lael-labs/executor

executor/apps/web/src/app/api/auth/anonymous-token/route.ts+9−4

 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
+import { z } from "zod";
+const anonymousTokenRequestSchema = z.object({
+  actorId: z.string().trim().min(1).optional(),
+});
 function toSiteUrl(convexUrl?: string): string | null {
   if (!convexUrl) {
   let body: { actorId?: string } = {};
   try {
-    const parsed = await request.json() as { actorId?: unknown };
+    const parsed = anonymousTokenRequestSchema.safeParse(await request.json());
-    if (typeof parsed.actorId === "string" && parsed.actorId.trim().length > 0) {
+    if (parsed.success && parsed.data.actorId) {
-      body.actorId = parsed.actorId.trim();
+      body.actorId = parsed.data.actorId;
     }
   } catch {
     body = {};
   });
   const text = await response.text();
-  let payload: unknown = null;
+  let payload: unknown;
   try {
     payload = JSON.parse(text);
   } catch {

executor/apps/web/src/lib/mcp/oauth-provider.test.ts+51−0

@@ -0,0 +1,51 @@
	1	import { expect, test } from "bun:test";
	2	import {
	3	decodePendingCookieValue,
	4	decodePopupResultCookieValue,
	5	encodePendingCookieValue,
	6	encodePopupResultCookieValue,
	7	type McpOAuthPending,
	8	type McpOAuthPopupResult,
	9	} from "./oauth-provider";
	10
	11	test("pending cookie round-trips with versioned envelope", () => {
	12	const pending: McpOAuthPending = {
	13	state: "state-123",
	14	sourceUrl: "https://example.com/mcp",
	15	redirectUrl: "https://app.example.com/oauth/callback",
	16	codeVerifier: "verifier-123",
	17	};
	18
	19	const encoded = encodePendingCookieValue(pending);
	20	expect(decodePendingCookieValue(encoded)).toEqual(pending);
	21	});
	22
	23	test("pending cookie decoder supports legacy payload shape", () => {
	24	const legacyPayload = {
	25	state: "legacy-state",
	26	sourceUrl: "https://legacy.example.com/mcp",
	27	redirectUrl: "https://legacy.example.com/callback",
	28	};
	29	const raw = Buffer.from(JSON.stringify(legacyPayload), "utf8").toString("base64url");
	30
	31	expect(decodePendingCookieValue(raw)).toEqual(legacyPayload);
	32	});
	33
	34	test("popup cookie round-trips with versioned envelope", () => {
	35	const result: McpOAuthPopupResult = {
	36	ok: true,
	37	sourceUrl: "https://example.com/mcp",
	38	accessToken: "token-123",
	39	refreshToken: "refresh-123",
	40	scope: "read write",
	41	expiresIn: 3600,
	42	};
	43
	44	const encoded = encodePopupResultCookieValue(result);
	45	expect(decodePopupResultCookieValue(encoded)).toEqual(result);
	46	});
	47
	48	test("popup cookie decoder rejects invalid payloads", () => {
	49	const invalidRaw = Buffer.from(JSON.stringify({ ok: "yes" }), "utf8").toString("base64url");
	50	expect(decodePopupResultCookieValue(invalidRaw)).toBeNull();
	51	});

executor/apps/web/src/lib/mcp/oauth-provider.ts+55−42

 import { randomUUID } from "node:crypto";
 import { Result } from "better-result";
+import { z } from "zod";
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type {
   OAuthClientInformationMixed,
 const COOKIE_PREFIX = "executor_mcp_oauth_";
 export const MCP_OAUTH_RESULT_COOKIE = "executor_mcp_oauth_result";
+const pendingSchema = z.object({
+  state: z.string(),
+  sourceUrl: z.string(),
+  redirectUrl: z.string(),
+  codeVerifier: z.string().optional(),
+  clientInformation: z.custom<OAuthClientInformationMixed>().optional(),
+});
+const versionedPendingSchema = z.object({
+  version: z.literal(1),
+  pending: pendingSchema,
+});
+const popupResultSchema = z.object({
+  ok: z.boolean(),
+  sourceUrl: z.string().optional(),
+  accessToken: z.string().optional(),
+  refreshToken: z.string().optional(),
+  scope: z.string().optional(),
+  expiresIn: z.number().optional(),
+  error: z.string().optional(),
+});
+const versionedPopupResultSchema = z.object({
+  version: z.literal(1),
+  result: popupResultSchema,
+});
+function decodeCookieJson(raw: string): unknown | null {
+  const decodedResult = Result.try(() => Buffer.from(raw, "base64url").toString("utf8"));
+  if (decodedResult.isErr()) {
+    return null;
+  }
+  const parsedResult = Result.try(() => JSON.parse(decodedResult.value));
+  return parsedResult.isOk() ? parsedResult.value : null;
+}
 export function buildPendingCookieName(state: string): string {
   return `${COOKIE_PREFIX}${state}`;
 }
 }
 export function encodePendingCookieValue(pending: McpOAuthPending): string {
-  return Buffer.from(JSON.stringify(pending), "utf8").toString("base64url");
+  return Buffer.from(JSON.stringify({ version: 1, pending }), "utf8").toString("base64url");
 }
 export function decodePendingCookieValue(raw: string): McpOAuthPending | null {
-  const decodedResult = Result.try(() => Buffer.from(raw, "base64url").toString("utf8"));
+  const decoded = decodeCookieJson(raw);
-  if (!decodedResult.isOk()) {
+  if (!decoded) {
-    return null;
-  }
-  const parsedResult = Result.try(() => JSON.parse(decodedResult.value) as Partial<McpOAuthPending>);
-  if (!parsedResult.isOk()) {
     return null;
   }
-  const parsed = parsedResult.value;
+  const versionedResult = versionedPendingSchema.safeParse(decoded);
-  if (
+  if (versionedResult.success) {
-    typeof parsed.state !== "string"
+    return versionedResult.data.pending;
-    || typeof parsed.sourceUrl !== "string"
-    || typeof parsed.redirectUrl !== "string"
-  ) {
-    return null;
   }
-  return {
+  const legacyResult = pendingSchema.safeParse(decoded);
-    state: parsed.state,
+  return legacyResult.success ? legacyResult.data : null;
-    sourceUrl: parsed.sourceUrl,
-    redirectUrl: parsed.redirectUrl,
-    ...(typeof parsed.codeVerifier === "string" ? { codeVerifier: parsed.codeVerifier } : {}),
-    ...(parsed.clientInformation ? { clientInformation: parsed.clientInformation } : {}),
-  };
 }
 export function encodePopupResultCookieValue(result: McpOAuthPopupResult): string {
-  return Buffer.from(JSON.stringify(result), "utf8").toString("base64url");
+  return Buffer.from(JSON.stringify({ version: 1, result }), "utf8").toString("base64url");
 }
 export function decodePopupResultCookieValue(raw: string): McpOAuthPopupResult | null {
-  const decodedResult = Result.try(() => Buffer.from(raw, "base64url").toString("utf8"));
+  const decoded = decodeCookieJson(raw);
-  if (!decodedResult.isOk()) {
+  if (!decoded) {
     return null;
   }
-  const parsedResult = Result.try(() => JSON.parse(decodedResult.value) as Partial<McpOAuthPopupResult>);
+  const versionedResult = versionedPopupResultSchema.safeParse(decoded);
-  if (!parsedResult.isOk()) {
+  if (versionedResult.success) {
-    return null;
+    return versionedResult.data.result;
-  }
-  const parsed = parsedResult.value;
-  if (typeof parsed.ok !== "boolean") {
-    return null;
   }
-  return {
+  const legacyResult = popupResultSchema.safeParse(decoded);
-    ok: parsed.ok,
+  return legacyResult.success ? legacyResult.data : null;
-    ...(typeof parsed.sourceUrl === "string" ? { sourceUrl: parsed.sourceUrl } : {}),
-    ...(typeof parsed.accessToken === "string" ? { accessToken: parsed.accessToken } : {}),
-    ...(typeof parsed.refreshToken === "string" ? { refreshToken: parsed.refreshToken } : {}),
-    ...(typeof parsed.scope === "string" ? { scope: parsed.scope } : {}),
-    ...(typeof parsed.expiresIn === "number" ? { expiresIn: parsed.expiresIn } : {}),
-    ...(typeof parsed.error === "string" ? { error: parsed.error } : {}),
-  };
 }
 export class McpPopupOAuthProvider implements OAuthClientProvider {

executor/apps/web/src/lib/openapi/spec-inspector.ts+58−34

@@ -1,4 +1,6 @@
		1	import { Result } from "better-result";
1	import { parse as parseYaml } from "yaml";	2	import { parse as parseYaml } from "yaml";
		3	import { z } from "zod";
2	import type { CredentialScope, SourceAuthType } from "@/lib/types";	4	import type { CredentialScope, SourceAuthType } from "@/lib/types";
3		5
4	type SupportedAuthType = Exclude<SourceAuthType, "none" \| "mixed">;	6	type SupportedAuthType = Exclude<SourceAuthType, "none" \| "mixed">;
@@ -15,11 +17,36 @@ type OpenApiInspectionResult = { · 10 unmodified lines
15	inferredAuth: InferredSpecAuth;	17	inferredAuth: InferredSpecAuth;
16	};	18	};
17		19
18	function asRecord(value: unknown): Record<string, unknown> {	20	const recordSchema = z.record(z.unknown());
19	if (!value \|\| typeof value !== "object" \|\| Array.isArray(value)) {	21
20	return {};	22	const securityRequirementSchema = z.record(z.array(z.unknown()).optional());
		23
		24	const securitySchemeSchema = z.object({
		25	type: z.string().optional(),
		26	scheme: z.string().optional(),
		27	in: z.string().optional(),
		28	name: z.string().optional(),
		29	});
		30
		31	function toRecordValue(value: unknown): Record<string, unknown> {
		32	const parsed = recordSchema.safeParse(value);
		33	return parsed.success ? parsed.data : {};
		34	}
		35
		36	function parseObjectFromText(text: string, format: "json" \| "yaml"): Record<string, unknown> \| null {
		37	const parsed = format === "json"
		38	? Result.try(() => JSON.parse(text))
		39	: Result.try(() => parseYaml(text));
		40	if (parsed.isErr()) {
		41	return null;
		42	}
		43
		44	const parsedRecord = recordSchema.safeParse(parsed.value);
		45	if (!parsedRecord.success \|\| Object.keys(parsedRecord.data).length === 0) {
		46	return null;
21	}	47	}
22	return value as Record<string, unknown>;	48
		49	return parsedRecord.data;
23	}	50	}
24		51
25	function parseOpenApiPayload(raw: string, sourceUrl: string, contentType: string): Record<string, unknown> {	52	function parseOpenApiPayload(raw: string, sourceUrl: string, contentType: string): Record<string, unknown> {
@@ -27,40 +54,34 @@ function parseOpenApiPayload(raw: string, sourceUrl: string, contentType: string · 1 unmodified line
27	const loweredUrl = sourceUrl.toLowerCase();	54	const loweredUrl = sourceUrl.toLowerCase();
28	const preferJson = loweredContentType.includes("json") \|\| loweredUrl.endsWith(".json");	55	const preferJson = loweredContentType.includes("json") \|\| loweredUrl.endsWith(".json");
29		56
30	const tryJson = () => asRecord(JSON.parse(raw));	57	const primary = preferJson
31	const tryYaml = () => asRecord(parseYaml(raw));	58	? parseObjectFromText(raw, "json")
32		59	: parseObjectFromText(raw, "yaml");
33	const parsed = preferJson	60	const fallback = preferJson
34	? (() => {	61	? parseObjectFromText(raw, "yaml")
35	try {	62	: parseObjectFromText(raw, "json");
36	return tryJson();	63	const parsed = primary ?? fallback;
37	} catch {	64
38	return tryYaml();	65	if (!parsed) {
39	}
40	})()
41	: (() => {
42	try {
43	return tryYaml();
44	} catch {
45	return tryJson();
46	}
47	})();
48
49	if (Object.keys(parsed).length === 0) {
50	throw new Error("Spec payload is empty or not an object");	66	throw new Error("Spec payload is empty or not an object");
51	}	67	}
52		68
53	return parsed;	69	return parsed;
54	}	70	}
55		71
56	function normalizeAuthScheme(scheme: Record<string, unknown>): {	72	function normalizeAuthScheme(scheme: unknown): {
57	type: SupportedAuthType;	73	type: SupportedAuthType;
58	header?: string;	74	header?: string;
59	} \| null {	75	} \| null {
60	const type = String(scheme.type ?? "").toLowerCase();	76	const parsedScheme = securitySchemeSchema.safeParse(scheme);
		77	if (!parsedScheme.success) {
		78	return null;
		79	}
		80
		81	const type = (parsedScheme.data.type ?? "").toLowerCase();
61		82
62	if (type === "http") {	83	if (type === "http") {
63	const httpScheme = String(scheme.scheme ?? "").toLowerCase();	84	const httpScheme = (parsedScheme.data.scheme ?? "").toLowerCase();
64	if (httpScheme === "bearer") {	85	if (httpScheme === "bearer") {
65	return { type: "bearer" };	86	return { type: "bearer" };
66	}	87	}
@@ -71,8 +92,8 @@ function normalizeAuthScheme(scheme: Record<string, unknown>): { · 4 unmodified lines
71	}	92	}
72		93
73	if (type === "apikey") {	94	if (type === "apikey") {
74	const location = String(scheme.in ?? "").toLowerCase();	95	const location = (parsedScheme.data.in ?? "").toLowerCase();
75	const header = typeof scheme.name === "string" ? scheme.name.trim() : "";	96	const header = (parsedScheme.data.name ?? "").trim();
76	if (location === "header" && header.length > 0) {	97	if (location === "header" && header.length > 0) {
77	return { type: "apiKey", header };	98	return { type: "apiKey", header };
78	}	99	}
@@ -87,23 +108,26 @@ function normalizeAuthScheme(scheme: Record<string, unknown>): { · 8 unmodified lines
87	}	108	}
88		109
89	function inferSecuritySchemaAuth(spec: Record<string, unknown>): InferredSpecAuth {	110	function inferSecuritySchemaAuth(spec: Record<string, unknown>): InferredSpecAuth {
90	const components = asRecord(spec.components);	111	const components = toRecordValue(spec.components);
91	const securitySchemes = asRecord(components.securitySchemes);	112	const securitySchemes = toRecordValue(components.securitySchemes);
92	const schemeNames = Object.keys(securitySchemes);	113	const schemeNames = Object.keys(securitySchemes);
93	if (schemeNames.length === 0) {	114	if (schemeNames.length === 0) {
94	return { type: "none", inferred: true };	115	return { type: "none", inferred: true };
95	}	116	}
96		117
97	const globalSecurity = Array.isArray(spec.security)	118	const globalSecurity = Array.isArray(spec.security)
98	? spec.security.filter((entry): entry is Record<string, unknown> => Boolean(entry && typeof entry === "object"))	119	? spec.security.flatMap((entry) => {
		120	const parsed = securityRequirementSchema.safeParse(entry);
		121	return parsed.success ? [parsed.data] : [];
		122	})
99	: [];	123	: [];
100	const referencedSchemeNames = globalSecurity.flatMap((entry) => Object.keys(entry));	124	const referencedSchemeNames = globalSecurity.flatMap((entry) => Object.keys(entry));
101	const candidateNames = referencedSchemeNames.length > 0	125	const candidateNames = referencedSchemeNames.length > 0
102	? [...new Set(referencedSchemeNames.filter((name) => typeof securitySchemes[name] === "object"))]	126	? [...new Set(referencedSchemeNames.filter((name) => Object.prototype.hasOwnProperty.call(securitySchemes, name)))]
103	: schemeNames;	127	: schemeNames;
104		128
105	const normalized = candidateNames	129	const normalized = candidateNames
106	.map((name) => normalizeAuthScheme(asRecord(securitySchemes[name])))	130	.map((name) => normalizeAuthScheme(securitySchemes[name]))
107	.filter((entry): entry is NonNullable<typeof entry> => Boolean(entry));	131	.filter((entry): entry is NonNullable<typeof entry> => Boolean(entry));
108		132
109	if (normalized.length === 0) {	133	if (normalized.length === 0) {

executor/apps/web/src/lib/session-storage.ts+49−5

@@ -1,9 +1,16 @@
1	import type { Id } from "@executor/database/convex/_generated/dataModel";	1	import type { Id } from "@executor/database/convex/_generated/dataModel";
		2	import { z } from "zod";
2		3
3	const SESSION_KEY = "executor_session_id";	4	const SESSION_KEY = "executor_session_id";
4	const ACTIVE_WORKSPACE_KEY = "executor_active_workspace_id";	5	const ACTIVE_WORKSPACE_KEY = "executor_active_workspace_id";
5	const ACTIVE_WORKSPACE_BY_ACCOUNT_KEY = "executor_active_workspace_by_account";	6	const ACTIVE_WORKSPACE_BY_ACCOUNT_KEY = "executor_active_workspace_by_account";
6		7
		8	const workspaceByAccountSchema = z.record(z.string());
		9
		10	function isWorkspaceId(value: string): value is Id<"workspaces"> {
		11	return value.trim().length > 0;
		12	}
		13
7	export function readStoredSessionId() {	14	export function readStoredSessionId() {
8	if (typeof window === "undefined") {	15	if (typeof window === "undefined") {
9	return null;	16	return null;
@@ -17,7 +24,12 @@ export function readStoredActiveWorkspaceId() { · 7 unmodified lines
17	return null;	24	return null;
18	}	25	}
19		26
20	return localStorage.getItem(ACTIVE_WORKSPACE_KEY) as Id<"workspaces"> \| null;	27	const stored = localStorage.getItem(ACTIVE_WORKSPACE_KEY);
		28	if (!stored \|\| !isWorkspaceId(stored)) {
		29	return null;
		30	}
		31
		32	return stored;
21	}	33	}
22		34
23	export function persistSessionId(sessionId: string) {	35	export function persistSessionId(sessionId: string) {
@@ -33,18 +45,50 @@ export function clearSessionStorage() { · 9 unmodified lines
33	localStorage.removeItem(ACTIVE_WORKSPACE_KEY);	45	localStorage.removeItem(ACTIVE_WORKSPACE_KEY);
34	}	46	}
35		47
36	export function readWorkspaceByAccount() {	48	export function readWorkspaceByAccount(): Record<string, Id<"workspaces">> {
		49	if (typeof window === "undefined") {
		50	return {};
		51	}
		52
37	const raw = localStorage.getItem(ACTIVE_WORKSPACE_BY_ACCOUNT_KEY);	53	const raw = localStorage.getItem(ACTIVE_WORKSPACE_BY_ACCOUNT_KEY);
38	if (!raw) {	54	if (!raw) {
39	return {} as Record<string, Id<"workspaces">>;	55	return {};
40	}	56	}
41		57
		58	let parsedJson: unknown;
42	try {	59	try {
43	const parsed = JSON.parse(raw) as Record<string, Id<"workspaces">>;	60	parsedJson = JSON.parse(raw);
44	return parsed ?? {};
45	} catch {	61	} catch {
46	return {};	62	return {};
47	}	63	}
		64
		65	const parsedMap = workspaceByAccountSchema.safeParse(parsedJson);
		66	if (!parsedMap.success) {
		67	return {};
		68	}
		69
		70	let changed = false;
		71	const cleaned: Record<string, Id<"workspaces">> = {};
		72	for (const [accountIdRaw, workspaceIdRaw] of Object.entries(parsedMap.data)) {
		73	const accountId = accountIdRaw.trim();
		74	const workspaceId = workspaceIdRaw.trim();
		75	if (!accountId \|\| !isWorkspaceId(workspaceId)) {
		76	changed = true;
		77	continue;
		78	}
		79
		80	if (accountId !== accountIdRaw \|\| workspaceId !== workspaceIdRaw) {
		81	changed = true;
		82	}
		83
		84	cleaned[accountId] = workspaceId;
		85	}
		86
		87	if (changed) {
		88	writeWorkspaceByAccount(cleaned);
		89	}
		90
		91	return cleaned;
48	}	92	}
49		93
50	function writeWorkspaceByAccount(value: Record<string, Id<"workspaces">>) {	94	function writeWorkspaceByAccount(value: Record<string, Id<"workspaces">>) {

executor/apps/web/src/lib/types.ts+22−3

 export type TaskStatus = "queued" | "running" | "completed" | "failed" | "timed_out" | "denied";
 export type ApprovalStatus = "pending" | "approved" | "denied";
 export type PolicyDecision = "allow" | "require_approval" | "deny";
+export type PolicyScopeType = "organization" | "workspace";
+export type PolicyMatchType = "glob" | "exact";
+export type PolicyEffect = "allow" | "deny";
+export type PolicyApprovalMode = "inherit" | "auto" | "required";
 export type CredentialScope = "workspace" | "actor";
 export type CredentialProvider = "local-convex" | "workos-vault";
+export type OwnerScopeType = "organization" | "workspace";
 export type ToolApprovalMode = "auto" | "required";
 export type ToolSourceType = "mcp" | "openapi" | "graphql";
 export interface AccessPolicyRecord {
   id: string;
-  workspaceId: string;
+  scopeType?: PolicyScopeType;
+  organizationId?: string;
+  workspaceId?: string;
+  targetActorId?: string;
   actorId?: string;
   clientId?: string;
+  resourceType?: "tool_path";
+  resourcePattern?: string;
+  matchType?: PolicyMatchType;
+  effect?: PolicyEffect;
+  approvalMode?: PolicyApprovalMode;
   toolPathPattern: string;
   decision: PolicyDecision;
   priority: number;
 export interface CredentialRecord {
   id: string;
   bindingId?: string;
-  workspaceId: string;
+  ownerScopeType?: OwnerScopeType;
+  organizationId?: string;
+  workspaceId?: string;
   sourceKey: string;
   scope: CredentialScope;
   actorId?: string;
 export interface ToolSourceRecord {
   id: string;
-  workspaceId: string;
+  ownerScopeType?: OwnerScopeType;
+  organizationId?: string;
+  workspaceId?: string;
   name: string;
   type: ToolSourceType;
   config: Record<string, unknown>;
+  specHash?: string;
+  authFingerprint?: string;
   enabled: boolean;
   createdAt: number;
   updatedAt: number;

executor/packages/core/src/credential-providers.test.ts+30−1

@@ -1,5 +1,5 @@
1	import { expect, test } from "bun:test";	1	import { expect, test } from "bun:test";
2	import { resolveCredentialPayload } from "./credential-providers";	2	import { resolveCredentialPayload, resolveCredentialPayloadResult } from "./credential-providers";
3		3
4	test("local provider returns stored payload", async () => {	4	test("local provider returns stored payload", async () => {
5	const payload = await resolveCredentialPayload({	5	const payload = await resolveCredentialPayload({
@@ -46,6 +46,23 @@ test("WorkOS Vault provider falls back to id key and raw token", async () => { · 40 unmodified lines
46	expect(payload).toEqual({ token: "ghp_raw_token" });	46	expect(payload).toEqual({ token: "ghp_raw_token" });
47	});	47	});
48		48
		49	test("WorkOS Vault provider parses env-style key/value payloads", async () => {
		50	const payload = await resolveCredentialPayload(
		51	{
		52	provider: "workos-vault",
		53	secretJson: { objectId: "secret_789" },
		54	},
		55	{
		56	readVaultObject: async ({ objectId }) => {
		57	expect(objectId).toBe("secret_789");
		58	return "TOKEN=vault-token\nHEADER_NAME=\"x-api-key\"";
		59	},
		60	},
		61	);
		62
		63	expect(payload).toEqual({ TOKEN: "vault-token", HEADER_NAME: "x-api-key" });
		64	});
		65
49	test("WorkOS Vault provider gives actionable error on missing reference", async () => {	66	test("WorkOS Vault provider gives actionable error on missing reference", async () => {
50	await expect(	67	await expect(
51	resolveCredentialPayload({	68	resolveCredentialPayload({
@@ -54,3 +71,15 @@ test("WorkOS Vault provider gives actionable error on missing reference", async · 2 unmodified lines
54	}),	71	}),
55	).rejects.toThrow("Re-save this credential");	72	).rejects.toThrow("Re-save this credential");
56	});	73	});
		74
		75	test("resolveCredentialPayloadResult returns Err for missing WorkOS reference", async () => {
		76	const result = await resolveCredentialPayloadResult({
		77	provider: "workos-vault",
		78	secretJson: {},
		79	});
		80
		81	expect(result.isErr()).toBe(true);
		82	if (result.isErr()) {
		83	expect(result.error.message).toContain("Re-save this credential");
		84	}
		85	});

executor/packages/core/src/credential-providers.ts+100−71

@@ -1,10 +1,13 @@
1	"use node";	1	"use node";
2		2
3	import { WorkOS } from "@workos-inc/node";
4	import { Result } from "better-result";	3	import { Result } from "better-result";
5	import { z } from "zod";	4	import { z } from "zod";
		5	import {
		6	createWorkosClient,
		7	parseWorkosVaultReference,
		8	withWorkosVaultRetryResult,
		9	} from "./credentials/workos-vault";
6	import type { CredentialProvider, CredentialRecord } from "./types";	10	import type { CredentialProvider, CredentialRecord } from "./types";
7	import { asRecord } from "./utils";
8		11
9	type CredentialPayload = Record<string, unknown>;	12	type CredentialPayload = Record<string, unknown>;
10		13
@@ -18,67 +21,31 @@ type VaultObjectReader = (input: VaultReadInput) => Promise<string>; · 7 unmodified lines
18	type ProviderResolver = (	21	type ProviderResolver = (
19	record: Pick<CredentialRecord, "provider" \| "secretJson">,	22	record: Pick<CredentialRecord, "provider" \| "secretJson">,
20	readVaultObject: VaultObjectReader,	23	readVaultObject: VaultObjectReader,
21	) => Promise<CredentialPayload \| null>;	24	) => Promise<Result<CredentialPayload \| null, Error>>;
22		25
23	const workosVaultSecretConfigSchema = z.object({	26	const recordSchema = z.record(z.unknown());
24	objectId: z.string().optional(),
25	id: z.string().optional(),
26	apiKey: z.string().optional(),
27	});
28		27
29	function resolveWorkosApiKey(explicitApiKey?: string): string {	28	function coerceRecord(value: unknown): Record<string, unknown> {
30	const candidate =	29	const parsed = recordSchema.safeParse(value);
31	explicitApiKey?.trim() \|\|	30	return parsed.success ? parsed.data : {};
32	process.env.WORKOS_API_KEY?.trim() \|\|
33	"";
34
35	if (!candidate) {
36	throw new Error("WorkOS Vault provider requires WORKOS_API_KEY");
37	}
38
39	return candidate;
40	}	31	}
41		32
42	function isRetryableVaultError(error: unknown): boolean {	33	const envSecretKeySchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
43	if (!(error instanceof Error)) {
44	return false;
45	}
46	const message = error.message.toLowerCase();
47	return (
48	message.includes("not yet ready") \|\|
49	message.includes("can be retried") \|\|
50	(message.includes("kek") && message.includes("ready"))
51	);
52	}
53		34
54	async function sleep(ms: number): Promise<void> {	35	async function defaultReadVaultObject(input: VaultReadInput): Promise<string> {
55	await new Promise((resolve) => setTimeout(resolve, ms));	36	const workosResult = createWorkosClient(input.apiKey);
56	}	37	if (workosResult.isErr()) {
57		38	throw new Error("WorkOS Vault provider requires WORKOS_API_KEY");
58	async function withVaultRetry<T>(operation: () => Promise<T>): Promise<T> {
59	const maxAttempts = 5;
60	let delayMs = 250;
61
62	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
63	try {
64	return await operation();
65	} catch (error) {
66	if (!isRetryableVaultError(error) \|\| attempt === maxAttempts) {
67	throw error;
68	}
69	await sleep(delayMs);
70	delayMs *= 2;
71	}
72	}	39	}
73		40
74	throw new Error("Unreachable retry state");	41	const readResult = await withWorkosVaultRetryResult(async () => {
75	}	42	return await workosResult.value.vault.readObject({ id: input.objectId });
76
77	async function defaultReadVaultObject(input: VaultReadInput): Promise<string> {
78	const workos = new WorkOS(resolveWorkosApiKey(input.apiKey));
79	const object = await withVaultRetry(async () => {
80	return await workos.vault.readObject({ id: input.objectId });
81	});	43	});
		44	if (readResult.isErr()) {
		45	throw readResult.error;
		46	}
		47
		48	const object = readResult.value;
82	const value = typeof object.value === "string" ? object.value : "";	49	const value = typeof object.value === "string" ? object.value : "";
83	if (!value.trim()) {	50	if (!value.trim()) {
84	throw new Error(`WorkOS Vault object '${input.objectId}' returned an empty value`);	51	throw new Error(`WorkOS Vault object '${input.objectId}' returned an empty value`);
@@ -92,41 +59,91 @@ function parseSecretValue(raw: string): CredentialPayload { · 7 unmodified lines
92	return {};	59	return {};
93	}	60	}
94		61
95	const parsedJson = Result.try(() => JSON.parse(value));	62	try {
96	if (parsedJson.isOk()) {	63	const parsed = JSON.parse(value);
97	const parsed = parsedJson.value;	64	const asObject = coerceRecord(parsed);
98	const asObject = asRecord(parsed);
99	if (Object.keys(asObject).length > 0) {	65	if (Object.keys(asObject).length > 0) {
100	return asObject;	66	return asObject;
101	}	67	}
		68	} catch {
		69	// Continue with env-style and token fallback parsing.
		70	}
		71
		72	const envStyleResult = parseEnvStyleSecret(value);
		73	if (envStyleResult) {
		74	return envStyleResult;
102	}	75	}
103		76
104	return { token: value };	77	return { token: value };
105	}	78	}
106		79
		80	function stripWrappingQuotes(value: string): string {
		81	if (value.length < 2) {
		82	return value;
		83	}
		84
		85	const startsWithSingle = value.startsWith("'") && value.endsWith("'");
		86	const startsWithDouble = value.startsWith('"') && value.endsWith('"');
		87	return startsWithSingle \|\| startsWithDouble ? value.slice(1, -1) : value;
		88	}
		89
		90	function parseEnvStyleSecret(raw: string): CredentialPayload \| null {
		91	const lines = raw
		92	.split(/\r?\n/)
		93	.map((line) => line.trim())
		94	.filter((line) => line.length > 0 && !line.startsWith("#"));
		95	if (lines.length === 0) {
		96	return null;
		97	}
		98
		99	const parsedPayload: CredentialPayload = {};
		100	for (const line of lines) {
		101	const separatorIndex = line.indexOf("=");
		102	if (separatorIndex <= 0) {
		103	return null;
		104	}
		105
		106	const keyRaw = line.slice(0, separatorIndex).trim();
		107	const keyResult = envSecretKeySchema.safeParse(keyRaw);
		108	if (!keyResult.success) {
		109	return null;
		110	}
		111
		112	const valueRaw = line.slice(separatorIndex + 1).trim();
		113	parsedPayload[keyResult.data] = stripWrappingQuotes(valueRaw);
		114	}
		115
		116	return Object.keys(parsedPayload).length > 0 ? parsedPayload : null;
		117	}
		118
107	async function resolveLocalConvex(	119	async function resolveLocalConvex(
108	record: Pick<CredentialRecord, "secretJson">,	120	record: Pick<CredentialRecord, "secretJson">,
109	): Promise<CredentialPayload \| null> {	121	): Promise<Result<CredentialPayload \| null, Error>> {
110	return asRecord(record.secretJson);	122	return Result.ok(coerceRecord(record.secretJson));
111	}	123	}
112		124
113	async function resolveWorkosVault(	125	async function resolveWorkosVault(
114	record: Pick<CredentialRecord, "secretJson">,	126	record: Pick<CredentialRecord, "secretJson">,
115	readVaultObject: VaultObjectReader,	127	readVaultObject: VaultObjectReader,
116	): Promise<CredentialPayload \| null> {	128	): Promise<Result<CredentialPayload \| null, Error>> {
117	const parsedConfig = workosVaultSecretConfigSchema.safeParse(asRecord(record.secretJson));	129	const parsedReference = parseWorkosVaultReference(coerceRecord(record.secretJson));
118	const config = parsedConfig.success ? parsedConfig.data : {};	130	const objectId = parsedReference.objectId ?? "";
119	const objectId = config.objectId?.trim() \|\| config.id?.trim() \|\| "";
120		131
121	if (!objectId) {	132	if (!objectId) {
122	throw new Error(	133	return Result.err(
123	"Encrypted credential is missing its secure reference. Re-save this credential in the dashboard.",	134	new Error("Encrypted credential is missing its secure reference. Re-save this credential in the dashboard."),
124	);	135	);
125	}	136	}
126	const apiKey = config.apiKey?.trim() \|\| undefined;	137	const apiKey = parsedReference.apiKey;
127		138
128	const raw = await readVaultObject({ objectId, apiKey });	139	const rawResult = await Result.tryPromise(async () => {
129	return parseSecretValue(raw);	140	return await readVaultObject({ objectId, apiKey });
		141	});
		142	if (rawResult.isErr()) {
		143	return Result.err(new Error(rawResult.error.message));
		144	}
		145
		146	return Result.ok(parseSecretValue(rawResult.value));
130	}	147	}
131		148
132	const providers: Record<CredentialProvider, ProviderResolver> = {	149	const providers: Record<CredentialProvider, ProviderResolver> = {
@@ -138,10 +155,22 @@ export async function resolveCredentialPayload( · 5 unmodified lines
138	record: Pick<CredentialRecord, "provider" \| "secretJson">,	155	record: Pick<CredentialRecord, "provider" \| "secretJson">,
139	options?: { readVaultObject?: VaultObjectReader },	156	options?: { readVaultObject?: VaultObjectReader },
140	): Promise<CredentialPayload \| null> {	157	): Promise<CredentialPayload \| null> {
		158	const resolved = await resolveCredentialPayloadResult(record, options);
		159	if (resolved.isErr()) {
		160	throw resolved.error;
		161	}
		162
		163	return resolved.value;
		164	}
		165
		166	export async function resolveCredentialPayloadResult(
		167	record: Pick<CredentialRecord, "provider" \| "secretJson">,
		168	options?: { readVaultObject?: VaultObjectReader },
		169	): Promise<Result<CredentialPayload \| null, Error>> {
141	const provider = record.provider;	170	const provider = record.provider;
142	const resolver = providers[provider];	171	const resolver = providers[provider];
143	if (!resolver) {	172	if (!resolver) {
144	throw new Error(`Unsupported credential provider: ${provider}`);	173	return Result.err(new Error(`Unsupported credential provider: ${provider}`));
145	}	174	}
146		175
147	return await resolver(record, options?.readVaultObject ?? defaultReadVaultObject);	176	return await resolver(record, options?.readVaultObject ?? defaultReadVaultObject);

executor/packages/core/src/credentials/workos-vault.test.ts+64−0

@@ -0,0 +1,64 @@
	1	import { expect, test } from "bun:test";
	2	import {
	3	extractWorkosVaultObjectId,
	4	isWorkosVaultRetryableError,
	5	parseWorkosVaultReference,
	6	withWorkosVaultRetryResult,
	7	} from "./workos-vault";
	8
	9	test("parseWorkosVaultReference normalizes object id aliases", () => {
	10	expect(parseWorkosVaultReference({ objectId: " secret_123 " })).toEqual({ objectId: "secret_123" });
	11	expect(parseWorkosVaultReference({ id: "secret_456", apiKey: " key_abc " })).toEqual({
	12	objectId: "secret_456",
	13	apiKey: "key_abc",
	14	});
	15	expect(parseWorkosVaultReference("not-an-object")).toEqual({});
	16	});
	17
	18	test("extractWorkosVaultObjectId returns null when missing", () => {
	19	expect(extractWorkosVaultObjectId({ apiKey: "key" })).toBeNull();
	20	expect(extractWorkosVaultObjectId({ id: "secret_789" })).toBe("secret_789");
	21	});
	22
	23	test("isWorkosVaultRetryableError detects retryable vault messages", () => {
	24	expect(isWorkosVaultRetryableError(new Error("KEK not yet ready"))).toBe(true);
	25	expect(isWorkosVaultRetryableError(new Error("This can be retried"))).toBe(true);
	26	expect(isWorkosVaultRetryableError(new Error("Permission denied"))).toBe(false);
	27	});
	28
	29	test("withWorkosVaultRetryResult retries retryable errors and succeeds", async () => {
	30	let attempts = 0;
	31	const result = await withWorkosVaultRetryResult(async () => {
	32	attempts += 1;
	33	if (attempts < 3) {
	34	throw new Error("KEK not yet ready");
	35	}
	36	return "ok";
	37	}, {
	38	maxAttempts: 5,
	39	initialDelayMs: 0,
	40	maxDelayMs: 1,
	41	});
	42
	43	expect(result.isOk()).toBe(true);
	44	if (result.isOk()) {
	45	expect(result.value).toBe("ok");
	46	}
	47	expect(attempts).toBe(3);
	48	});
	49
	50	test("withWorkosVaultRetryResult returns configured exhaustion error", async () => {
	51	const result = await withWorkosVaultRetryResult(async () => {
	52	throw new Error("can be retried");
	53	}, {
	54	maxAttempts: 2,
	55	initialDelayMs: 0,
	56	maxDelayMs: 1,
	57	exhaustionErrorMessage: "still warming up",
	58	});
	59
	60	expect(result.isErr()).toBe(true);
	61	if (result.isErr()) {
	62	expect(result.error.message).toBe("still warming up");
	63	}
	64	});

executor/packages/core/src/credentials/workos-vault.ts+128−0

@@ -0,0 +1,128 @@
	1	"use node";
	2
	3	import { WorkOS } from "@workos-inc/node";
	4	import { Result } from "better-result";
	5	import { z } from "zod";
	6
	7	const workosVaultReferenceSchema = z.object({
	8	objectId: z.string().optional(),
	9	id: z.string().optional(),
	10	apiKey: z.string().optional(),
	11	});
	12
	13	function normalizeUnknownError(error: unknown): Error {
	14	return error instanceof Error ? error : new Error(String(error));
	15	}
	16
	17	function normalizeDelayMs(value: number, fallback: number): number {
	18	if (!Number.isFinite(value) \|\| value < 0) {
	19	return fallback;
	20	}
	21	return Math.floor(value);
	22	}
	23
	24	function normalizeAttempts(value: number, fallback: number): number {
	25	if (!Number.isFinite(value) \|\| value < 1) {
	26	return fallback;
	27	}
	28	return Math.floor(value);
	29	}
	30
	31	export function parseWorkosVaultReference(value: unknown): {
	32	objectId?: string;
	33	apiKey?: string;
	34	} {
	35	const parsed = workosVaultReferenceSchema.safeParse(value);
	36	if (!parsed.success) {
	37	return {};
	38	}
	39
	40	const objectId = (parsed.data.objectId ?? parsed.data.id ?? "").trim();
	41	const apiKey = (parsed.data.apiKey ?? "").trim();
	42
	43	return {
	44	...(objectId ? { objectId } : {}),
	45	...(apiKey ? { apiKey } : {}),
	46	};
	47	}
	48
	49	export function extractWorkosVaultObjectId(value: unknown): string \| null {
	50	const parsed = parseWorkosVaultReference(value);
	51	return parsed.objectId ?? null;
	52	}
	53
	54	export function resolveWorkosApiKey(explicitApiKey?: string): Result<string, Error> {
	55	const candidate = explicitApiKey?.trim() \|\| process.env.WORKOS_API_KEY?.trim() \|\| "";
	56	if (!candidate) {
	57	return Result.err(new Error("Encrypted storage requires WORKOS_API_KEY"));
	58	}
	59
	60	return Result.ok(candidate);
	61	}
	62
	63	export function createWorkosClient(explicitApiKey?: string): Result<WorkOS, Error> {
	64	const apiKeyResult = resolveWorkosApiKey(explicitApiKey);
	65	if (apiKeyResult.isErr()) {
	66	return apiKeyResult;
	67	}
	68
	69	return Result.ok(new WorkOS(apiKeyResult.value));
	70	}
	71
	72	export function isWorkosVaultRetryableError(error: unknown): boolean {
	73	if (!(error instanceof Error)) {
	74	return false;
	75	}
	76
	77	const message = error.message.toLowerCase();
	78	return (
	79	message.includes("not yet ready")
	80	\|\| message.includes("can be retried")
	81	\|\| (message.includes("kek") && message.includes("ready"))
	82	);
	83	}
	84
	85	async function sleep(ms: number): Promise<void> {
	86	await new Promise((resolve) => setTimeout(resolve, ms));
	87	}
	88
	89	export interface WorkosVaultRetryOptions {
	90	maxAttempts?: number;
	91	initialDelayMs?: number;
	92	maxDelayMs?: number;
	93	exhaustionErrorMessage?: string;
	94	}
	95
	96	export async function withWorkosVaultRetryResult<T>(
	97	operation: () => Promise<T>,
	98	options: WorkosVaultRetryOptions = {},
	99	): Promise<Result<T, Error>> {
	100	const maxAttempts = normalizeAttempts(options.maxAttempts ?? 5, 5);
	101	const maxDelayMs = normalizeDelayMs(options.maxDelayMs ?? 10_000, 10_000);
	102	let delayMs = normalizeDelayMs(options.initialDelayMs ?? 250, 250);
	103
	104	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
	105	const valueResult = await Result.tryPromise(operation);
	106	if (valueResult.isOk()) {
	107	return valueResult;
	108	}
	109
	110	const cause = valueResult.error.cause;
	111	const normalizedError = normalizeUnknownError(cause);
	112	if (!isWorkosVaultRetryableError(normalizedError)) {
	113	return Result.err(normalizedError);
	114	}
	115
	116	if (attempt === maxAttempts) {
	117	if (options.exhaustionErrorMessage) {
	118	return Result.err(new Error(options.exhaustionErrorMessage));
	119	}
	120	return Result.err(normalizedError);
	121	}
	122
	123	await sleep(delayMs);
	124	delayMs = Math.min(Math.max(0, delayMs * 2), maxDelayMs);
	125	}
	126
	127	return Result.err(new Error("WorkOS Vault retry loop exhausted unexpectedly"));
	128	}

executor/packages/core/src/graphql/field-tools.ts+10−3

 import type { GraphqlExecutionEnvelope } from "../tool/source-execution";
-import { asRecord } from "../utils";
+import { z } from "zod";
+const recordSchema = z.record(z.unknown());
+function coerceRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 export interface GqlTypeRef {
   kind: string;
   envelope: GraphqlExecutionEnvelope,
   operationName: string,
 ): GraphqlExecutionEnvelope {
-  const record = asRecord(envelope.data);
+  const record = coerceRecord(envelope.data);
   if (Object.prototype.hasOwnProperty.call(record, operationName)) {
     return {
       data: record[operationName],
         && typeof value === "object"
         && !Array.isArray(value)
       ) {
-        const nested = asRecord(value);
+          const nested = coerceRecord(value);
         if (Object.keys(nested).length === 1 && Object.prototype.hasOwnProperty.call(nested, argName)) {
           return { [argName]: nested[argName] };
         }

executor/packages/core/src/managed/runtime-bootstrap.ts+2−1

@@ -82,9 +82,10 @@ async function getConfiguredFunctionsPath(candidate: string): Promise<string \| n · 81 unmodified lines
82	try {	82	try {
83	const raw = await fs.readFile(path.join(candidate, "convex.json"), "utf8");	83	const raw = await fs.readFile(path.join(candidate, "convex.json"), "utf8");
84	const parsed = convexJsonSchema.safeParse(JSON.parse(raw));	84	const parsed = convexJsonSchema.safeParse(JSON.parse(raw));
85	if (!parsed.success \|\| typeof parsed.data.functions !== "string") {	85	if (!parsed.success \|\| !parsed.data.functions) {
86	return null;	86	return null;
87	}	87	}
		88
88	const value = parsed.data.functions.trim();	89	const value = parsed.data.functions.trim();
89	return value.length > 0 ? value : null;	90	return value.length > 0 ? value : null;
90	} catch {	91	} catch {

executor/packages/core/src/managed/runtime-info.ts+7−5

 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { Result } from "better-result";
 import { z } from "zod";
 import type { ManagedRuntimeConfig, ManagedRuntimeInfo } from "../managed-runtime";
 export async function ensureConfig(info: ManagedRuntimeInfo): Promise<ManagedRuntimeConfig> {
   if (await pathExists(info.configPath)) {
     const raw = await fs.readFile(info.configPath, "utf8");
-    const parsedResult = Result.try(() => JSON.parse(raw));
+    let parsedValue: unknown;
-    const parsed = parsedResult.isOk()
+    try {
-      ? parseManagedRuntimeConfig(parsedResult.value)
+      parsedValue = JSON.parse(raw);
-      : null;
+    } catch {
+      parsedValue = null;
+    }
+    const parsed = parseManagedRuntimeConfig(parsedValue);
     if (!parsed) {
       const config = defaultConfig();

executor/packages/core/src/mcp/server-approval.ts+14−12

   McpExecutorService,
 } from "./server-contracts";
 import { getTaskTerminalState } from "./server-utils";
-import { asRecord } from "../utils";
 const elicitationResponseSchema = z.object({
   action: z.enum(["accept", "decline", "cancel"]),
   }).optional(),
 });
+const subscriptionEventPayloadSchema = z.object({
+  status: z.string().optional(),
+  pendingApprovalCount: z.coerce.number().optional(),
+});
 function formatApprovalInput(input: unknown, maxLength = 2000): string {
   let serialized: string;
   try {
     }
     const action = parsedResponse.data.action;
-    const content = asRecord(parsedResponse.data.content);
+    const content = parsedResponse.data.content;
     if (action !== "accept") {
       return {
       };
     }
-    const selectedDecision = content.decision;
+    const selectedDecision = content?.decision;
     const decision = selectedDecision === "approved" ? "approved" : "denied";
-    const selectedReason = content.reason;
+    const selectedReason = content?.reason?.trim();
-    const reason = typeof selectedReason === "string" && selectedReason.trim().length > 0
+    const reason = selectedReason && selectedReason.length > 0 ? selectedReason : undefined;
-      ? selectedReason
-      : undefined;
     return { decision, reason };
   };
     };
     unsubscribe = service.subscribe(taskId, workspaceId, (event) => {
-      const payload = asRecord(event.payload);
+      const parsedPayload = subscriptionEventPayloadSchema.safeParse(event.payload);
-      const type = typeof payload.status === "string" ? payload.status : undefined;
+      const type = parsedPayload.success ? parsedPayload.data.status : undefined;
-      const pendingApprovalCount = typeof payload.pendingApprovalCount === "number"
+      const pendingApprovalCount = parsedPayload.success
-        ? payload.pendingApprovalCount
+        ? (parsedPayload.data.pendingApprovalCount ?? 0)
         : 0;
-      if (typeof type === "string" && getTaskTerminalState(type)) {
+      if (type && getTaskTerminalState(type)) {
         void done();
         return;
       }

executor/packages/core/src/openapi-auth.ts+7−3

 import type { OpenApiAuth } from "./tool/source-types";
 import { z } from "zod";
-import { asRecord } from "./utils";
+import { toPlainObject } from "./utils";
+function toRecordOrEmpty(value: unknown): Record<string, unknown> {
+  return toPlainObject(value) ?? {};
+}
 const securityRequirementSchema = z.record(z.array(z.unknown()).optional());
 });
 export function inferOpenApiAuth(spec: Record<string, unknown>): OpenApiAuth | undefined {
-  const components = asRecord(spec.components);
+  const components = toRecordOrEmpty(spec.components);
-  const securitySchemes = asRecord(components.securitySchemes);
+  const securitySchemes = toRecordOrEmpty(components.securitySchemes);
   if (Object.keys(securitySchemes).length === 0) {
     return undefined;
   }

executor/packages/core/src/openapi-compaction.ts+18−14

   responseTypeHintFromSchema,
   type OpenApiParameterHint,
 } from "./openapi/schema-hints";
-import { asRecord } from "./utils";
+import { toPlainObject } from "./utils";
+function toRecordOrEmpty(value: unknown): Record<string, unknown> {
+  return toPlainObject(value) ?? {};
+}
 export interface CompactOpenApiPathsOptions {
   includeSchemas?: boolean;
   componentRequestBodies?: Record<string, unknown>,
   options: CompactOpenApiPathsOptions = {},
 ): Record<string, unknown> {
-  const paths = asRecord(pathsValue);
+  const paths = toRecordOrEmpty(pathsValue);
   const methods = ["get", "post", "put", "delete", "patch", "head", "options"] as const;
   const compactPaths: Record<string, unknown> = {};
-  const compParams = componentParameters ? asRecord(componentParameters) : {};
+  const compParams = componentParameters ? toRecordOrEmpty(componentParameters) : {};
-  const compSchemas = componentSchemas ? asRecord(componentSchemas) : {};
+  const compSchemas = componentSchemas ? toRecordOrEmpty(componentSchemas) : {};
-  const compResponses = componentResponses ? asRecord(componentResponses) : {};
+  const compResponses = componentResponses ? toRecordOrEmpty(componentResponses) : {};
-  const compRequestBodies = componentRequestBodies ? asRecord(componentRequestBodies) : {};
+  const compRequestBodies = componentRequestBodies ? toRecordOrEmpty(componentRequestBodies) : {};
   const includeSchemas = options.includeSchemas ?? true;
   const includeTypeHints = options.includeTypeHints ?? true;
   const includeParameterSchemas = options.includeParameterSchemas ?? true;
       const prefix = "#/components/parameters/";
       if (ref.startsWith(prefix)) {
         const key = ref.slice(prefix.length);
-        const resolved = asRecord(compParams[key]);
+        const resolved = toRecordOrEmpty(compParams[key]);
         if (Object.keys(resolved).length > 0) return resolved;
       }
     }
   const normalizeParameters = (entries: unknown): Array<OpenApiParameterHint & { in: string }> => {
     if (!Array.isArray(entries)) return [];
     return entries
-      .map((entry) => resolveParam(asRecord(entry)))
+      .map((entry) => resolveParam(toRecordOrEmpty(entry)))
       .filter((entry) => typeof entry.name === "string" && typeof entry.in === "string")
       .map((entry) => ({
         name: String(entry.name),
   };
   for (const [pathTemplate, pathValue] of Object.entries(paths)) {
-    const pathObject = asRecord(pathValue);
+    const pathObject = toRecordOrEmpty(pathValue);
     const compactPathObject: Record<string, unknown> = {};
     const sharedParameters = normalizeParameters(pathObject.parameters);
     if (sharedParameters.length > 0) {
     }
     for (const method of methods) {
-      const operation = asRecord(pathObject[method]);
+      const operation = toRecordOrEmpty(pathObject[method]);
       if (Object.keys(operation).length === 0) continue;
       const operationIdRaw = String(operation.operationId ?? `${method}_${pathTemplate}`);
       // Always attempt to compute minimal input/output schemas. This keeps the
       // prepared spec compact while enabling schema-first tool signatures.
       if (includeSchemas || hasGeneratedTypes) {
-        const requestBody = resolveRequestBodyRef(asRecord(operation.requestBody), compRequestBodies);
+        const requestBody = resolveRequestBodyRef(toRecordOrEmpty(operation.requestBody), compRequestBodies);
-        const requestBodyContent = asRecord(requestBody.content);
+        const requestBodyContent = toRecordOrEmpty(requestBody.content);
         const rawRequestBodySchema = getPreferredContentSchema(requestBodyContent);
         requestBodySchema = resolveSchemaRef(rawRequestBodySchema, compSchemas);
-        const responses = asRecord(operation.responses);
+        const responses = toRecordOrEmpty(operation.responses);
         for (const [status, responseValue] of Object.entries(responses)) {
           if (!status.startsWith("2")) continue;
           responseStatus = status;
-          const resolvedResponse = resolveResponseRef(asRecord(responseValue), compResponses);
+          const resolvedResponse = resolveResponseRef(toRecordOrEmpty(responseValue), compResponses);
           responseSchema = resolveSchemaRef(
             getPreferredResponseSchema(resolvedResponse),
             compSchemas,

executor/packages/core/src/openapi-prepare.ts+46−35

 import { compactOpenApiPaths } from "./openapi-compaction";
 import { extractOperationIdsFromDts } from "./openapi/schema-hints";
 import type { PreparedOpenApiSpec } from "./tool/source-types";
-import { asRecord } from "./utils";
+import { toPlainObject } from "./utils";
 const unknownRecordSchema = z.record(z.unknown());
+const openApiDocumentSchema = z.object({
+  openapi: z.string().optional(),
+  swagger: z.string().optional(),
+}).catchall(z.unknown());
 interface SwaggerParserAdapter {
   bundle(spec: unknown): Promise<unknown>;
   parse(spec: unknown): Promise<unknown>;
   return Result.ok(parsed.data);
 }
-function describeResultError(error: unknown): string {
+function toOpenApiTsInput(spec: Record<string, unknown>): Parameters<typeof openapiTS>[0] {
-  const cause = asRecord(error).cause;
+  const parsed = openApiDocumentSchema.safeParse(spec);
-  if (cause instanceof Error) {
+  if (!parsed.success) {
-    return cause.message;
+    throw new Error(`OpenAPI document is invalid: ${parsed.error.message}`);
-  }
-  if (typeof cause === "string" && cause.trim().length > 0) {
-    return cause;
   }
-  return error instanceof Error ? error.message : String(error);
+  return parsed.data as Parameters<typeof openapiTS>[0] & Record<string, unknown>;
 }
 function stripBrokenDiscriminators(spec: Record<string, unknown>): Record<string, unknown> | null {
     let target: unknown = spec;
     for (const segment of segments) {
       if (target && typeof target === "object") {
-        target = asRecord(target)[segment];
+        const targetRecord = toPlainObject(target);
+        if (!targetRecord) return false;
+        target = targetRecord[segment];
       } else {
         return false;
       }
   function hasBrokenDiscriminators(obj: unknown): boolean {
     if (Array.isArray(obj)) return obj.some(hasBrokenDiscriminators);
     if (obj && typeof obj === "object") {
-      const record = asRecord(obj);
+      const record = toPlainObject(obj);
+      if (!record) return false;
       if (record.discriminator && typeof record.discriminator === "object") {
-        const disc = asRecord(record.discriminator);
+        const disc = toPlainObject(record.discriminator) ?? {};
         if (disc.mapping && typeof disc.mapping === "object") {
-          const mapping = asRecord(disc.mapping);
+          const mapping = toPlainObject(disc.mapping) ?? {};
           if (Object.values(mapping).some((ref) => typeof ref === "string" && !refExists(ref))) {
             return true;
           }
   function walk(obj: unknown): unknown {
     if (Array.isArray(obj)) return obj.map(walk);
     if (obj && typeof obj === "object") {
-      const record = asRecord(obj);
+      const record = toPlainObject(obj);
+      if (!record) return obj;
       const clone: Record<string, unknown> = {};
       for (const [key, value] of Object.entries(record)) {
         if (key === "discriminator" && typeof value === "object" && value !== null) {
-          const disc = asRecord(value);
+          const disc = toPlainObject(value) ?? {};
           if (disc.mapping && typeof disc.mapping === "object") {
-            const mapping = asRecord(disc.mapping);
+            const mapping = toPlainObject(disc.mapping) ?? {};
             const hasBroken = Object.values(mapping).some(
               (ref) => typeof ref === "string" && !refExists(ref),
             );
 async function generateOpenApiDts(spec: Record<string, unknown>): Promise<string | null> {
   try {
-    const ast = await openapiTS(spec as never, { silent: true });
+    const ast = await openapiTS(toOpenApiTsInput(spec), { silent: true });
     return astToString(ast);
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     if (patched) {
       console.warn(`[executor] openapi-typescript failed, retrying with patched spec: ${msg}`);
       try {
-        const ast = await openapiTS(patched as never, { silent: true });
+        const ast = await openapiTS(toOpenApiTsInput(patched), { silent: true });
         return astToString(ast);
       } catch (retryError) {
         const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
   let parsed: Record<string, unknown>;
   if (typeof spec === "string") {
-    const parsedResult = await Result.tryPromise(() => parser.parse(spec));
+    let parsedValue: unknown;
-    if (parsedResult.isErr()) {
+    try {
-      const msg = describeResultError(parsedResult.error);
+      parsedValue = await parser.parse(spec);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to fetch/parse OpenAPI source '${sourceName}': ${msg}`);
     }
-    const parsedRecord = toRecordResult(parsedResult.value, `Parsed OpenAPI source '${sourceName}'`);
+    const parsedRecord = toRecordResult(parsedValue, `Parsed OpenAPI source '${sourceName}'`);
     if (parsedRecord.isErr()) {
       throw new Error(`Failed to fetch/parse OpenAPI source '${sourceName}': ${parsedRecord.error.message}`);
     }
     parsed = spec;
   }
-  let bundled: Record<string, unknown>;
+  let bundled: Record<string, unknown> = parsed;
   const dtsPromise = shouldGenerateDts
     ? generateOpenApiDts(parsed)
     : Promise.resolve<string | null>(null);
   if (shouldBundle) {
-    const bundleResult = await Result.tryPromise(() => parser.bundle(parsed));
+    let bundledValue: unknown;
-    if (bundleResult.isErr()) {
+    try {
-      const bundleMessage = describeResultError(bundleResult.error);
+      bundledValue = await parser.bundle(parsed);
+    } catch (error) {
+      const bundleMessage = error instanceof Error ? error.message : String(error);
       warnings.push(`OpenAPI bundle failed for '${sourceName}', using parse-only mode: ${bundleMessage}`);
       bundled = parsed;
-    } else {
+      bundledValue = undefined;
-      const bundledRecord = toRecordResult(bundleResult.value, `Bundled OpenAPI source '${sourceName}'`);
+    }
+    if (bundledValue !== undefined) {
+      const bundledRecord = toRecordResult(bundledValue, `Bundled OpenAPI source '${sourceName}'`);
       if (bundledRecord.isErr()) {
         warnings.push(`OpenAPI bundle returned non-object payload for '${sourceName}', using parse-only mode`);
         bundled = parsed;
         bundled = bundledRecord.value;
       }
     }
-  } else {
-    bundled = parsed;
   }
   const dts = await dtsPromise;
   return {
     servers: servers
       .map((server) => {
-        const value = asRecord(server).url;
+        const value = toPlainObject(server)?.url;
         return typeof value === "string" ? value : "";
       })
       .filter((url) => url.length > 0),
     paths: compactOpenApiPaths(
       bundled.paths,
       operationTypeIds,
-      asRecord(asRecord(bundled.components).parameters),
+      toPlainObject(toPlainObject(bundled.components)?.parameters) ?? {},
-      asRecord(asRecord(bundled.components).schemas),
+      toPlainObject(toPlainObject(bundled.components)?.schemas) ?? {},
-      asRecord(asRecord(bundled.components).responses),
+      toPlainObject(toPlainObject(bundled.components)?.responses) ?? {},
-      asRecord(asRecord(bundled.components).requestBodies),
+      toPlainObject(toPlainObject(bundled.components)?.requestBodies) ?? {},
       {
         includeSchemas: profile === "full",
         includeTypeHints: true,

executor/packages/core/src/openapi/schema-hints.ts+41−37

-import { asRecord } from "../utils";
+import { toPlainObject } from "../utils";
+function toRecordOrEmpty(value: unknown): Record<string, unknown> {
+  return toPlainObject(value) ?? {};
+}
 type JsonSchema = Record<string, unknown>;
 const COMPONENT_REF_INLINE_DEPTH = 2;
 function isSmallInlineableComponentSchema(schema: Record<string, unknown>): boolean {
   const shape = schema;
   const type = typeof shape.type === "string" ? shape.type : undefined;
-  const props = asRecord(shape.properties);
+  const props = toRecordOrEmpty(shape.properties);
   const propCount = Object.keys(props).length;
   if (type !== "object" && propCount === 0) return false;
   if (propCount === 0) return false;
   const preferredKeys = ["application/json", "*/*"];
   for (const key of preferredKeys) {
-    const schema = asRecord(asRecord(content[key]).schema);
+    const schema = toRecordOrEmpty(toRecordOrEmpty(content[key]).schema);
     if (Object.keys(schema).length > 0) return schema;
   }
   for (const [key, value] of Object.entries(content)) {
     if (!key.includes("json")) continue;
-    const schema = asRecord(asRecord(value).schema);
+    const schema = toRecordOrEmpty(toRecordOrEmpty(value).schema);
     if (Object.keys(schema).length > 0) return schema;
   }
   for (const value of Object.values(content)) {
-    const schema = asRecord(asRecord(value).schema);
+    const schema = toRecordOrEmpty(toRecordOrEmpty(value).schema);
     if (Object.keys(schema).length > 0) return schema;
   }
 }
 export function getPreferredResponseSchema(responseValue: Record<string, unknown>): Record<string, unknown> {
-  const contentSchema = getPreferredContentSchema(asRecord(responseValue.content));
+  const contentSchema = getPreferredContentSchema(toRecordOrEmpty(responseValue.content));
   if (Object.keys(contentSchema).length > 0) {
     return contentSchema;
   }
-  const schema = asRecord(responseValue.schema);
+  const schema = toRecordOrEmpty(responseValue.schema);
   if (Object.keys(schema).length > 0) {
     return schema;
   }
   }
   const key = ref.slice(prefix.length);
-  const resolved = asRecord(componentSchemas[key]);
+  const resolved = toRecordOrEmpty(componentSchemas[key]);
   if (Object.keys(resolved).length === 0) {
     return schema;
   }
   }
   const key = ref.slice(prefix.length);
-  const resolved = asRecord(componentRequestBodies[key]);
+  const resolved = toRecordOrEmpty(componentRequestBodies[key]);
   if (Object.keys(resolved).length === 0) {
     return requestBody;
   }
   }
   const key = ref.slice(prefix.length);
-  const resolved = asRecord(componentResponses[key]);
+  const resolved = toRecordOrEmpty(componentResponses[key]);
   if (Object.keys(resolved).length === 0) {
     return response;
   }
 }
 export function parameterSchemaFromEntry(entry: Record<string, unknown>): Record<string, unknown> {
-  const schema = asRecord(entry.schema);
+  const schema = toRecordOrEmpty(entry.schema);
   if (Object.keys(schema).length > 0) {
     return schema;
   }
   if (Array.isArray(entry.enum) && entry.enum.length > 0) {
     fallback.enum = entry.enum;
   }
-  const items = asRecord(entry.items);
+  const items = toRecordOrEmpty(entry.items);
   if (Object.keys(items).length > 0) {
     fallback.items = items;
   }
 function isObjectSchema(schema: JsonSchema): boolean {
   const type = typeof schema.type === "string" ? schema.type : undefined;
   if (type === "object") return true;
-  return Object.keys(asRecord(schema.properties)).length > 0;
+  return Object.keys(toRecordOrEmpty(schema.properties)).length > 0;
 }
 function isEmptyObjectSchema(schema: JsonSchema): boolean {
   const type = typeof schema.type === "string" ? schema.type : undefined;
   if (type !== "object") return false;
-  return Object.keys(asRecord(schema.properties)).length === 0;
+  return Object.keys(toRecordOrEmpty(schema.properties)).length === 0;
 }
 function isPlainScalarSchema(schema: JsonSchema): boolean {
   // Many real-world OpenAPI specs include `oneOf: [{type:"object"}, { ...specific... }]`
   // or even `oneOf: [{type:"string"}, { ...object... }, { ...object... }]`.
   // These broad scalar/empty-object variants add noise without helping the UI/LLM.
-  const hasNonEmptyObject = variants.some((v) => isObjectSchema(v) && Object.keys(asRecord(v.properties)).length > 0);
+  const hasNonEmptyObject = variants.some((v) => isObjectSchema(v) && Object.keys(toRecordOrEmpty(v.properties)).length > 0);
   let filtered = variants;
   if (hasNonEmptyObject) {
   const requiredLists = variants.map((v) => new Set(
     (Array.isArray(v.required) ? v.required : []).filter((k): k is string => typeof k === "string"),
   ));
-  const propsLists = variants.map((v) => asRecord(v.properties));
+  const propsLists = variants.map((v) => toRecordOrEmpty(v.properties));
   const keysToConsider = new Set<string>();
   for (const req of requiredLists) {
       if (!schema || typeof schema !== "object") continue;
       const hint = jsonSchemaTypeHintFallback(schema, depth + 1, componentSchemas, seenRefs);
       if (!hint || hint === "unknown") continue;
-      candidates.push({ hint, schema: asRecord(schema) });
+      candidates.push({ hint, schema: toRecordOrEmpty(schema) });
     }
     if (candidates.length === 0) continue;
   for (let i = 0; i < variants.length; i++) {
     const variant = variants[i]!;
-    const props = asRecord(variant.properties);
+    const props = toRecordOrEmpty(variant.properties);
-    const discSchema = asRecord(props[discriminantKey]);
+    const discSchema = toRecordOrEmpty(props[discriminantKey]);
     const disc = extractStringLiteralFromSchema(discSchema);
     if (!disc) {
       return variants;
     for (const member of group) used.add(member.idx);
     const base = group[0]!.schema;
-    const baseProps = asRecord(base.properties);
+    const baseProps = toRecordOrEmpty(base.properties);
-    const discSchema = asRecord(baseProps[discriminantKey]);
+    const discSchema = toRecordOrEmpty(baseProps[discriminantKey]);
     const discType = typeof discSchema.type === "string" ? discSchema.type : "string";
     const mergedDiscriminant: JsonSchema = {
   const right = variants[1]!;
   if (!isObjectSchema(left) || !isObjectSchema(right)) return null;
-  const leftProps = asRecord(left.properties);
+  const leftProps = toRecordOrEmpty(left.properties);
-  const rightProps = asRecord(right.properties);
+  const rightProps = toRecordOrEmpty(right.properties);
   const leftKeys = Object.keys(leftProps);
   const rightKeys = Object.keys(rightProps);
   if (leftKeys.length === 0 || rightKeys.length === 0) return null;
   const sup = leftSubRight ? right : left;
   const sub = leftSubRight ? left : right;
-  const supProps = asRecord(sup.properties);
+  const supProps = toRecordOrEmpty(sup.properties);
-  const subProps = asRecord(sub.properties);
+  const subProps = toRecordOrEmpty(sub.properties);
   const supKeys = Object.keys(supProps);
   const subKeys = Object.keys(subProps);
   const extraKeys = supKeys.filter((k) => !subKeys.includes(k));
   if (variants.length < 2) return null;
   if (!variants.every(isObjectSchema)) return null;
-  const propsList = variants.map((v) => asRecord(v.properties));
+  const propsList = variants.map((v) => toRecordOrEmpty(v.properties));
   const commonKeys = intersectKeys(propsList);
   if (commonKeys.length === 0) return null;
   const commonEntries: Array<{ key: string; hint: string; required: boolean }> = [];
   for (const key of commonKeys) {
-    const hints = variants.map((v) => jsonSchemaTypeHintFallback(asRecord(v.properties)[key], depth + 1, componentSchemas, seenRefs));
+    const hints = variants.map((v) => jsonSchemaTypeHintFallback(toRecordOrEmpty(v.properties)[key], depth + 1, componentSchemas, seenRefs));
     const firstHint = hints[0];
     if (!firstHint || hints.some((h) => h !== firstHint)) continue;
   const commonProps = new Set(commonEntries.map((e) => e.key));
   const residualSchemas: JsonSchema[] = [];
   for (const variant of variants) {
-    const props = asRecord(variant.properties);
+    const props = toRecordOrEmpty(variant.properties);
     const residualProps = Object.fromEntries(Object.entries(props).filter(([key]) => !commonProps.has(key)));
     const req = Array.isArray(variant.required) ? variant.required : [];
     const residualRequired = req.filter((key) => typeof key === "string" && !commonProps.has(key));
   }
   // If factoring doesn't reduce anything, bail.
-  const reduces = residualSchemas.some((s) => Object.keys(asRecord(s.properties)).length > 0);
+  const reduces = residualSchemas.some((s) => Object.keys(toRecordOrEmpty(s.properties)).length > 0);
   if (!reduces) return null;
   const commonInner = commonEntries
   if (variants.length < 3) return null;
   if (!variants.every(isObjectSchema)) return null;
-  const propsList = variants.map((v) => asRecord(v.properties));
+  const propsList = variants.map((v) => toRecordOrEmpty(v.properties));
   const requiredList = variants.map((v) => new Set(
     (Array.isArray(v.required) ? v.required : []).filter((k): k is string => typeof k === "string"),
   ));
   // If factoring doesn't actually remove anything useful, bail.
   const anyResidualHasProps = residualSchemas.some(
-    (s) => Object.keys(asRecord(s.properties)).length > 0,
+    (s) => Object.keys(toRecordOrEmpty(s.properties)).length > 0,
   );
   if (!anyResidualHasProps) return null;
   if (!schema || typeof schema !== "object") return "unknown";
   if (depth > 12) return "unknown";
-  const shape = asRecord(schema);
+  const shape = toRecordOrEmpty(schema);
   if (typeof shape.$ref === "string") {
     const ref = shape.$ref;
     const prefix = "#/components/schemas/";
     if (ref.startsWith(prefix)) {
       const key = ref.slice(prefix.length);
-      const resolved = componentSchemas ? asRecord(componentSchemas[key]) : {};
+      const resolved = componentSchemas ? toRecordOrEmpty(componentSchemas[key]) : {};
       const canInline = Object.keys(resolved).length > 0
         && !seenRefs.has(ref)
         && (depth < COMPONENT_REF_INLINE_DEPTH || isSmallInlineableComponentSchema(resolved));
     return `${maybeParenthesizeArrayElement(itemType)}[]`;
   }
-  const props = asRecord(shape.properties);
+  const props = toRecordOrEmpty(shape.properties);
   const additionalProperties = shape.additionalProperties;
   const requiredRaw = Array.isArray(shape.required) ? shape.required : [];
   const required = new Set(requiredRaw.filter((item): item is string => typeof item === "string"));
 ): string[] {
   if (!schema || typeof schema !== "object") return [];
-  const record = asRecord(schema);
+  const record = toRecordOrEmpty(schema);
   const ref = typeof record.$ref === "string" ? record.$ref : "";
   if (ref.startsWith("#/components/schemas/")) {
     if (seenRefs.has(ref)) return [];
     const key = ref.slice("#/components/schemas/".length);
-    const resolved = componentSchemas ? asRecord(componentSchemas[key]) : {};
+    const resolved = componentSchemas ? toRecordOrEmpty(componentSchemas[key]) : {};
     if (Object.keys(resolved).length === 0) return [];
     const nextSeen = new Set(seenRefs);
     nextSeen.add(ref);
   const keys: string[] = [];
   const seen = new Set<string>();
-  for (const key of Object.keys(asRecord(record.properties))) {
+  for (const key of Object.keys(toRecordOrEmpty(record.properties))) {
     pushUnique(keys, seen, key);
   }

executor/packages/core/src/openapi/tool-builder.ts+38−23

+import { z } from "zod";
 import {
   buildOpenApiArgPreviewKeys,
   buildOpenApiInputSchema,
   jsonSchemaTypeHintFallback,
   responseTypeHintFromSchema,
 } from "./schema-hints";
-import { z } from "zod";
 import { buildOpenApiToolPath } from "./tool-path";
 import { buildCredentialSpec, buildStaticAuthHeaders, getCredentialSourceKey } from "../tool/source-auth";
 import { executeOpenApiRequest } from "../tool/source-execution";
 import type { ToolDefinition } from "../types";
 import type { ToolTypedRef } from "../types";
 import { buildPreviewKeys, extractTopLevelRequiredKeys } from "../tool-typing/schema-utils";
-import { asRecord } from "../utils";
+import { toPlainObject } from "../utils";
 import type { SerializedTool } from "../tool/source-serialization";
 type OpenApiOperationParameter = {
   schema: Record<string, unknown>;
 };
-const recordArraySchema = z.array(z.record(z.unknown()));
+const stringArraySchema = z.array(z.string());
+const nonEmptyTrimmedStringSchema = z.string().transform((value) => value.trim()).refine((value) => value.length > 0);
-function asRecordArray(value: unknown): Record<string, unknown>[] {
+function toRecordOrEmpty(value: unknown): Record<string, unknown> {
-  const parsed = recordArraySchema.safeParse(value);
+  return toPlainObject(value) ?? {};
-  return parsed.success ? parsed.data : [];
+}
+function parseNonEmptyTrimmedString(value: unknown): string | undefined {
+  const parsed = nonEmptyTrimmedStringSchema.safeParse(value);
+  return parsed.success ? parsed.data : undefined;
+}
+function toRecordArray(value: unknown): Array<Record<string, unknown>> {
+  if (!Array.isArray(value)) return [];
+  const entries: Array<Record<string, unknown>> = [];
+  for (const item of value) {
+    const record = toPlainObject(item);
+    if (record) {
+      entries.push(record);
+    }
+  }
+  return entries;
 }
 function buildOpenApiOperationParameters(
 ): OpenApiOperationParameter[] {
   return [
     ...sharedParameters,
-    ...asRecordArray(operation.parameters),
+    ...toRecordArray(operation.parameters),
   ].map((entry) => ({
     name: String(entry.name ?? ""),
     in: String(entry.in ?? "query"),
     required: Boolean(entry.required),
-    schema: asRecord(entry.schema),
+    schema: toRecordOrEmpty(entry.schema),
   }));
 }
   const sourceLabel = `openapi:${config.name}`;
   const credentialSourceKey = getCredentialSourceKey(config);
   const credentialSpec = buildCredentialSpec(credentialSourceKey, effectiveAuth);
-  const paths = asRecord(prepared.paths);
+  const paths = toRecordOrEmpty(prepared.paths);
   const tools: ToolDefinition[] = [];
   const methods = ["get", "post", "put", "delete", "patch", "head", "options"] as const;
   const usedToolPaths = new Set<string>();
   for (const [pathTemplate, pathValue] of Object.entries(paths)) {
-    const pathObject = asRecord(pathValue);
+    const pathObject = toRecordOrEmpty(pathValue);
-    const sharedParameters = asRecordArray(pathObject.parameters);
+    const sharedParameters = toRecordArray(pathObject.parameters);
     for (const method of methods) {
-      const operation = asRecord(pathObject[method]);
+      const operation = toRecordOrEmpty(pathObject[method]);
       if (Object.keys(operation).length === 0) continue;
       const tags = Array.isArray(operation.tags) ? operation.tags : [];
       const operationIdRaw = String(operation.operationId ?? `${method}_${pathTemplate}`);
       const parameters = buildOpenApiOperationParameters(sharedParameters, operation);
-      const inputSchema = asRecord(operation._inputSchema);
+      const inputSchema = toRecordOrEmpty(operation._inputSchema);
-      const outputSchema = asRecord(operation._outputSchema);
+      const outputSchema = toRecordOrEmpty(operation._outputSchema);
-      const inputHint = typeof operation._argsTypeHint === "string" && operation._argsTypeHint.trim().length > 0
+      const inputHint = parseNonEmptyTrimmedString(operation._argsTypeHint);
-        ? operation._argsTypeHint.trim()
+      const outputHint = parseNonEmptyTrimmedString(operation._returnsTypeHint);
-        : undefined;
-      const outputHint = typeof operation._returnsTypeHint === "string" && operation._returnsTypeHint.trim().length > 0
-        ? operation._returnsTypeHint.trim()
-        : undefined;
       const requiredInputKeys = extractTopLevelRequiredKeys(inputSchema);
-      const previewInputKeys = Array.isArray(operation._previewInputKeys)
+      const parsedPreviewInputKeys = stringArraySchema.safeParse(operation._previewInputKeys);
-        ? operation._previewInputKeys.filter((value): value is string => typeof value === "string")
+      const previewInputKeys = parsedPreviewInputKeys.success
+        ? parsedPreviewInputKeys.data
         : buildPreviewKeys(inputSchema);
       const typedRef: ToolTypedRef = {
         kind: "openapi_operation",
-        sourceKey: sourceLabel,
+        sourceKey: config.sourceKey ?? sourceLabel,
         operationId: operationIdRaw,
       };

executor/packages/core/src/postman-runtime.ts+9−3

 import { asStringRecord, detectJsonContentType, findUnresolvedPostmanTemplateKeys, interpolatePostmanTemplate, stringifyTemplateValue } from "./postman-utils";
 import { z } from "zod";
-import { asRecord } from "./utils";
 import type { PostmanRequestBody } from "./postman/collection-utils";
 export interface PostmanSerializedRunSpec {
   body: z.unknown().optional(),
 }).passthrough();
+const recordSchema = z.record(z.unknown());
+function coerceRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 export async function executePostmanRequest(
   runSpec: PostmanSerializedRunSpec,
   payload: Record<string, unknown>,
     }
   }
-  const queryOverrides = asRecord(normalizedPayload.query);
+  const queryOverrides = coerceRecord(normalizedPayload.query);
   for (const [key, value] of Object.entries(queryOverrides)) {
     if (!key || value === undefined || value === null) continue;
     url.searchParams.set(key, stringifyTemplateValue(value));
   Object.assign(headers, runSpec.authHeaders);
   Object.assign(headers, credentialHeaders ?? {});
-  const headerOverrides = asRecord(normalizedPayload.headers);
+  const headerOverrides = coerceRecord(normalizedPayload.headers);
   for (const [name, value] of Object.entries(headerOverrides)) {
     if (!name || value === undefined || value === null) continue;
     headers[name] = stringifyTemplateValue(value);

executor/packages/core/src/postman-utils.ts+8−2

-import { asRecord } from "./utils";
+import { z } from "zod";
 const POSTMAN_TEMPLATE_PATTERN = /\{\{([^{}]+)\}\}/g;
+const recordSchema = z.record(z.unknown());
+function coerceRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 export function stringifyTemplateValue(value: unknown): string {
   if (value === null || value === undefined) return "";
 export function asStringRecord(value: unknown): Record<string, string> {
   const result: Record<string, string> = {};
-  for (const [key, entry] of Object.entries(asRecord(value))) {
+  for (const [key, entry] of Object.entries(coerceRecord(value))) {
     result[key] = stringifyTemplateValue(entry);
   }
   return result;

executor/packages/core/src/postman/collection-utils.ts+77−32

@@ -1,11 +1,50 @@
1	import { sanitizeSegment, sanitizeSnakeSegment } from "../tool/path-utils";	1	import { sanitizeSegment, sanitizeSnakeSegment } from "../tool/path-utils";
2	import { stringifyTemplateValue } from "../postman-utils";	2	import { stringifyTemplateValue } from "../postman-utils";
3	import { asRecord } from "../utils";	3	import { z } from "zod";
4		4
5	export type PostmanRequestBody =	5	export type PostmanRequestBody =
6	\| { kind: "urlencoded"; entries: Array<{ key: string; value: string }> }	6	\| { kind: "urlencoded"; entries: Array<{ key: string; value: string }> }
7	\| { kind: "raw"; text: string };	7	\| { kind: "raw"; text: string };
8		8
		9	const postmanKeyValueEntrySchema = z.object({
		10	key: z.coerce.string(),
		11	value: z.unknown().optional(),
		12	disabled: z.boolean().optional(),
		13	enabled: z.boolean().optional(),
		14	});
		15
		16	const postmanBodySchema = z.object({
		17	mode: z.string().optional(),
		18	urlencoded: z.array(postmanKeyValueEntrySchema).optional(),
		19	raw: z.string().optional(),
		20	dataMode: z.string().optional(),
		21	data: z.array(postmanKeyValueEntrySchema).optional(),
		22	rawModeData: z.string().optional(),
		23	});
		24
		25	function parseKeyValueEntries(value: unknown): Array<z.infer<typeof postmanKeyValueEntrySchema>> {
		26	const parsed = z.array(postmanKeyValueEntrySchema).safeParse(value);
		27	return parsed.success ? parsed.data : [];
		28	}
		29
		30	function isDisabled(entry: z.infer<typeof postmanKeyValueEntrySchema>): boolean {
		31	return entry.disabled === true \|\| entry.enabled === false;
		32	}
		33
		34	function toNormalizedEntry(
		35	entry: z.infer<typeof postmanKeyValueEntrySchema>,
		36	): { key: string; value: string } \| null {
		37	const key = entry.key.trim();
		38	if (!key \|\| isDisabled(entry)) {
		39	return null;
		40	}
		41
		42	return {
		43	key,
		44	value: stringifyTemplateValue(entry.value),
		45	};
		46	}
		47
9	export function buildPostmanToolPath(	48	export function buildPostmanToolPath(
10	sourceName: string,	49	sourceName: string,
11	requestName: string,	50	requestName: string,
@@ -48,57 +87,63 @@ export function resolvePostmanFolderPath( · 36 unmodified lines
48	}	87	}
49		88
50	export function extractPostmanVariableMap(value: unknown): Record<string, string> {	89	export function extractPostmanVariableMap(value: unknown): Record<string, string> {
51	if (!Array.isArray(value)) return {};
52	const result: Record<string, string> = {};	90	const result: Record<string, string> = {};
53	for (const entry of value) {	91	for (const entry of parseKeyValueEntries(value)) {
54	const record = asRecord(entry);	92	const normalized = toNormalizedEntry(entry);
55	const key = typeof record.key === "string" ? record.key.trim() : "";	93	if (!normalized) continue;
56	if (!key) continue;	94	result[normalized.key] = normalized.value;
57	if (record.disabled === true) continue;
58	result[key] = stringifyTemplateValue(record.value);
59	}	95	}
60	return result;	96	return result;
61	}	97	}
62		98
63	export function extractPostmanHeaderMap(value: unknown): Record<string, string> {	99	export function extractPostmanHeaderMap(value: unknown): Record<string, string> {
64	if (!Array.isArray(value)) return {};
65	const result: Record<string, string> = {};	100	const result: Record<string, string> = {};
66	for (const entry of value) {	101	for (const entry of parseKeyValueEntries(value)) {
67	const record = asRecord(entry);	102	const normalized = toNormalizedEntry(entry);
68	const key = typeof record.key === "string" ? record.key.trim() : "";	103	if (!normalized) continue;
69	if (!key \|\| record.disabled === true) continue;	104	result[normalized.key] = normalized.value;
70	result[key] = stringifyTemplateValue(record.value);
71	}	105	}
72	return result;	106	return result;
73	}	107	}
74		108
75	export function extractPostmanQueryEntries(value: unknown): Array<{ key: string; value: string }> {	109	export function extractPostmanQueryEntries(value: unknown): Array<{ key: string; value: string }> {
76	if (!Array.isArray(value)) return [];
77	const entries: Array<{ key: string; value: string }> = [];	110	const entries: Array<{ key: string; value: string }> = [];
78	for (const entry of value) {	111	for (const entry of parseKeyValueEntries(value)) {
79	const record = asRecord(entry);	112	const normalized = toNormalizedEntry(entry);
80	const key = typeof record.key === "string" ? record.key.trim() : "";	113	if (!normalized) continue;
81	if (!key \|\| record.disabled === true) continue;	114	entries.push(normalized);
82	entries.push({ key, value: stringifyTemplateValue(record.value) });
83	}	115	}
84	return entries;	116	return entries;
85	}	117	}
86		118
87	export function extractPostmanBody(record: Record<string, unknown>): PostmanRequestBody \| undefined {	119	export function extractPostmanBody(value: unknown): PostmanRequestBody \| undefined {
88	const dataMode = typeof record.dataMode === "string" ? record.dataMode.toLowerCase() : "";	120	const parsedBody = postmanBodySchema.safeParse(value);
89	if (dataMode === "urlencoded" && Array.isArray(record.data)) {	121	if (!parsedBody.success) return undefined;
90	const entries: Array<{ key: string; value: string }> = [];	122
91	for (const item of record.data) {	123	const body = parsedBody.data;
92	const entry = asRecord(item);	124	const mode = (body.mode ?? body.dataMode ?? "").trim().toLowerCase();
93	const key = typeof entry.key === "string" ? entry.key.trim() : "";	125
94	if (!key \|\| entry.disabled === true) continue;	126	if (mode === "urlencoded") {
95	entries.push({ key, value: stringifyTemplateValue(entry.value) });	127	const rawEntries = body.urlencoded ?? body.data ?? [];
96	}	128	const entries = rawEntries
		129	.map((entry) => toNormalizedEntry(entry))
		130	.filter((entry): entry is { key: string; value: string } => Boolean(entry));
97	return entries.length > 0 ? { kind: "urlencoded", entries } : undefined;	131	return entries.length > 0 ? { kind: "urlencoded", entries } : undefined;
98	}	132	}
99		133
100	if (typeof record.rawModeData === "string" && record.rawModeData.length > 0) {	134	if (mode === "raw") {
101	return { kind: "raw", text: record.rawModeData };	135	const rawText = body.raw ?? body.rawModeData ?? "";
		136	if (rawText.trim().length > 0) {
		137	return { kind: "raw", text: rawText };
		138	}
		139	}
		140
		141	if ((body.rawModeData ?? "").trim().length > 0) {
		142	return { kind: "raw", text: body.rawModeData ?? "" };
		143	}
		144
		145	if ((body.raw ?? "").trim().length > 0) {
		146	return { kind: "raw", text: body.raw ?? "" };
102	}	147	}
103		148
104	return undefined;	149	return undefined;

executor/packages/core/src/runtimes/runtime-core.ts+10−4

     return undefined;
   }
-  const serialized = Result.try(() => JSON.stringify(value));
+  let serialized: string | undefined;
-  if (serialized.isErr()) {
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
     return String(value);
   }
-  if (serialized.value === undefined) {
+  if (serialized === undefined) {
     return null;
   }
-  return Result.try(() => JSON.parse(serialized.value)).unwrapOr(String(value));
+  try {
+    return JSON.parse(serialized);
+  } catch {
+    return String(value);
+  }
 }
 function createToolsProxy(

executor/packages/core/src/tool-discovery.ts+7−5

 } from "./tool-discovery/formatting";
 import { buildIndex, getTopLevelNamespace, listIndexForContext } from "./tool-discovery/indexing";
 import { chooseBestPath, deriveIntentPhrase, extractNamespaceHints, scoreEntry } from "./tool-discovery/ranking";
-import { asRecord } from "./utils";
+const recordSchema = z.record(z.unknown());
 const catalogToolsInputSchema = z.object({
   namespace: z.string().optional(),
       outputSchema: { type: "object", properties: { results: { type: "array" }, total: { type: "number" } }, required: ["results", "total"] },
     },
     run: async (input: unknown, context) => {
-      const payload = asRecord(input);
+      const payload = recordSchema.safeParse(input);
-      const parsedInput = catalogToolsInputSchema.safeParse(payload);
+      const normalizedPayload = payload.success ? payload.data : {};
+      const parsedInput = catalogToolsInputSchema.safeParse(normalizedPayload);
       const namespaceFilter = (parsedInput.success ? (parsedInput.data.namespace ?? "") : "").trim().toLowerCase();
       const query = (parsedInput.success ? (parsedInput.data.query ?? "") : "").trim().toLowerCase();
       const depthValue = parsedInput.success ? parsedInput.data.depth : undefined;
       },
     },
     run: async (input: unknown, context) => {
-      const payload = asRecord(input);
+      const payload = recordSchema.safeParse(input);
-      const parsedInput = discoverInputSchema.safeParse(payload);
+      const normalizedPayload = payload.success ? payload.data : {};
+      const parsedInput = discoverInputSchema.safeParse(normalizedPayload);
       const query = (parsedInput.success ? (parsedInput.data.query ?? "") : "").trim().toLowerCase();
       const depthValue = parsedInput.success ? parsedInput.data.depth : undefined;
       const depth = Math.max(0, Math.min(2, Number(depthValue ?? 1)));

executor/packages/core/src/tool-discovery/indexing.ts+19−8

+import { z } from "zod";
 import type { ToolDefinition } from "../types";
 import { jsonSchemaTypeHintFallback } from "../openapi/schema-hints";
 import { buildPreviewKeys, extractTopLevelRequiredKeys } from "../tool-typing/schema-utils";
 import { sanitizeJsonSchemaForConvex } from "../tool-typing/convex-sanitize";
-import { asRecord } from "../utils";
 import type { DiscoverIndexEntry } from "./types";
 const GENERIC_NAMESPACE_SUFFIXES = new Set([
   "services",
 ]);
+const recordSchema = z.record(z.unknown());
+const stringArraySchema = z.array(z.string());
+function coerceRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 function normalizeHint(type?: string): string {
   return type && type.trim().length > 0 ? type : "unknown";
 }
 function isEmptyObjectSchema(schema: Record<string, unknown>): boolean {
   if (Object.keys(schema).length === 0) return true;
-  const props = asRecord(schema.properties);
+  const props = coerceRecord(schema.properties);
   const required = Array.isArray(schema.required) ? schema.required : [];
   return Object.keys(props).length === 0 && required.length === 0;
 }
       const preferredPath = preferredToolPath(tool.path);
       const aliases = getPathAliases(tool.path);
       const searchText = `${tool.path} ${preferredPath} ${aliases.join(" ")} ${tool.description} ${tool.source ?? ""}`.toLowerCase();
+      const typing = tool.typing;
-      const inputSchema = asRecord(tool.typing?.inputSchema);
+      const inputSchema = coerceRecord(typing?.inputSchema);
-      const outputSchema = asRecord(tool.typing?.outputSchema);
+      const outputSchema = coerceRecord(typing?.outputSchema);
       const safeInputSchema = sanitizeJsonSchemaForConvex(inputSchema);
       const safeOutputSchema = sanitizeJsonSchemaForConvex(outputSchema);
-      const requiredInputKeys = Array.isArray(tool.typing?.requiredInputKeys)
+      const parsedRequiredInputKeys = stringArraySchema.safeParse(typing?.requiredInputKeys);
-        ? tool.typing!.requiredInputKeys!.filter((value): value is string => typeof value === "string")
+      const requiredInputKeys = parsedRequiredInputKeys.success
+        ? parsedRequiredInputKeys.data
         : extractTopLevelRequiredKeys(inputSchema);
-      const previewInputKeys = Array.isArray(tool.typing?.previewInputKeys)
+      const parsedPreviewInputKeys = stringArraySchema.safeParse(typing?.previewInputKeys);
-        ? tool.typing!.previewInputKeys!.filter((value): value is string => typeof value === "string")
+      const previewInputKeys = parsedPreviewInputKeys.success
+        ? parsedPreviewInputKeys.data
         : buildPreviewKeys(inputSchema);
       const displayInputHint = normalizeHint(

executor/packages/core/src/tool-source-loaders/graphql-loader.ts+69−20

 import type { GraphqlToolSourceConfig } from "../tool/source-types";
 import { buildPreviewKeys, extractTopLevelRequiredKeys } from "../tool-typing/schema-utils";
 import type { ToolDefinition } from "../types";
-import { asRecord } from "../utils";
 const gqlTypeRefSchema: z.ZodType<GqlTypeRef> = z.lazy(() => z.object({
   kind: z.string(),
   description: z.string().nullable().optional().transform((value) => value ?? null),
 });
-const gqlTypeSchema: z.ZodType<GqlType> = z.object({
+const gqlTypeSchema = z.object({
   kind: z.string(),
   name: z.string(),
   fields: z.array(gqlFieldSchema).nullable().optional().transform((value) => value ?? null),
   enumValues: z.array(gqlEnumValueSchema).nullable().optional().transform((value) => value ?? null),
 });
-const gqlSchemaSchema: z.ZodType<GqlSchema> = z.object({
+const gqlSchemaSchema = z.object({
   queryType: z.object({ name: z.string() }).nullable().optional().transform((value) => value ?? null),
   mutationType: z.object({ name: z.string() }).nullable().optional().transform((value) => value ?? null),
   types: z.array(gqlTypeSchema),
   errors: z.array(z.unknown()).optional(),
 });
+const graphqlObjectInputSchema = z.object({
+  query: z.string().optional(),
+  variables: z.unknown().optional(),
+}).catchall(z.unknown());
+const graphqlToolInputSchema = z.union([
+  z.string(),
+  graphqlObjectInputSchema,
+]);
+const recordSchema = z.record(z.unknown());
+function coerceRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
+function normalizeGraphqlToolInput(value: unknown): {
+  payload: Record<string, unknown>;
+  query: string;
+  variables: unknown;
+  hasExplicitQuery: boolean;
+} {
+  const parsedInput = graphqlToolInputSchema.safeParse(value);
+  if (!parsedInput.success) {
+    const payload = coerceRecord(value);
+    return {
+      payload,
+      query: "",
+      variables: payload.variables,
+      hasExplicitQuery: false,
+    };
+  }
+  if (typeof parsedInput.data === "string") {
+    const query = parsedInput.data.trim();
+    return {
+      payload: { query: parsedInput.data },
+      query,
+      variables: undefined,
+      hasExplicitQuery: query.length > 0,
+    };
+  }
+  const query = (parsedInput.data.query ?? "").trim();
+  return {
+    payload: parsedInput.data,
+    query,
+    variables: parsedInput.data.variables,
+    hasExplicitQuery: query.length > 0,
+  };
+}
 const INTROSPECTION_QUERY = `
   query IntrospectionQuery {
     __schema {
 }
 function toGraphqlEnvelope(value: unknown): GraphqlExecutionEnvelope {
-  const payload = asRecord(value);
+  const payload = coerceRecord(value);
   return {
     data: Object.prototype.hasOwnProperty.call(payload, "data") ? payload.data : null,
     errors: Array.isArray(payload.errors) ? payload.errors : [],
     throw new Error(`GraphQL introspection failed: HTTP ${introspectionResult.status}: ${text.slice(0, 300)}`);
   }
-  const introspectionJsonResult = await Result.tryPromise(() => introspectionResult.json());
+  let introspectionJson: unknown;
-  if (introspectionJsonResult.isErr()) {
+  try {
-    const message = introspectionJsonResult.error.cause instanceof Error
+    introspectionJson = await introspectionResult.json();
-      ? introspectionJsonResult.error.cause.message
+  } catch (error) {
-      : String(introspectionJsonResult.error.cause);
+    const message = error instanceof Error ? error.message : String(error);
     throw new Error(`GraphQL introspection response parse failed: ${message}`);
   }
-  const schemaResult = parseGraphqlIntrospectionSchema(introspectionJsonResult.value);
+  const schemaResult = parseGraphqlIntrospectionSchema(introspectionJson);
   if (schemaResult.isErr()) {
     throw schemaResult.error;
   }
       authHeaders,
     },
     run: async (input: unknown, context) => {
-      const payload = asRecord(input);
+      const normalized = normalizeGraphqlToolInput(input);
-      const query = String(payload.query ?? "");
+      if (!normalized.hasExplicitQuery) {
-      const variables = payload.variables ?? undefined;
-      if (!query.trim()) {
         throw new Error("GraphQL query string is required");
       }
       return await executeGraphqlRequest(
         config.endpoint,
         authHeaders,
-        query,
+        normalized.query,
-        variables,
+        normalized.variables,
         context.credential?.headers,
       );
     },
         _pseudoTool: true,
         run: async (input: unknown, context) => {
           // If someone calls this directly, delegate to the main graphql tool
-          const payload = asRecord(input);
+          const normalized = normalizeGraphqlToolInput(input);
-          const hasExplicitQuery = typeof payload.query === "string" && payload.query.trim().length > 0;
+          const payload = normalized.payload;
-          if (!hasExplicitQuery) {
+          if (!normalized.hasExplicitQuery) {
             // Auto-build the query from the variables
             payload.query = buildFieldQuery(operationType, field.name, field.args, field.type, typeMap);
             if (payload.variables === undefined) {

executor/packages/core/src/tool-source-loaders/mcp-loader.ts+10−4

 import type { McpToolSourceConfig } from "../tool/source-types";
 import { buildPreviewKeys, extractTopLevelRequiredKeys } from "../tool-typing/schema-utils";
 import type { ToolDefinition } from "../types";
-import { asRecord } from "../utils";
 import type { SerializedTool } from "../tool/source-serialization";
 const listedToolsResponseSchema = z.object({
   tools: z.array(z.record(z.unknown())).optional(),
 });
+const recordSchema = z.record(z.unknown());
+function coerceRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 function extractListedTools(value: unknown): Record<string, unknown>[] {
   const parsed = listedToolsResponseSchema.safeParse(value);
   if (!parsed.success) {
   return tools.map((tool) => {
     const toolName = String(tool.name ?? "tool");
-    const inputSchema = asRecord(tool.inputSchema);
+    const inputSchema = coerceRecord(tool.inputSchema);
-    const outputSchema = asRecord(tool.outputSchema);
+    const outputSchema = coerceRecord(tool.outputSchema);
     const previewInputKeys = buildPreviewKeys(inputSchema).filter((key) => key.length > 0);
     const requiredInputKeys = extractTopLevelRequiredKeys(inputSchema);
     return {
         toolName,
       },
       run: async (input: unknown, context) => {
-        const payload = asRecord(input);
+        const payload = coerceRecord(input);
         const result = await callToolWithReconnect(toolName, payload, context.credential?.headers);
         return extractMcpResult(result);
       },

executor/packages/core/src/tool-source-loaders/openapi-loader.ts+54−25

@@ -1,6 +1,5 @@
1	"use node";	1	"use node";
2		2
3	import { Result } from "better-result";
4	import { z } from "zod";	3	import { z } from "zod";
5	import { buildOpenApiToolsFromPrepared } from "../openapi/tool-builder";	4	import { buildOpenApiToolsFromPrepared } from "../openapi/tool-builder";
6	import { buildCredentialSpec, buildStaticAuthHeaders, getCredentialSourceKey } from "../tool/source-auth";	5	import { buildCredentialSpec, buildStaticAuthHeaders, getCredentialSourceKey } from "../tool/source-auth";
@@ -16,7 +15,7 @@ import { executePostmanRequest, type PostmanSerializedRunSpec } from "../postman · 9 unmodified lines
16	import { prepareOpenApiSpec } from "../openapi-prepare";	15	import { prepareOpenApiSpec } from "../openapi-prepare";
17	import type { OpenApiToolSourceConfig } from "../tool/source-types";	16	import type { OpenApiToolSourceConfig } from "../tool/source-types";
18	import type { ToolDefinition } from "../types";	17	import type { ToolDefinition } from "../types";
19	import { asRecord } from "../utils";	18	import { toPlainObject } from "../utils";
20	import type { SerializedTool } from "../tool/source-serialization";	19	import type { SerializedTool } from "../tool/source-serialization";
21		20
22	const POSTMAN_SPEC_PREFIX = "postman:";	21	const POSTMAN_SPEC_PREFIX = "postman:";
@@ -30,6 +29,29 @@ const postmanCollectionResponseSchema = z.object({ · 7 unmodified lines
30	}).optional(),	29	}).optional(),
31	});	30	});
32		31
		32	const postmanFolderSchema = z.object({
		33	id: z.string(),
		34	name: z.string().optional(),
		35	folder: z.string().optional(),
		36	});
		37
		38	const postmanRequestSchema = z.object({
		39	id: z.string().optional(),
		40	name: z.string().optional(),
		41	method: z.string().optional(),
		42	url: z.string(),
		43	folder: z.string().optional(),
		44	pathVariableData: z.unknown().optional(),
		45	pathVariables: z.unknown().optional(),
		46	headerData: z.unknown().optional(),
		47	headers: z.unknown().optional(),
		48	queryParams: z.unknown().optional(),
		49	queryParam: z.unknown().optional(),
		50	bodyData: z.unknown().optional(),
		51	body: z.unknown().optional(),
		52	description: z.string().optional(),
		53	});
		54
33	function parsePostmanCollectionUid(spec: string): string \| null {	55	function parsePostmanCollectionUid(spec: string): string \| null {
34	if (!spec.startsWith(POSTMAN_SPEC_PREFIX)) {	56	if (!spec.startsWith(POSTMAN_SPEC_PREFIX)) {
35	return null;	57	return null;
@@ -67,14 +89,15 @@ async function loadPostmanCollectionTools( · 31 unmodified lines
67	throw new Error(`Failed to fetch API collection ${collectionUid}: HTTP ${response.status} ${text.slice(0, 300)}`);	89	throw new Error(`Failed to fetch API collection ${collectionUid}: HTTP ${response.status} ${text.slice(0, 300)}`);
68	}	90	}
69		91
70	const responseJsonResult = await Result.tryPromise(() => response.json());	92	let responseJson: unknown;
71	if (responseJsonResult.isErr()) {	93	try {
72	const cause = responseJsonResult.error.cause;	94	responseJson = await response.json();
73	const message = cause instanceof Error ? cause.message : String(cause);	95	} catch (error) {
		96	const message = error instanceof Error ? error.message : String(error);
74	throw new Error(`Failed to parse API collection ${collectionUid}: ${message}`);	97	throw new Error(`Failed to parse API collection ${collectionUid}: ${message}`);
75	}	98	}
76		99
77	const parsedCollection = postmanCollectionResponseSchema.safeParse(responseJsonResult.value);	100	const parsedCollection = postmanCollectionResponseSchema.safeParse(responseJson);
78	if (!parsedCollection.success) {	101	if (!parsedCollection.success) {
79	throw new Error(`Invalid API collection response for ${collectionUid}: ${parsedCollection.error.message}`);	102	throw new Error(`Invalid API collection response for ${collectionUid}: ${parsedCollection.error.message}`);
80	}	103	}
@@ -87,11 +110,14 @@ async function loadPostmanCollectionTools( · 6 unmodified lines
87		110
88	const folderById = new Map<string, { name: string; parentId?: string }>();	111	const folderById = new Map<string, { name: string; parentId?: string }>();
89	for (const folder of folders) {	112	for (const folder of folders) {
90	const id = typeof folder.id === "string" ? folder.id : "";	113	const parsedFolder = postmanFolderSchema.safeParse(folder);
91	if (!id) continue;	114	if (!parsedFolder.success) continue;
92	const name = typeof folder.name === "string" && folder.name.trim().length > 0 ? folder.name : "folder";	115
93	const parentId = typeof folder.folder === "string" ? folder.folder : undefined;	116	const id = parsedFolder.data.id;
94	folderById.set(id, { name, parentId });	117	const name = parsedFolder.data.name && parsedFolder.data.name.trim().length > 0
		118	? parsedFolder.data.name
		119	: "folder";
		120	folderById.set(id, { name, parentId: parsedFolder.data.folder });
95	}	121	}
96		122
97	const sourceLabel = `catalog:${config.name}`;	123	const sourceLabel = `catalog:${config.name}`;
@@ -115,29 +141,32 @@ async function loadPostmanCollectionTools( · 17 unmodified lines
115	const tools: ToolDefinition[] = [];	141	const tools: ToolDefinition[] = [];
116		142
117	for (const request of requests) {	143	for (const request of requests) {
118	const methodRaw = typeof request.method === "string" ? request.method.toLowerCase() : "get";	144	const parsedRequest = postmanRequestSchema.safeParse(request);
		145	if (!parsedRequest.success) continue;
		146
		147	const methodRaw = (parsedRequest.data.method ?? "get").toLowerCase();
119	const method = methodRaw.length > 0 ? methodRaw : "get";	148	const method = methodRaw.length > 0 ? methodRaw : "get";
120	const url = typeof request.url === "string" ? request.url : "";	149	const url = parsedRequest.data.url;
121	if (!url) continue;	150	if (!url) continue;
122		151
123	const requestId = typeof request.id === "string" ? request.id : "";	152	const requestId = parsedRequest.data.id ?? "";
124	const requestName = typeof request.name === "string" && request.name.trim().length > 0	153	const requestName = parsedRequest.data.name && parsedRequest.data.name.trim().length > 0
125	? request.name.trim()	154	? parsedRequest.data.name.trim()
126	: requestId \|\| `${method.toUpperCase()} request`;	155	: requestId \|\| `${method.toUpperCase()} request`;
127	const folderId = typeof request.folder === "string" ? request.folder : undefined;	156	const folderId = parsedRequest.data.folder;
128	const folderPath = resolvePostmanFolderPath(folderId, folderById);	157	const folderPath = resolvePostmanFolderPath(folderId, folderById);
129	const requestVariables = {	158	const requestVariables = {
130	...collectionVariables,	159	...collectionVariables,
131	...extractPostmanVariableMap(request.pathVariableData),	160	...extractPostmanVariableMap(parsedRequest.data.pathVariableData ?? parsedRequest.data.pathVariables),
132	};	161	};
133		162
134	const runSpec: PostmanSerializedRunSpec = {	163	const runSpec: PostmanSerializedRunSpec = {
135	kind: "postman",	164	kind: "postman",
136	method,	165	method,
137	url,	166	url,
138	headers: extractPostmanHeaderMap(request.headerData),	167	headers: extractPostmanHeaderMap(parsedRequest.data.headerData ?? parsedRequest.data.headers),
139	queryParams: extractPostmanQueryEntries(request.queryParams),	168	queryParams: extractPostmanQueryEntries(parsedRequest.data.queryParams ?? parsedRequest.data.queryParam),
140	body: extractPostmanBody(request),	169	body: extractPostmanBody(parsedRequest.data.bodyData ?? parsedRequest.data.body),
141	variables: requestVariables,	170	variables: requestVariables,
142	authHeaders,	171	authHeaders,
143	};	172	};
@@ -152,8 +181,8 @@ async function loadPostmanCollectionTools( · 8 unmodified lines
152	path: buildPostmanToolPath(config.name, requestName, folderPath, usedPaths),	181	path: buildPostmanToolPath(config.name, requestName, folderPath, usedPaths),
153	source: sourceLabel,	182	source: sourceLabel,
154	approval,	183	approval,
155	description: typeof request.description === "string" && request.description.trim().length > 0	184	description: parsedRequest.data.description && parsedRequest.data.description.trim().length > 0
156	? request.description	185	? parsedRequest.data.description
157	: `${method.toUpperCase()} ${url}`,	186	: `${method.toUpperCase()} ${url}`,
158	typing: {	187	typing: {
159	inputSchema,	188	inputSchema,
@@ -163,7 +192,7 @@ async function loadPostmanCollectionTools( · 3 unmodified lines
163	credential: credentialSpec,	192	credential: credentialSpec,
164	_runSpec: runSpec,	193	_runSpec: runSpec,
165	run: async (input: unknown, context) => {	194	run: async (input: unknown, context) => {
166	const payloadRecord = asRecord(input);	195	const payloadRecord = toPlainObject(input) ?? {};
167	return await executePostmanRequest(runSpec, payloadRecord, context.credential?.headers);	196	return await executePostmanRequest(runSpec, payloadRecord, context.credential?.headers);
168	},	197	},
169	};	198	};

executor/packages/core/src/tool-sources.test.ts+91−0

@@ -448,6 +448,87 @@ test("postman collection specs load and execute request tools", async () => { · 447 unmodified lines
448	}	448	}
449	});	449	});
450		450
		451	test("postman collection supports v2 body modes", async () => {
		452	const upstream = Bun.serve({
		453	port: 0,
		454	fetch: async (req) => {
		455	const url = new URL(req.url);
		456	if (req.method === "POST" && url.pathname === "/submit") {
		457	return Response.json({
		458	ok: true,
		459	body: await req.text(),
		460	contentType: req.headers.get("content-type"),
		461	token: req.headers.get("x-token"),
		462	});
		463	}
		464	return new Response("not found", { status: 404 });
		465	},
		466	});
		467
		468	const proxy = Bun.serve({
		469	port: 0,
		470	fetch: async (req) => {
		471	const body = (await req.json()) as { service?: string; method?: string; path?: string };
		472	if (body.service === "sync" && body.method === "GET" && body.path === "/collection/123-v2-body?populate=true") {
		473	return Response.json({
		474	data: {
		475	name: "Demo v2 body collection",
		476	variables: [{ key: "token", value: "Bearer v2-token" }],
		477	requests: [
		478	{
		479	id: "request_submit",
		480	name: "Submit payload",
		481	method: "POST",
		482	url: `http://127.0.0.1:${upstream.port}/submit`,
		483	headerData: [{ key: "x-token", value: "{{token}}" }],
		484	body: {
		485	mode: "urlencoded",
		486	urlencoded: [
		487	{ key: "itemId", value: "{{itemId}}" },
		488	{ key: "count", value: 2 },
		489	],
		490	},
		491	},
		492	],
		493	},
		494	});
		495	}
		496	return Response.json({ error: "unknown request" }, { status: 400 });
		497	},
		498	});
		499
		500	try {
		501	const { tools, warnings } = await loadExternalTools([
		502	{
		503	type: "openapi",
		504	name: "postman-v2-body",
		505	spec: "postman:123-v2-body",
		506	postmanProxyUrl: `http://127.0.0.1:${proxy.port}`,
		507	},
		508	]);
		509
		510	expect(warnings).toHaveLength(0);
		511	expect(tools).toHaveLength(1);
		512
		513	const result = await tools[0]!.run(
		514	{
		515	variables: { itemId: "xyz" },
		516	},
		517	{ taskId: "t", workspaceId: TEST_WORKSPACE_ID, isToolAllowed: () => true },
		518	);
		519
		520	expect(result).toEqual({
		521	ok: true,
		522	body: "itemId=xyz&count=2",
		523	contentType: "application/x-www-form-urlencoded",
		524	token: "Bearer v2-token",
		525	});
		526	} finally {
		527	proxy.stop(true);
		528	upstream.stop(true);
		529	}
		530	});
		531
451	test("parseGraphqlOperationPaths handles aliases and fragments", async () => {	532	test("parseGraphqlOperationPaths handles aliases and fragments", async () => {
452	const parsed = parseGraphqlOperationPaths(	533	const parsed = parseGraphqlOperationPaths(
453	"linear",	534	"linear",
@@ -708,6 +789,7 @@ test("graphql helper tools generate valid selection sets and envelope responses" · 254 unmodified lines
708	const batchResult = await batchTool!.run({ input: { issues: ["one"] } }, context);	789	const batchResult = await batchTool!.run({ input: { issues: ["one"] } }, context);
709	const batchResultDoubleWrapped = await batchTool!.run({ input: { input: { issues: ["two"] } } }, context);	790	const batchResultDoubleWrapped = await batchTool!.run({ input: { input: { issues: ["two"] } } }, context);
710	const rawResult = await rawTool!.run({ query: "query { teams { totalCount } }" }, context);	791	const rawResult = await rawTool!.run({ query: "query { teams { totalCount } }" }, context);
		792	const rawStringResult = await rawTool!.run("query { teams { totalCount } }", context);
711		793
712	expect(teamsResult).toEqual({	794	expect(teamsResult).toEqual({
713	data: {	795	data: {
@@ -739,6 +821,15 @@ test("graphql helper tools generate valid selection sets and envelope responses" · 25 unmodified lines
739	},	821	},
740	errors: [],	822	errors: [],
741	});	823	});
		824	expect(rawStringResult).toEqual({
		825	data: {
		826	teams: {
		827	totalCount: 1,
		828	nodes: [{ id: "team_1", name: "Core" }],
		829	},
		830	},
		831	errors: [],
		832	});
742		833
743	const helperQueries = capturedQueries.filter((query) => !query.includes("__schema"));	834	const helperQueries = capturedQueries.filter((query) => !query.includes("__schema"));
744	const helperVariables = capturedVariables.slice(1);	835	const helperVariables = capturedVariables.slice(1);

executor/packages/core/src/tool-typing/convex-sanitize.ts+6−2

 import type { JsonSchema } from "../types";
-import { asRecord } from "../utils";
+import { isPlainObject } from "../utils";
+function toRecord(value: unknown): Record<string, unknown> {
+  return isPlainObject(value) ? value : {};
+}
 function stripDollarKeysDeep(value: unknown): unknown {
   if (Array.isArray(value)) {
   if (value && typeof value === "object") {
     const out: Record<string, unknown> = {};
-    for (const [key, child] of Object.entries(asRecord(value))) {
+    for (const [key, child] of Object.entries(toRecord(value))) {
       if (key.startsWith("$")) continue;
       out[key] = stripDollarKeysDeep(child);
     }

executor/packages/core/src/tool-typing/schema-utils.ts+8−4

 import type { JsonSchema } from "../types";
-import { asRecord } from "../utils";
+import { isPlainObject } from "../utils";
+function toRecord(value: unknown): Record<string, unknown> {
+  return isPlainObject(value) ? value : {};
+}
 function uniq(values: string[]): string[] {
   return [...new Set(values.filter((v) => v.trim().length > 0))];
   const allOf = asUnknownArray(schema.allOf);
   for (const entry of allOf) {
-    const nested = asRecord(entry);
+    const nested = toRecord(entry);
     if (Object.keys(nested).length === 0) continue;
     collectTopLevelRequiredKeys(nested, out);
   }
 }
 function collectTopLevelPropertyKeys(schema: Record<string, unknown>, out: string[]): void {
-  const props = asRecord(schema.properties);
+  const props = toRecord(schema.properties);
   out.push(...Object.keys(props));
   const allOf = asUnknownArray(schema.allOf);
   for (const entry of allOf) {
-    const nested = asRecord(entry);
+    const nested = toRecord(entry);
     if (Object.keys(nested).length === 0) continue;
     collectTopLevelPropertyKeys(nested, out);
   }

executor/packages/core/src/tool-typing/typebundle.ts+6−2

 import type { ToolDefinition } from "../types";
 import { jsonSchemaTypeHintFallback } from "../openapi/schema-hints";
 import { OPENAPI_HELPER_TYPES } from "../openapi/helper-types";
-import { asRecord } from "../utils";
+import { isPlainObject } from "../utils";
 import { BASE_ENVIRONMENT_DTS } from "./env-types";
+function toRecord(value: unknown): Record<string, unknown> {
+  return isPlainObject(value) ? value : {};
+}
 const memberNameRegex = /^[$A-Z_][0-9A-Z_$]*$/i;
 function emitMemberName(name: string): string {
 function typeHintFromSchema(schema: Record<string, unknown> | undefined, fallback: string): string {
   if (!schema || Object.keys(schema).length === 0) return fallback;
   // Special-case empty object input to keep signatures tidy.
-  const props = asRecord(schema.properties);
+  const props = toRecord(schema.properties);
   const required = Array.isArray(schema.required) ? schema.required : [];
   if (Object.keys(props).length === 0 && required.length === 0) {
     return fallback === "{}" ? "{}" : fallback;

executor/packages/core/src/tool/source-auth.test.ts+77−0

@@ -0,0 +1,77 @@
	1	import { expect, test } from "bun:test";
	2	import {
	3	buildCredentialAuthHeaders,
	4	buildCredentialSpec,
	5	buildStaticAuthHeaders,
	6	readCredentialOverrideHeaders,
	7	} from "./source-auth";
	8
	9	test("buildStaticAuthHeaders returns static bearer header", () => {
	10	const headers = buildStaticAuthHeaders({
	11	type: "bearer",
	12	mode: "static",
	13	token: "secret-token",
	14	});
	15
	16	expect(headers).toEqual({ authorization: "Bearer secret-token" });
	17	});
	18
	19	test("buildCredentialSpec omits static auth and preserves actor mode", () => {
	20	expect(buildCredentialSpec("source:test", { type: "none" })).toBeUndefined();
	21	expect(
	22	buildCredentialSpec("source:test", {
	23	type: "apiKey",
	24	mode: "actor",
	25	header: "x-api-key",
	26	}),
	27	).toEqual({
	28	sourceKey: "source:test",
	29	mode: "actor",
	30	authType: "apiKey",
	31	headerName: "x-api-key",
	32	});
	33	});
	34
	35	test("buildCredentialAuthHeaders supports bearer token aliases", () => {
	36	const headers = buildCredentialAuthHeaders(
	37	{ authType: "bearer" },
	38	{ accessToken: " token-123 " },
	39	);
	40
	41	expect(headers).toEqual({ authorization: "Bearer token-123" });
	42	});
	43
	44	test("buildCredentialAuthHeaders supports apiKey aliases and explicit header", () => {
	45	const headers = buildCredentialAuthHeaders(
	46	{ authType: "apiKey", headerName: "x-custom-key" },
	47	{ apiKey: "api-value", headerName: "x-ignored" },
	48	);
	49
	50	expect(headers).toEqual({ "x-custom-key": "api-value" });
	51	});
	52
	53	test("buildCredentialAuthHeaders supports basic auth aliases", () => {
	54	const headers = buildCredentialAuthHeaders(
	55	{ authType: "basic" },
	56	{ user: "alice", pass: "hunter2" },
	57	);
	58
	59	expect(headers).toEqual({
	60	authorization: `Basic ${Buffer.from("alice:hunter2", "utf8").toString("base64")}`,
	61	});
	62	});
	63
	64	test("readCredentialOverrideHeaders trims keys and coerces values", () => {
	65	const headers = readCredentialOverrideHeaders({
	66	headers: {
	67	" x-trace-id ": "trace-1",
	68	"": "ignored",
	69	"x-retry": 2,
	70	},
	71	});
	72
	73	expect(headers).toEqual({
	74	"x-trace-id": "trace-1",
	75	"x-retry": "2",
	76	});
	77	});

executor/packages/core/src/tool/source-auth.ts+83−0

@@ -1,5 +1,88 @@
1	import type { OpenApiAuth } from "./source-types";	1	import type { OpenApiAuth } from "./source-types";
2	import type { ToolCredentialSpec } from "../types";	2	import type { ToolCredentialSpec } from "../types";
		3	import { z } from "zod";
		4
		5	export type CredentialHeaderAuthSpec = {
		6	authType: "bearer" \| "apiKey" \| "basic";
		7	headerName?: string;
		8	};
		9
		10	const secretRecordSchema = z.record(z.unknown());
		11	const credentialOverrideHeadersSchema = z.object({
		12	headers: z.record(z.coerce.string()).optional(),
		13	});
		14
		15	function toRecord(value: unknown): Record<string, unknown> {
		16	const parsed = secretRecordSchema.safeParse(value);
		17	return parsed.success ? parsed.data : {};
		18	}
		19
		20	function getTrimmedString(value: unknown): string {
		21	if (typeof value !== "string") {
		22	return "";
		23	}
		24
		25	return value.trim();
		26	}
		27
		28	function readSecretValue(record: Record<string, unknown>, aliases: string[]): string {
		29	const entries = new Map<string, unknown>();
		30	for (const [key, value] of Object.entries(record)) {
		31	entries.set(key.toLowerCase(), value);
		32	}
		33
		34	for (const alias of aliases) {
		35	const value = entries.get(alias.toLowerCase());
		36	const trimmed = getTrimmedString(value);
		37	if (trimmed) {
		38	return trimmed;
		39	}
		40	}
		41
		42	return "";
		43	}
		44
		45	export function buildCredentialAuthHeaders(
		46	auth: CredentialHeaderAuthSpec,
		47	secret: unknown,
		48	): Record<string, string> {
		49	const payload = toRecord(secret);
		50
		51	if (auth.authType === "bearer") {
		52	const token = readSecretValue(payload, ["token", "accessToken", "bearerToken", "value"]);
		53	return token ? { authorization: `Bearer ${token}` } : {};
		54	}
		55
		56	if (auth.authType === "apiKey") {
		57	const discoveredHeader = readSecretValue(payload, ["headerName", "header", "keyName"]);
		58	const headerName = (auth.headerName ?? discoveredHeader) \|\| "x-api-key";
		59	const value = readSecretValue(payload, ["value", "token", "apiKey", "key", "accessToken"]);
		60	return value ? { [headerName]: value } : {};
		61	}
		62
		63	const username = readSecretValue(payload, ["username", "user"]);
		64	const password = readSecretValue(payload, ["password", "pass"]);
		65	if (!username && !password) {
		66	return {};
		67	}
		68
		69	const encoded = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
		70	return { authorization: `Basic ${encoded}` };
		71	}
		72
		73	export function readCredentialOverrideHeaders(value: unknown): Record<string, string> {
		74	const parsed = credentialOverrideHeadersSchema.safeParse(value);
		75	const rawHeaders = parsed.success ? (parsed.data.headers ?? {}) : {};
		76
		77	const normalized: Record<string, string> = {};
		78	for (const [rawKey, rawValue] of Object.entries(rawHeaders)) {
		79	const key = rawKey.trim();
		80	if (!key) continue;
		81	normalized[key] = rawValue;
		82	}
		83
		84	return normalized;
		85	}
3		86
4	export function buildStaticAuthHeaders(auth?: OpenApiAuth): Record<string, string> {	87	export function buildStaticAuthHeaders(auth?: OpenApiAuth): Record<string, string> {
5	if (!auth \|\| auth.type === "none") return {};	88	if (!auth \|\| auth.type === "none") return {};

executor/packages/core/src/tool/source-execution.ts+10−3

 import { Result, TaggedError } from "better-result";
-import { asRecord } from "../utils";
+import { z } from "zod";
+const recordSchema = z.record(z.unknown());
+function toRecord(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 type OpenApiRequestErrorArgs = {
   status: number | null;
   input: unknown,
   credentialHeaders?: Record<string, string>,
 ): Promise<Result<unknown, OpenApiRequestError>> {
-  const payload = asRecord(input);
+  const payload = toRecord(input);
   const readMethods = new Set(["get", "head", "options"]);
   const { url, bodyInput } = buildOpenApiUrl(
     runSpec.baseUrl,
 function hasGraphqlData(data: unknown): boolean {
   if (data === null || data === undefined) return false;
   if (Array.isArray(data)) return data.length > 0;
-  if (typeof data === "object") return Object.keys(asRecord(data)).length > 0;
+  if (typeof data === "object") return Object.keys(toRecord(data)).length > 0;
   return true;
 }

executor/packages/core/src/tool/source-serialization.ts+76−29

@@ -5,7 +5,13 @@ import { callMcpToolWithReconnect, executeGraphqlRequest, executeOpenApiRequest · 4 unmodified lines
5	import { Result } from "better-result";	5	import { Result } from "better-result";
6	import { z } from "zod";	6	import { z } from "zod";
7	import type { ToolApprovalMode, ToolCredentialSpec, ToolDefinition, ToolTyping } from "../types";	7	import type { ToolApprovalMode, ToolCredentialSpec, ToolDefinition, ToolTyping } from "../types";
8	import { asRecord } from "../utils";	8
		9	const recordSchema = z.record(z.unknown());
		10
		11	function toRecord(value: unknown): Record<string, unknown> {
		12	const parsed = recordSchema.safeParse(value);
		13	return parsed.success ? parsed.data : {};
		14	}
9		15
10	export interface SerializedTool {	16	export interface SerializedTool {
11	path: string;	17	path: string;
@@ -124,21 +130,62 @@ const toolTypingSchema: z.ZodType<ToolTyping> = z.object({ · 112 unmodified lines
124		130
125	const toolCredentialSpecSchema: z.ZodType<ToolCredentialSpec> = z.object({	131	const toolCredentialSpecSchema: z.ZodType<ToolCredentialSpec> = z.object({
126	sourceKey: z.string(),	132	sourceKey: z.string(),
127	mode: z.enum(["static", "workspace", "actor"]),	133	mode: z.enum(["workspace", "actor"]),
128	authType: z.enum(["bearer", "apiKey", "basic"]),	134	authType: z.enum(["bearer", "apiKey", "basic"]),
129	headerName: z.string().optional(),	135	headerName: z.string().optional(),
130	staticSecretJson: z.record(z.unknown()).optional(),	136	staticSecretJson: z.record(z.unknown()).optional(),
131	});	137	});
132		138
133	const graphqlRawInputSchema = z.object({	139	const graphqlObjectInputSchema = z.object({
134	query: z.string(),	140	query: z.string().optional(),
135	variables: z.unknown().optional(),	141	variables: z.unknown().optional(),
		142	}).catchall(z.unknown());
		143
		144	const graphqlInvocationInputSchema = z.union([
		145	z.string(),
		146	graphqlObjectInputSchema,
		147	]);
		148
		149	const invalidSerializedToolFallbackSchema = z.object({
		150	path: z.string().optional(),
		151	source: z.string().optional(),
136	});	152	});
137		153
138	const graphqlFieldInputSchema = z.object({	154	function normalizeGraphqlInvocationInput(input: unknown): {
139	query: z.string().optional(),	155	payload: Record<string, unknown>;
140	variables: z.unknown().optional(),	156	query: string;
141	}).passthrough();	157	variables: unknown;
		158	hasExplicitQuery: boolean;
		159	} {
		160	const parsedInput = graphqlInvocationInputSchema.safeParse(input);
		161	if (!parsedInput.success) {
		162	const payload = toRecord(input);
		163	return {
		164	payload,
		165	query: "",
		166	variables: payload.variables,
		167	hasExplicitQuery: false,
		168	};
		169	}
		170
		171	if (typeof parsedInput.data === "string") {
		172	const query = parsedInput.data.trim();
		173	return {
		174	payload: { query: parsedInput.data },
		175	query,
		176	variables: undefined,
		177	hasExplicitQuery: query.length > 0,
		178	};
		179	}
		180
		181	const query = (parsedInput.data.query ?? "").trim();
		182	return {
		183	payload: parsedInput.data,
		184	query,
		185	variables: parsedInput.data.variables,
		186	hasExplicitQuery: query.length > 0,
		187	};
		188	}
142		189
143	const serializedRunSpecSchema = z.union([	190	const serializedRunSpecSchema = z.union([
144	openApiRunSpecSchema,	191	openApiRunSpecSchema,
@@ -229,16 +276,16 @@ export function rehydrateTools( · 84 unmodified lines
229	return serialized.map((candidate, index) => {	276	return serialized.map((candidate, index) => {
230	const parsed = parseSerializedTool(candidate);	277	const parsed = parseSerializedTool(candidate);
231	if (parsed.isErr()) {	278	if (parsed.isErr()) {
232	const raw = asRecord(candidate);	279	const fallback = invalidSerializedToolFallbackSchema.safeParse(candidate);
233	const path = typeof raw.path === "string" && raw.path.trim().length > 0	280	const path = fallback.success && fallback.data.path && fallback.data.path.trim().length > 0
234	? raw.path	281	? fallback.data.path
235	: `invalid_serialized_tool_${index + 1}`;	282	: `invalid_serialized_tool_${index + 1}`;
236		283
237	return {	284	return {
238	path,	285	path,
239	description: "Invalid serialized tool definition",	286	description: "Invalid serialized tool definition",
240	approval: "required",	287	approval: "required",
241	source: typeof raw.source === "string" ? raw.source : undefined,	288	source: fallback.success ? fallback.data.source : undefined,
242	run: async () => {	289	run: async () => {
243	throw new Error(`Invalid serialized tool '${path}': ${parsed.error.message}`);	290	throw new Error(`Invalid serialized tool '${path}': ${parsed.error.message}`);
244	},	291	},
@@ -282,7 +329,7 @@ export function rehydrateTools( · 37 unmodified lines
282	return {	329	return {
283	...base,	330	...base,
284	run: async (input: unknown, context) => {	331	run: async (input: unknown, context) => {
285	const payload = asRecord(input);	332	const payload = toRecord(input);
286	return await executePostmanRequest(runSpec, payload, context.credential?.headers);	333	return await executePostmanRequest(runSpec, payload, context.credential?.headers);
287	},	334	},
288	};	335	};
@@ -305,7 +352,7 @@ export function rehydrateTools( · 16 unmodified lines
305	() => connectMcp(url, queryParams, transport, mergedHeaders),	352	() => connectMcp(url, queryParams, transport, mergedHeaders),
306	);	353	);
307		354
308	const payload = asRecord(input);	355	const payload = toRecord(input);
309	const result = await callMcpToolWithReconnect(	356	const result = await callMcpToolWithReconnect(
310	() => conn.client.callTool({ name: toolName, arguments: payload }),	357	() => conn.client.callTool({ name: toolName, arguments: payload }),
311	async () => {	358	async () => {
@@ -330,14 +377,17 @@ export function rehydrateTools( · 18 unmodified lines
330	return {	377	return {
331	...base,	378	...base,
332	run: async (input: unknown, context) => {	379	run: async (input: unknown, context) => {
333	const payload = asRecord(input);	380	const normalized = normalizeGraphqlInvocationInput(input);
334	const parsedInput = graphqlRawInputSchema.safeParse(payload);	381	if (!normalized.hasExplicitQuery) {
335	const query = parsedInput.success ? parsedInput.data.query : "";
336	if (!query.trim()) {
337	throw new Error("GraphQL query string is required");	382	throw new Error("GraphQL query string is required");
338	}	383	}
339	const variables = parsedInput.success ? parsedInput.data.variables : undefined;	384	const response = await executeGraphqlRequest(
340	const response = await executeGraphqlRequest(endpoint, authHeaders, query, variables, context.credential?.headers);	385	endpoint,
		386	authHeaders,
		387	normalized.query,
		388	normalized.variables,
		389	context.credential?.headers,
		390	);
341	if (response.isErr()) {	391	if (response.isErr()) {
342	throw new Error(response.error.message);	392	throw new Error(response.error.message);
343	}	393	}
@@ -351,15 +401,12 @@ export function rehydrateTools( · 7 unmodified lines
351	return {	401	return {
352	...base,	402	...base,
353	run: async (input: unknown, context) => {	403	run: async (input: unknown, context) => {
354	const payload = asRecord(input);	404	const normalized = normalizeGraphqlInvocationInput(input);
355	const parsedInput = graphqlFieldInputSchema.safeParse(payload);	405	const query = normalized.hasExplicitQuery ? normalized.query : queryTemplate;
356	const normalizedInput = parsedInput.success ? parsedInput.data : {};	406
357	const hasExplicitQuery = typeof normalizedInput.query === "string" && normalizedInput.query.trim().length > 0;	407	let variables = normalized.variables;
358	const query = hasExplicitQuery ? normalizedInput.query : queryTemplate;	408	if (variables === undefined && !normalized.hasExplicitQuery) {
359		409	variables = normalizeGraphqlFieldVariables(argNames ?? [], normalized.payload);
360	let variables = normalizedInput.variables;
361	if (variables === undefined && !hasExplicitQuery) {
362	variables = normalizeGraphqlFieldVariables(argNames ?? [], payload);
363	}	410	}
364		411
365	const envelopeResult = await executeGraphqlRequest(	412	const envelopeResult = await executeGraphqlRequest(

executor/packages/core/src/types.ts+26−6

 export type ApprovalStatus = "pending" | "approved" | "denied";
 export type ToolCallStatus = "requested" | "pending_approval" | "completed" | "failed" | "denied";
 export type PolicyDecision = "allow" | "require_approval" | "deny";
+export type PolicyScopeType = "organization" | "workspace";
+export type PolicyMatchType = "glob" | "exact";
+export type PolicyEffect = "allow" | "deny";
+export type PolicyApprovalMode = "inherit" | "auto" | "required";
+export type OwnerScopeType = "organization" | "workspace";
 export type CredentialScope = "workspace" | "actor";
 export type CredentialProvider = "local-convex" | "workos-vault";
 export type ToolApprovalMode = "auto" | "required";
 export interface AccessPolicyRecord {
   id: string;
-  workspaceId: Id<"workspaces">;
+  scopeType?: PolicyScopeType;
-  actorId?: string;
+  organizationId?: Id<"organizations">;
+  workspaceId?: Id<"workspaces">;
+  targetActorId?: string;
   clientId?: string;
-  toolPathPattern: string;
+  resourceType?: "tool_path";
-  decision: PolicyDecision;
+  resourcePattern?: string;
+  matchType?: PolicyMatchType;
+  effect?: PolicyEffect;
+  approvalMode?: PolicyApprovalMode;
   priority: number;
   createdAt: number;
   updatedAt: number;
+  // Legacy aliases retained for callers that still expect v1 fields.
+  actorId?: string;
+  toolPathPattern: string;
+  decision: PolicyDecision;
 }
 export interface CredentialRecord {
   id: string;
   bindingId?: string;
-  workspaceId: Id<"workspaces">;
+  ownerScopeType?: OwnerScopeType;
+  organizationId?: Id<"organizations">;
+  workspaceId?: Id<"workspaces">;
   sourceKey: string;
   scope: CredentialScope;
   actorId?: string;
 export interface ToolSourceRecord {
   id: string;
-  workspaceId: Id<"workspaces">;
+  ownerScopeType?: OwnerScopeType;
+  organizationId?: Id<"organizations">;
+  workspaceId?: Id<"workspaces">;
   name: string;
   type: ToolSourceType;
   config: Record<string, unknown>;
+  specHash?: string;
+  authFingerprint?: string;
   enabled: boolean;
   createdAt: number;
   updatedAt: number;

executor/packages/core/src/utils.ts+13−7

@@ -1,12 +1,18 @@
1	/**	1	/**
2	* Safely cast an unknown value to a Record<string, unknown>.	2	* Runtime guard for plain object payloads.
3	* Returns an empty object for nullish, non-object, or array values.
4	*/	3	*/
5	export function asRecord(value: unknown): Record<string, unknown> {	4	export function isPlainObject(value: unknown): value is Record<string, unknown> {
6	if (value && typeof value === "object" && !Array.isArray(value)) {	5	if (!value \|\| typeof value !== "object" \|\| Array.isArray(value)) return false;
7	return value as Record<string, unknown>;	6
8	}	7	const prototype = Object.getPrototypeOf(value);
9	return {};	8	return prototype === Object.prototype \|\| prototype === null;
		9	}
		10
		11	/**
		12	* Convert a runtime value into a plain object record, or return undefined.
		13	*/
		14	export function toPlainObject(value: unknown): Record<string, unknown> \| undefined {
		15	return isPlainObject(value) ? value : undefined;
10	}	16	}
11		17
12	/**	18	/**

executor/packages/core/src/workspace/tool-cache.test.ts+17−3

  * round-trip with functional `run` methods.
  */
 import { test, expect, describe } from "bun:test";
+import { z } from "zod";
 import type { Id } from "../../../database/convex/_generated/dataModel";
 import {
   prepareOpenApiSpec,
 const TEST_WORKSPACE_ID = "w" as Id<"workspaces">;
+const unknownRecordSchema = z.record(z.unknown());
+const graphqlBodySchema = z.object({
+  query: z.string().optional(),
+  variables: z.unknown().optional(),
+});
 function makeBaseTools(): Map<string, ToolDefinition> {
   return new Map([
     [
           previewInputKeys: ["message"],
         },
         run: async (input: unknown) => {
-          const payload = input as Record<string, unknown>;
+          const parsedPayload = unknownRecordSchema.safeParse(input);
+          const payload = parsedPayload.success ? parsedPayload.data : {};
           return payload.message;
         },
       },
     const originalFetch = globalThis.fetch;
     const calls: Array<{ query: string; variables: unknown }> = [];
     globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
-      const body = JSON.parse(String(init?.body ?? "{}")) as { query?: string; variables?: unknown };
+      const parsedBody = graphqlBodySchema.safeParse(JSON.parse(String(init?.body ?? "{}")));
+      const body = parsedBody.success ? parsedBody.data : {};
       calls.push({ query: body.query ?? "", variables: body.variables });
       if ((body.query ?? "").includes("teams")) {
         { query: "query viewer { viewer { id } }" },
         { taskId: "t", workspaceId: TEST_WORKSPACE_ID, isToolAllowed: () => true },
       );
+      const rawStringResult = await rawTool!.run(
+        "query viewer { viewer { id } }",
+        { taskId: "t", workspaceId: TEST_WORKSPACE_ID, isToolAllowed: () => true },
+      );
       const teamsResult = await teamsTool!.run(
         {},
         { taskId: "t", workspaceId: TEST_WORKSPACE_ID, isToolAllowed: () => true },
       );
       expect(rawResult).toEqual({ data: { viewer: { id: "user_1" } }, errors: [] });
+      expect(rawStringResult).toEqual({ data: { viewer: { id: "user_1" } }, errors: [] });
       expect(teamsResult).toEqual({ data: [{ id: "team_1", name: "Core" }], errors: [] });
-      expect(calls.length).toBe(2);
+      expect(calls.length).toBe(3);
     } finally {
       globalThis.fetch = originalFetch;
     }

executor/packages/database/convex/_generated/api.d.ts+79−25

       {
         actorId?: string;
         id?: string;
+        ownerScopeType?: "organization" | "workspace";
         provider?: "local-convex" | "workos-vault";
         scope: "workspace" | "actor";
-        secretJson: any;
+        secretJson: Record<string, any>;
         sessionId?: string;
         sourceKey: string;
         workspaceId: Id<"workspaces">;
         actorId?: string;
         clientId?: string;
         code: string;
-        metadata?: any;
+        metadata?: Record<string, any>;
         runtimeId?: string;
         sessionId?: string;
         timeoutMs?: number;
       "public",
       {
         callId: string;
-        input?: any;
+        input?: Record<string, any>;
         internalSecret: string;
         runId: string;
         toolPath: string;
       "public",
       {
         actorId?: string;
+        approvalMode?: "inherit" | "auto" | "required";
         clientId?: string;
-        decision: "allow" | "require_approval" | "deny";
+        decision?: "allow" | "require_approval" | "deny";
+        effect?: "allow" | "deny";
         id?: string;
+        matchType?: "glob" | "exact";
         priority?: number;
+        scopeType?: "organization" | "workspace";
         sessionId?: string;
         toolPathPattern: string;
         workspaceId: Id<"workspaces">;
       {
         actorId?: string;
         id?: string;
-        overridesJson?: any;
+        overridesJson?: Record<string, any>;
+        ownerScopeType?: "organization" | "workspace";
         provider?: "local-convex" | "workos-vault";
         scope: "workspace" | "actor";
-        secretJson: any;
+        secretJson: Record<string, any>;
         sessionId?: string;
         sourceKey: string;
         workspaceId: Id<"workspaces">;
       "mutation",
       "public",
       {
-        config: any;
+        config: Record<string, any>;
         enabled?: boolean;
         id?: string;
         name: string;
+        ownerScopeType?: "organization" | "workspace";
         sessionId?: string;
         type: "mcp" | "openapi" | "graphql";
         workspaceId: Id<"workspaces">;
       createApproval: FunctionReference<
         "mutation",
         "internal",
-        { id: string; input?: any; taskId: string; toolPath: string },
+        {
+          id: string;
+          input?: Record<string, any>;
+          taskId: string;
+          toolPath: string;
+        },
         any
       >;
       getApproval: FunctionReference<
     createApproval: FunctionReference<
       "mutation",
       "internal",
-      { id: string; input?: any; taskId: string; toolPath: string },
+      {
+        id: string;
+        input?: Record<string, any>;
+        taskId: string;
+        toolPath: string;
+      },
       any
     >;
     createTask: FunctionReference<
         clientId?: string;
         code: string;
         id: string;
-        metadata?: any;
+        metadata?: Record<string, any>;
         runtimeId: string;
         timeoutMs?: number;
         workspaceId: Id<"workspaces">;
     createTaskEvent: FunctionReference<
       "mutation",
       "internal",
-      { eventName: string; payload: any; taskId: string; type: string },
+      {
+        eventName: string;
+        payload: Record<string, any>;
+        taskId: string;
+        type: string;
+      },
       any
     >;
     credentials: {
         {
           actorId?: string;
           id?: string;
-          overridesJson?: any;
+          overridesJson?: Record<string, any>;
+          ownerScopeType?: "organization" | "workspace";
           provider?: "local-convex" | "workos-vault";
           scope: "workspace" | "actor";
-          secretJson: any;
+          secretJson: Record<string, any>;
           sourceKey: string;
           workspaceId: Id<"workspaces">;
         },
         "internal",
         {
           actorId?: string;
+          approvalMode?: "inherit" | "auto" | "required";
           clientId?: string;
-          decision: "allow" | "require_approval" | "deny";
+          decision?: "allow" | "require_approval" | "deny";
+          effect?: "allow" | "deny";
           id?: string;
+          matchType?: "glob" | "exact";
           priority?: number;
-          toolPathPattern: string;
+          resourcePattern?: string;
+          scopeType?: "organization" | "workspace";
+          targetActorId?: string;
+          toolPathPattern?: string;
           workspaceId: Id<"workspaces">;
         },
         any
       createTaskEvent: FunctionReference<
         "mutation",
         "internal",
-        { eventName: string; payload: any; taskId: string; type: string },
+        {
+          eventName: string;
+          payload: Record<string, any>;
+          taskId: string;
+          type: string;
+        },
         any
       >;
       listTaskEvents: FunctionReference<
           clientId?: string;
           code: string;
           id: string;
-          metadata?: any;
+          metadata?: Record<string, any>;
           runtimeId: string;
           timeoutMs?: number;
           workspaceId: Id<"workspaces">;
         "mutation",
         "internal",
         {
-          config: any;
+          config: Record<string, any>;
           enabled?: boolean;
           id?: string;
           name: string;
+          ownerScopeType?: "organization" | "workspace";
           type: "mcp" | "openapi" | "graphql";
           workspaceId: Id<"workspaces">;
         },
       "internal",
       {
         actorId?: string;
+        approvalMode?: "inherit" | "auto" | "required";
         clientId?: string;
-        decision: "allow" | "require_approval" | "deny";
+        decision?: "allow" | "require_approval" | "deny";
+        effect?: "allow" | "deny";
         id?: string;
+        matchType?: "glob" | "exact";
         priority?: number;
-        toolPathPattern: string;
+        resourcePattern?: string;
+        scopeType?: "organization" | "workspace";
+        targetActorId?: string;
+        toolPathPattern?: string;
         workspaceId: Id<"workspaces">;
       },
       any
       {
         actorId?: string;
         id?: string;
-        overridesJson?: any;
+        overridesJson?: Record<string, any>;
+        ownerScopeType?: "organization" | "workspace";
         provider?: "local-convex" | "workos-vault";
         scope: "workspace" | "actor";
-        secretJson: any;
+        secretJson: Record<string, any>;
         sourceKey: string;
         workspaceId: Id<"workspaces">;
       },
       "mutation",
       "internal",
       {
-        config: any;
+        config: Record<string, any>;
         enabled?: boolean;
         id?: string;
         name: string;
+        ownerScopeType?: "organization" | "workspace";
         type: "mcp" | "openapi" | "graphql";
         workspaceId: Id<"workspaces">;
       },
         actorId: string;
         clientId?: string;
         code: string;
-        metadata?: any;
+        metadata?: Record<string, any>;
         runtimeId?: string;
         scheduleAfterCreate?: boolean;
         timeoutMs?: number;
     handleExternalToolCall: FunctionReference<
       "action",
       "internal",
-      { callId: string; input?: any; runId: string; toolPath: string },
+      {
+        callId: string;
+        input?: Record<string, any>;
+        runId: string;
+        toolPath: string;
+      },
       any
     >;
     listToolsInternal: FunctionReference<
       },
       any
     >;
+    pruneBuilds: FunctionReference<
+      "mutation",
+      "internal",
+      { maxRetainedBuilds?: number; workspaceId: Id<"workspaces"> },
+      any
+    >;
     putNamespacesBatch: FunctionReference<
       "mutation",
       "internal",

executor/packages/database/convex/credentialsNode.ts+2−0

 const credentialScopeValidator = v.union(v.literal("workspace"), v.literal("actor"));
 const credentialProviderValidator = v.union(v.literal("local-convex"), v.literal("workos-vault"));
+const ownerScopeTypeValidator = v.union(v.literal("organization"), v.literal("workspace"));
 export const upsertCredential = action({
   args: {
     id: v.optional(v.string()),
     workspaceId: v.id("workspaces"),
     sessionId: v.optional(v.string()),
+    ownerScopeType: v.optional(ownerScopeTypeValidator),
     sourceKey: v.string(),
     scope: credentialScopeValidator,
     actorId: v.optional(v.string()),

executor/packages/database/convex/database/credentials.ts+156−55

@@ -1,4 +1,5 @@
1	import { v } from "convex/values";	1	import { v } from "convex/values";
		2	import { z } from "zod";
2	import { internalMutation, internalQuery } from "../_generated/server";	3	import { internalMutation, internalQuery } from "../_generated/server";
3	import { mapCredential } from "../../src/database/mappers";	4	import { mapCredential } from "../../src/database/mappers";
4	import { computeBoundAuthFingerprint } from "../../src/database/readers";	5	import { computeBoundAuthFingerprint } from "../../src/database/readers";
@@ -6,8 +7,15 @@ import { · 1 unmodified line
6	credentialProviderValidator,	7	credentialProviderValidator,
7	credentialScopeValidator,	8	credentialScopeValidator,
8	jsonObjectValidator,	9	jsonObjectValidator,
		10	ownerScopeTypeValidator,
9	} from "../../src/database/validators";	11	} from "../../src/database/validators";
10	import { asRecord } from "../../src/lib/object";	12
		13	const recordSchema = z.record(z.unknown());
		14
		15	function toRecordValue(value: unknown): Record<string, unknown> {
		16	const parsed = recordSchema.safeParse(value);
		17	return parsed.success ? parsed.data : {};
		18	}
11		19
12	function scopeKeyForCredential(scope: "workspace" \| "actor", actorId?: string): string {	20	function scopeKeyForCredential(scope: "workspace" \| "actor", actorId?: string): string {
13	if (scope === "workspace") {	21	if (scope === "workspace") {
@@ -26,6 +34,7 @@ export const upsertCredential = internalMutation({ · 12 unmodified lines
26	args: {	34	args: {
27	id: v.optional(v.string()),	35	id: v.optional(v.string()),
28	workspaceId: v.id("workspaces"),	36	workspaceId: v.id("workspaces"),
		37	ownerScopeType: v.optional(ownerScopeTypeValidator),
29	sourceKey: v.string(),	38	sourceKey: v.string(),
30	scope: credentialScopeValidator,	39	scope: credentialScopeValidator,
31	actorId: v.optional(v.string()),	40	actorId: v.optional(v.string()),
@@ -35,20 +44,39 @@ export const upsertCredential = internalMutation({ · 3 unmodified lines
35	},	44	},
36	handler: async (ctx, args) => {	45	handler: async (ctx, args) => {
37	const now = Date.now();	46	const now = Date.now();
		47	const ownerScopeType = args.ownerScopeType ?? "workspace";
		48	const workspace = await ctx.db.get(args.workspaceId);
		49	if (!workspace) {
		50	throw new Error(`Workspace not found: ${args.workspaceId}`);
		51	}
		52	const organizationId = workspace.organizationId;
		53	const ownerWorkspaceId = ownerScopeType === "workspace" ? args.workspaceId : undefined;
		54
38	const actorId = args.scope === "actor" ? args.actorId?.trim() : undefined;	55	const actorId = args.scope === "actor" ? args.actorId?.trim() : undefined;
39	const scopeKey = scopeKeyForCredential(args.scope, actorId);	56	const scopeKey = scopeKeyForCredential(args.scope, actorId);
40	const submittedSecret = asRecord(args.secretJson);	57	const submittedSecret = toRecordValue(args.secretJson);
41	const hasSubmittedSecret = Object.keys(submittedSecret).length > 0;	58	const hasSubmittedSecret = Object.keys(submittedSecret).length > 0;
42		59
43	const existing = await ctx.db	60	const existing = ownerScopeType === "workspace"
44	.query("sourceCredentials")	61	? await ctx.db
45	.withIndex("by_workspace_source_scope_key", (q) =>	62	.query("sourceCredentials")
46	q	63	.withIndex("by_workspace_source_scope_key", (q) =>
47	.eq("workspaceId", args.workspaceId)	64	q
48	.eq("sourceKey", args.sourceKey)	65	.eq("workspaceId", args.workspaceId)
49	.eq("scopeKey", scopeKey),	66	.eq("sourceKey", args.sourceKey)
50	)	67	.eq("scopeKey", scopeKey),
51	.unique();	68	)
		69	.unique()
		70	: await ctx.db
		71	.query("sourceCredentials")
		72	.withIndex("by_organization_owner_source_scope_key", (q) =>
		73	q
		74	.eq("organizationId", organizationId)
		75	.eq("ownerScopeType", "organization")
		76	.eq("sourceKey", args.sourceKey)
		77	.eq("scopeKey", scopeKey),
		78	)
		79	.unique();
52		80
53	let requestedId = args.id?.trim() \|\| "";	81	let requestedId = args.id?.trim() \|\| "";
54	if (requestedId.startsWith("bind_")) {	82	if (requestedId.startsWith("bind_")) {
@@ -56,31 +84,42 @@ export const upsertCredential = internalMutation({ · 1 unmodified line
56	.query("sourceCredentials")	84	.query("sourceCredentials")
57	.withIndex("by_binding_id", (q) => q.eq("bindingId", requestedId))	85	.withIndex("by_binding_id", (q) => q.eq("bindingId", requestedId))
58	.unique();	86	.unique();
59	if (binding && binding.workspaceId === args.workspaceId) {	87	const sameOwner = binding
		88	&& binding.organizationId === organizationId
		89	&& binding.ownerScopeType === ownerScopeType
		90	&& (ownerScopeType === "organization" \|\| binding.workspaceId === args.workspaceId);
		91	if (sameOwner) {
60	requestedId = binding.credentialId;	92	requestedId = binding.credentialId;
61	}	93	}
62	}	94	}
63		95
64	const connectionId = requestedId \|\| existing?.credentialId \|\| `conn_${crypto.randomUUID()}`;	96	const connectionId = requestedId \|\| existing?.credentialId \|\| `conn_${crypto.randomUUID()}`;
65		97
66	const linkedRows = await ctx.db	98	const linkedRows = ownerScopeType === "workspace"
67	.query("sourceCredentials")	99	? await ctx.db
68	.withIndex("by_workspace_credential", (q) =>	100	.query("sourceCredentials")
69	q.eq("workspaceId", args.workspaceId).eq("credentialId", connectionId),	101	.withIndex("by_workspace_credential", (q) =>
70	)	102	q.eq("workspaceId", args.workspaceId).eq("credentialId", connectionId),
71	.collect();	103	)
		104	.collect()
		105	: await ctx.db
		106	.query("sourceCredentials")
		107	.withIndex("by_organization_owner_credential", (q) =>
		108	q.eq("organizationId", organizationId).eq("ownerScopeType", "organization").eq("credentialId", connectionId),
		109	)
		110	.collect();
72	const exemplar = linkedRows[0] ?? existing ?? null;	111	const exemplar = linkedRows[0] ?? existing ?? null;
73		112
74	const provider = args.provider ?? exemplar?.provider ?? "local-convex";	113	const provider = args.provider ?? exemplar?.provider ?? "local-convex";
75	const fallbackSecret = asRecord(exemplar?.secretJson);	114	const fallbackSecret = toRecordValue(exemplar?.secretJson);
76	const finalSecret = hasSubmittedSecret ? submittedSecret : fallbackSecret;	115	const finalSecret = hasSubmittedSecret ? submittedSecret : fallbackSecret;
77	if (Object.keys(finalSecret).length === 0) {	116	if (Object.keys(finalSecret).length === 0) {
78	throw new Error("Credential values are required");	117	throw new Error("Credential values are required");
79	}	118	}
80		119
81	const overridesJson = args.overridesJson === undefined	120	const overridesJson = args.overridesJson === undefined
82	? asRecord(existing?.overridesJson)	121	? toRecordValue(existing?.overridesJson)
83	: asRecord(args.overridesJson);	122	: toRecordValue(args.overridesJson);
84		123
85	const boundAuthFingerprint = await computeBoundAuthFingerprint(	124	const boundAuthFingerprint = await computeBoundAuthFingerprint(
86	ctx,	125	ctx,
@@ -100,6 +139,9 @@ export const upsertCredential = internalMutation({ · 13 unmodified lines
100		139
101	if (existing) {	140	if (existing) {
102	await ctx.db.patch(existing._id, {	141	await ctx.db.patch(existing._id, {
		142	ownerScopeType,
		143	organizationId,
		144	workspaceId: ownerWorkspaceId,
103	credentialId: connectionId,	145	credentialId: connectionId,
104	provider,	146	provider,
105	secretJson: finalSecret,	147	secretJson: finalSecret,
@@ -113,7 +155,9 @@ export const upsertCredential = internalMutation({ · 7 unmodified lines
113	await ctx.db.insert("sourceCredentials", {	155	await ctx.db.insert("sourceCredentials", {
114	bindingId: `bind_${crypto.randomUUID()}`,	156	bindingId: `bind_${crypto.randomUUID()}`,
115	credentialId: connectionId,	157	credentialId: connectionId,
116	workspaceId: args.workspaceId,	158	ownerScopeType,
		159	organizationId,
		160	workspaceId: ownerWorkspaceId,
117	sourceKey: args.sourceKey,	161	sourceKey: args.sourceKey,
118	scope: args.scope,	162	scope: args.scope,
119	scopeKey,	163	scopeKey,
@@ -127,15 +171,26 @@ export const upsertCredential = internalMutation({ · 7 unmodified lines
127	});	171	});
128	}	172	}
129		173
130	const updated = await ctx.db	174	const updated = ownerScopeType === "workspace"
131	.query("sourceCredentials")	175	? await ctx.db
132	.withIndex("by_workspace_source_scope_key", (q) =>	176	.query("sourceCredentials")
133	q	177	.withIndex("by_workspace_source_scope_key", (q) =>
134	.eq("workspaceId", args.workspaceId)	178	q
135	.eq("sourceKey", args.sourceKey)	179	.eq("workspaceId", args.workspaceId)
136	.eq("scopeKey", scopeKey),	180	.eq("sourceKey", args.sourceKey)
137	)	181	.eq("scopeKey", scopeKey),
138	.unique();	182	)
		183	.unique()
		184	: await ctx.db
		185	.query("sourceCredentials")
		186	.withIndex("by_organization_owner_source_scope_key", (q) =>
		187	q
		188	.eq("organizationId", organizationId)
		189	.eq("ownerScopeType", "organization")
		190	.eq("sourceKey", args.sourceKey)
		191	.eq("scopeKey", scopeKey),
		192	)
		193	.unique();
139		194
140	if (!updated) {	195	if (!updated) {
141	throw new Error("Failed to read upserted credential");	196	throw new Error("Failed to read upserted credential");
@@ -148,11 +203,30 @@ export const upsertCredential = internalMutation({ · 6 unmodified lines
148	export const listCredentials = internalQuery({	203	export const listCredentials = internalQuery({
149	args: { workspaceId: v.id("workspaces") },	204	args: { workspaceId: v.id("workspaces") },
150	handler: async (ctx, args) => {	205	handler: async (ctx, args) => {
151	const docs = await ctx.db	206	const workspace = await ctx.db.get(args.workspaceId);
152	.query("sourceCredentials")	207	if (!workspace) {
153	.withIndex("by_workspace_created", (q) => q.eq("workspaceId", args.workspaceId))	208	return [];
154	.order("desc")	209	}
155	.collect();	210
		211	const [workspaceDocs, organizationDocs] = await Promise.all([
		212	ctx.db
		213	.query("sourceCredentials")
		214	.withIndex("by_workspace_created", (q) => q.eq("workspaceId", args.workspaceId))
		215	.order("desc")
		216	.collect(),
		217	ctx.db
		218	.query("sourceCredentials")
		219	.withIndex("by_organization_owner_created", (q) =>
		220	q.eq("organizationId", workspace.organizationId).eq("ownerScopeType", "organization"),
		221	)
		222	.order("desc")
		223	.collect(),
		224	]);
		225
		226	const docs = [...workspaceDocs, ...organizationDocs]
		227	.filter((doc, index, entries) => entries.findIndex((candidate) => candidate.bindingId === doc.bindingId) === index)
		228	.sort((a, b) => b.createdAt - a.createdAt);
		229
156	return docs.map(mapCredential);	230	return docs.map(mapCredential);
157	},	231	},
158	});	232	});
@@ -181,35 +255,62 @@ export const resolveCredential = internalQuery({ · 22 unmodified lines
181	actorId: v.optional(v.string()),	255	actorId: v.optional(v.string()),
182	},	256	},
183	handler: async (ctx, args) => {	257	handler: async (ctx, args) => {
184	if (args.scope === "actor") {	258	const workspace = await ctx.db.get(args.workspaceId);
185	const actorId = args.actorId?.trim() \|\| "";	259	if (!workspace) {
186	if (!actorId) {	260	return null;
187	return null;	261	}
188	}	262
		263	const workspaceScopeKey = scopeKeyForCredential("workspace");
		264	const actorId = args.actorId?.trim() \|\| "";
		265	const actorScopeKey = actorId ? scopeKeyForCredential("actor", actorId) : null;
189		266
190	const actorDoc = await ctx.db	267	const tryWorkspaceOwned = async (scopeKey: string) => {
		268	return await ctx.db
191	.query("sourceCredentials")	269	.query("sourceCredentials")
192	.withIndex("by_workspace_source_scope_key", (q) =>	270	.withIndex("by_workspace_source_scope_key", (q) =>
193	q	271	q
194	.eq("workspaceId", args.workspaceId)	272	.eq("workspaceId", args.workspaceId)
195	.eq("sourceKey", args.sourceKey)	273	.eq("sourceKey", args.sourceKey)
196	.eq("scopeKey", scopeKeyForCredential("actor", actorId)),	274	.eq("scopeKey", scopeKey),
197	)	275	)
198	.unique();	276	.unique();
		277	};
		278
		279	const tryOrganizationOwned = async (scopeKey: string) => {
		280	return await ctx.db
		281	.query("sourceCredentials")
		282	.withIndex("by_organization_owner_source_scope_key", (q) =>
		283	q
		284	.eq("organizationId", workspace.organizationId)
		285	.eq("ownerScopeType", "organization")
		286	.eq("sourceKey", args.sourceKey)
		287	.eq("scopeKey", scopeKey),
		288	)
		289	.unique();
		290	};
		291
		292	if (args.scope === "actor" && actorScopeKey) {
		293	const workspaceActorDoc = await tryWorkspaceOwned(actorScopeKey);
		294	if (workspaceActorDoc) {
		295	return mapCredential(workspaceActorDoc as never);
		296	}
		297
		298	const organizationActorDoc = await tryOrganizationOwned(actorScopeKey);
		299	if (organizationActorDoc) {
		300	return mapCredential(organizationActorDoc as never);
		301	}
		302	}
		303
		304	const workspaceDoc = await tryWorkspaceOwned(workspaceScopeKey);
		305	if (workspaceDoc) {
		306	return mapCredential(workspaceDoc as never);
		307	}
199		308
200	return actorDoc ? mapCredential(actorDoc) : null;	309	const organizationDoc = await tryOrganizationOwned(workspaceScopeKey);
		310	if (organizationDoc) {
		311	return mapCredential(organizationDoc as never);
201	}	312	}
202		313
203	const workspaceDoc = await ctx.db	314	return null;
204	.query("sourceCredentials")
205	.withIndex("by_workspace_source_scope_key", (q) =>
206	q
207	.eq("workspaceId", args.workspaceId)
208	.eq("sourceKey", args.sourceKey)
209	.eq("scopeKey", scopeKeyForCredential("workspace")),
210	)
211	.unique();
212
213	return workspaceDoc ? mapCredential(workspaceDoc) : null;
214	},	315	},
215	});	316	});

executor/packages/database/convex/database/policies.ts+75−13

@@ -2,7 +2,26 @@ import { v } from "convex/values"; · 1 unmodified line
2	import { internalMutation, internalQuery } from "../_generated/server";	2	import { internalMutation, internalQuery } from "../_generated/server";
3	import { listRuntimeTargets as listAvailableRuntimeTargets } from "../../../core/src/runtimes/runtime-catalog";	3	import { listRuntimeTargets as listAvailableRuntimeTargets } from "../../../core/src/runtimes/runtime-catalog";
4	import { mapPolicy } from "../../src/database/mappers";	4	import { mapPolicy } from "../../src/database/mappers";
5	import { policyDecisionValidator } from "../../src/database/validators";	5	import {
		6	policyApprovalModeValidator,
		7	policyDecisionValidator,
		8	policyEffectValidator,
		9	policyMatchTypeValidator,
		10	policyScopeTypeValidator,
		11	} from "../../src/database/validators";
		12
		13	function parseDecision(value: "allow" \| "require_approval" \| "deny" \| undefined): {
		14	effect: "allow" \| "deny";
		15	approvalMode: "inherit" \| "auto" \| "required";
		16	} {
		17	if (value === "deny") {
		18	return { effect: "deny", approvalMode: "inherit" };
		19	}
		20	if (value === "require_approval") {
		21	return { effect: "allow", approvalMode: "required" };
		22	}
		23	return { effect: "allow", approvalMode: "auto" };
		24	}
6		25
7	export const listRuntimeTargets = internalQuery({	26	export const listRuntimeTargets = internalQuery({
8	args: {},	27	args: {},
@@ -15,15 +34,34 @@ export const upsertAccessPolicy = internalMutation({ · 6 unmodified lines
15	args: {	34	args: {
16	id: v.optional(v.string()),	35	id: v.optional(v.string()),
17	workspaceId: v.id("workspaces"),	36	workspaceId: v.id("workspaces"),
		37	scopeType: v.optional(policyScopeTypeValidator),
18	actorId: v.optional(v.string()),	38	actorId: v.optional(v.string()),
		39	targetActorId: v.optional(v.string()),
19	clientId: v.optional(v.string()),	40	clientId: v.optional(v.string()),
20	toolPathPattern: v.string(),	41	toolPathPattern: v.optional(v.string()),
21	decision: policyDecisionValidator,	42	resourcePattern: v.optional(v.string()),
		43	matchType: v.optional(policyMatchTypeValidator),
		44	decision: v.optional(policyDecisionValidator),
		45	effect: v.optional(policyEffectValidator),
		46	approvalMode: v.optional(policyApprovalModeValidator),
22	priority: v.optional(v.number()),	47	priority: v.optional(v.number()),
23	},	48	},
24	handler: async (ctx, args) => {	49	handler: async (ctx, args) => {
25	const now = Date.now();	50	const now = Date.now();
26	const policyId = args.id ?? `policy_${crypto.randomUUID()}`;	51	const policyId = args.id ?? `policy_${crypto.randomUUID()}`;
		52	const workspace = await ctx.db.get(args.workspaceId);
		53	if (!workspace) {
		54	throw new Error(`Workspace not found: ${args.workspaceId}`);
		55	}
		56
		57	const scopeType = args.scopeType ?? "workspace";
		58	const targetActorId = (args.targetActorId ?? args.actorId)?.trim() \|\| undefined;
		59	const resourcePattern = (args.resourcePattern ?? args.toolPathPattern ?? "").trim() \|\| "";
		60	const matchType = args.matchType ?? "glob";
		61	const decisionFields = parseDecision(args.decision);
		62	const effect = args.effect ?? decisionFields.effect;
		63	const approvalMode = args.approvalMode ?? decisionFields.approvalMode;
		64
27	const existing = await ctx.db	65	const existing = await ctx.db
28	.query("accessPolicies")	66	.query("accessPolicies")
29	.withIndex("by_policy_id", (q) => q.eq("policyId", policyId))	67	.withIndex("by_policy_id", (q) => q.eq("policyId", policyId))
@@ -31,22 +69,32 @@ export const upsertAccessPolicy = internalMutation({ · 1 unmodified line
31		69
32	if (existing) {	70	if (existing) {
33	await ctx.db.patch(existing._id, {	71	await ctx.db.patch(existing._id, {
34	workspaceId: args.workspaceId,	72	scopeType,
35	actorId: args.actorId?.trim() \|\| undefined,	73	organizationId: workspace.organizationId,
		74	workspaceId: scopeType === "workspace" ? args.workspaceId : undefined,
		75	targetActorId,
36	clientId: args.clientId?.trim() \|\| undefined,	76	clientId: args.clientId?.trim() \|\| undefined,
37	toolPathPattern: args.toolPathPattern,	77	resourceType: "tool_path",
38	decision: args.decision,	78	resourcePattern,
		79	matchType,
		80	effect,
		81	approvalMode,
39	priority: args.priority ?? 100,	82	priority: args.priority ?? 100,
40	updatedAt: now,	83	updatedAt: now,
41	});	84	});
42	} else {	85	} else {
43	await ctx.db.insert("accessPolicies", {	86	await ctx.db.insert("accessPolicies", {
44	policyId,	87	policyId,
45	workspaceId: args.workspaceId,	88	scopeType,
46	actorId: args.actorId?.trim() \|\| undefined,	89	organizationId: workspace.organizationId,
		90	workspaceId: scopeType === "workspace" ? args.workspaceId : undefined,
		91	targetActorId,
47	clientId: args.clientId?.trim() \|\| undefined,	92	clientId: args.clientId?.trim() \|\| undefined,
48	toolPathPattern: args.toolPathPattern,	93	resourceType: "tool_path",
49	decision: args.decision,	94	resourcePattern,
		95	matchType,
		96	effect,
		97	approvalMode,
50	priority: args.priority ?? 100,	98	priority: args.priority ?? 100,
51	createdAt: now,	99	createdAt: now,
52	updatedAt: now,	100	updatedAt: now,
@@ -67,12 +115,26 @@ export const upsertAccessPolicy = internalMutation({ · 14 unmodified lines
67	export const listAccessPolicies = internalQuery({	115	export const listAccessPolicies = internalQuery({
68	args: { workspaceId: v.id("workspaces") },	116	args: { workspaceId: v.id("workspaces") },
69	handler: async (ctx, args) => {	117	handler: async (ctx, args) => {
70	const docs = await ctx.db	118	const workspace = await ctx.db.get(args.workspaceId);
		119	if (!workspace) {
		120	return [];
		121	}
		122
		123	const workspaceDocs = await ctx.db
71	.query("accessPolicies")	124	.query("accessPolicies")
72	.withIndex("by_workspace_created", (q) => q.eq("workspaceId", args.workspaceId))	125	.withIndex("by_workspace_created", (q) => q.eq("workspaceId", args.workspaceId))
73	.collect();	126	.collect();
74		127
75	return docs	128	const organizationDocs = await ctx.db
		129	.query("accessPolicies")
		130	.withIndex("by_organization_created", (q) => q.eq("organizationId", workspace.organizationId))
		131	.collect();
		132
		133	const all = [...workspaceDocs, ...organizationDocs.filter((doc) => doc.scopeType === "organization")].filter((doc, index, entries) => {
		134	return entries.findIndex((candidate) => candidate.policyId === doc.policyId) === index;
		135	});
		136
		137	return all
76	.sort((a, b) => {	138	.sort((a, b) => {
77	if (a.priority !== b.priority) {	139	if (a.priority !== b.priority) {
78	return b.priority - a.priority;	140	return b.priority - a.priority;

executor/packages/database/convex/database/task_events.ts+1−2

 import { internalMutation, internalQuery } from "../_generated/server";
 import { getTaskDoc, mapTaskEvent } from "../../src/database/readers";
 import { jsonObjectValidator } from "../../src/database/validators";
-import { asRecord } from "../../src/lib/object";
 export const createTaskEvent = internalMutation({
   args: {
       taskId: args.taskId,
       eventName: args.eventName,
       type: args.type,
-      payload: asRecord(args.payload),
+      payload: args.payload,
       createdAt,
     });

executor/packages/database/convex/database/tasks.ts+4−2

 import { mapTask } from "../../src/database/mappers";
 import { getTaskDoc } from "../../src/database/readers";
 import { completedTaskStatusValidator, jsonObjectValidator } from "../../src/database/validators";
-import { asRecord } from "../../src/lib/object";
 import { DEFAULT_TASK_TIMEOUT_MS } from "../../src/task/constants";
 import { isTerminalTaskStatus } from "../../src/task/status";
     }
     const now = Date.now();
+    const metadata = args.metadata === undefined
+      ? {}
+      : args.metadata;
     await ctx.db.insert("tasks", {
       taskId: args.id,
       code: args.code,
       clientId: args.clientId?.trim() || undefined,
       status: "queued",
       timeoutMs: args.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS,
-      metadata: asRecord(args.metadata),
+      metadata,
       createdAt: now,
       updatedAt: now,
     });

executor/packages/database/convex/database/tool_sources.ts+64−16

@@ -6,12 +6,13 @@ import { · 5 unmodified lines
6	normalizeSourceAuthFingerprint,	6	normalizeSourceAuthFingerprint,
7	} from "../../src/database/mappers";	7	} from "../../src/database/mappers";
8	import { normalizeToolSourceConfig } from "../../src/database/tool_source_config";	8	import { normalizeToolSourceConfig } from "../../src/database/tool_source_config";
9	import { jsonObjectValidator, toolSourceTypeValidator } from "../../src/database/validators";	9	import { jsonObjectValidator, ownerScopeTypeValidator, toolSourceTypeValidator } from "../../src/database/validators";
10		10
11	export const upsertToolSource = internalMutation({	11	export const upsertToolSource = internalMutation({
12	args: {	12	args: {
13	id: v.optional(v.string()),	13	id: v.optional(v.string()),
14	workspaceId: v.id("workspaces"),	14	workspaceId: v.id("workspaces"),
		15	ownerScopeType: v.optional(ownerScopeTypeValidator),
15	name: v.string(),	16	name: v.string(),
16	type: toolSourceTypeValidator,	17	type: toolSourceTypeValidator,
17	config: jsonObjectValidator,	18	config: jsonObjectValidator,
@@ -20,6 +21,14 @@ export const upsertToolSource = internalMutation({ · 2 unmodified lines
20	handler: async (ctx, args) => {	21	handler: async (ctx, args) => {
21	const now = Date.now();	22	const now = Date.now();
22	const sourceId = args.id ?? `src_${crypto.randomUUID()}`;	23	const sourceId = args.id ?? `src_${crypto.randomUUID()}`;
		24	const ownerScopeType = args.ownerScopeType ?? "workspace";
		25	const workspace = await ctx.db.get(args.workspaceId);
		26	if (!workspace) {
		27	throw new Error(`Workspace not found: ${args.workspaceId}`);
		28	}
		29	const organizationId = workspace.organizationId;
		30	const ownerWorkspaceId = ownerScopeType === "workspace" ? args.workspaceId : undefined;
		31
23	const configResult = normalizeToolSourceConfig(args.type, args.config);	32	const configResult = normalizeToolSourceConfig(args.type, args.config);
24	if (configResult.isErr()) {	33	if (configResult.isErr()) {
25	throw new Error(configResult.error.message);	34	throw new Error(configResult.error.message);
@@ -32,19 +41,28 @@ export const upsertToolSource = internalMutation({ · 6 unmodified lines
32	.query("toolSources")	41	.query("toolSources")
33	.withIndex("by_source_id", (q) => q.eq("sourceId", sourceId))	42	.withIndex("by_source_id", (q) => q.eq("sourceId", sourceId))
34	.unique(),	43	.unique(),
35	ctx.db	44	ownerScopeType === "workspace"
36	.query("toolSources")	45	? ctx.db
37	.withIndex("by_workspace_name", (q) => q.eq("workspaceId", args.workspaceId).eq("name", args.name))	46	.query("toolSources")
38	.unique(),	47	.withIndex("by_workspace_name", (q) => q.eq("workspaceId", args.workspaceId).eq("name", args.name))
		48	.unique()
		49	: ctx.db
		50	.query("toolSources")
		51	.withIndex("by_organization_owner_name", (q) =>
		52	q.eq("organizationId", organizationId).eq("ownerScopeType", "organization").eq("name", args.name),
		53	)
		54	.unique(),
39	]);	55	]);
40		56
41	if (conflict && conflict.sourceId !== sourceId) {	57	if (conflict && conflict.sourceId !== sourceId) {
42	throw new Error(`Tool source name '${args.name}' already exists in workspace ${args.workspaceId}`);	58	throw new Error(`Tool source name '${args.name}' already exists in this scope`);
43	}	59	}
44		60
45	if (existing) {	61	if (existing) {
46	await ctx.db.patch(existing._id, {	62	await ctx.db.patch(existing._id, {
47	workspaceId: args.workspaceId,	63	ownerScopeType,
		64	organizationId,
		65	workspaceId: ownerWorkspaceId,
48	name: args.name,	66	name: args.name,
49	type: args.type,	67	type: args.type,
50	config,	68	config,
@@ -56,7 +74,9 @@ export const upsertToolSource = internalMutation({ · 5 unmodified lines
56	} else {	74	} else {
57	await ctx.db.insert("toolSources", {	75	await ctx.db.insert("toolSources", {
58	sourceId,	76	sourceId,
59	workspaceId: args.workspaceId,	77	ownerScopeType,
		78	organizationId,
		79	workspaceId: ownerWorkspaceId,
60	name: args.name,	80	name: args.name,
61	type: args.type,	81	type: args.type,
62	config,	82	config,
@@ -82,11 +102,30 @@ export const upsertToolSource = internalMutation({ · 19 unmodified lines
82	export const listToolSources = internalQuery({	102	export const listToolSources = internalQuery({
83	args: { workspaceId: v.id("workspaces") },	103	args: { workspaceId: v.id("workspaces") },
84	handler: async (ctx, args) => {	104	handler: async (ctx, args) => {
85	const docs = await ctx.db	105	const workspace = await ctx.db.get(args.workspaceId);
86	.query("toolSources")	106	if (!workspace) {
87	.withIndex("by_workspace_updated", (q) => q.eq("workspaceId", args.workspaceId))	107	return [];
88	.order("desc")	108	}
89	.collect();	109
		110	const [workspaceDocs, organizationDocs] = await Promise.all([
		111	ctx.db
		112	.query("toolSources")
		113	.withIndex("by_workspace_updated", (q) => q.eq("workspaceId", args.workspaceId))
		114	.order("desc")
		115	.collect(),
		116	ctx.db
		117	.query("toolSources")
		118	.withIndex("by_organization_owner_updated", (q) =>
		119	q.eq("organizationId", workspace.organizationId).eq("ownerScopeType", "organization"),
		120	)
		121	.order("desc")
		122	.collect(),
		123	]);
		124
		125	const docs = [...workspaceDocs, ...organizationDocs]
		126	.filter((doc, index, entries) => entries.findIndex((candidate) => candidate.sourceId === doc.sourceId) === index)
		127	.sort((a, b) => b.updatedAt - a.updatedAt);
		128
90	return docs.map(mapSource);	129	return docs.map(mapSource);
91	},	130	},
92	});	131	});
@@ -94,20 +133,29 @@ export const listToolSources = internalQuery({ · 1 unmodified line
94	export const deleteToolSource = internalMutation({	133	export const deleteToolSource = internalMutation({
95	args: { workspaceId: v.id("workspaces"), sourceId: v.string() },	134	args: { workspaceId: v.id("workspaces"), sourceId: v.string() },
96	handler: async (ctx, args) => {	135	handler: async (ctx, args) => {
		136	const workspace = await ctx.db.get(args.workspaceId);
		137	if (!workspace) {
		138	return false;
		139	}
		140
97	const doc = await ctx.db	141	const doc = await ctx.db
98	.query("toolSources")	142	.query("toolSources")
99	.withIndex("by_source_id", (q) => q.eq("sourceId", args.sourceId))	143	.withIndex("by_source_id", (q) => q.eq("sourceId", args.sourceId))
100	.unique();	144	.unique();
101		145
102	if (!doc \|\| doc.workspaceId !== args.workspaceId) {	146	if (!doc \|\| doc.organizationId !== workspace.organizationId) {
		147	return false;
		148	}
		149
		150	if (doc.ownerScopeType === "workspace" && doc.workspaceId !== args.workspaceId) {
103	return false;	151	return false;
104	}	152	}
105		153
106	const sourceKey = `source:${args.sourceId}`;	154	const sourceKey = `source:${args.sourceId}`;
107	const bindings = await ctx.db	155	const bindings = await ctx.db
108	.query("sourceCredentials")	156	.query("sourceCredentials")
109	.withIndex("by_workspace_source_scope_key", (q) =>	157	.withIndex("by_organization_source", (q) =>
110	q.eq("workspaceId", args.workspaceId).eq("sourceKey", sourceKey),	158	q.eq("organizationId", workspace.organizationId).eq("sourceKey", sourceKey),
111	)	159	)
112	.collect();	160	.collect();
113		161

executor/packages/database/convex/migrations.ts+4−2

 export const cleanupAccessPolicyEmptyStringSentinels = migrations.define({
   table: "accessPolicies",
   migrateOne: async (_ctx, policy) => {
+    const policyRecord = policy as Record<string, unknown>;
     const patch: Record<string, undefined> = {};
-    if (policy.actorId === "") patch.actorId = undefined;
+    if (Reflect.get(policyRecord, "actorId") === "") patch["actorId"] = undefined;
-    if (policy.clientId === "") patch.clientId = undefined;
+    if (Reflect.get(policyRecord, "targetActorId") === "") patch["targetActorId"] = undefined;
+    if (policy.clientId === "") patch["clientId"] = undefined;
     if (Object.keys(patch).length > 0) return patch;
   },
 });

executor/packages/database/convex/schema.ts+46−18

   v.literal("denied"),
 );
 const toolApprovalMode = v.union(v.literal("auto"), v.literal("required"));
-const policyDecision = v.union(v.literal("allow"), v.literal("require_approval"), v.literal("deny"));
+const policyScopeType = v.union(v.literal("organization"), v.literal("workspace"));
+const policyResourceType = v.literal("tool_path");
+const policyMatchType = v.union(v.literal("glob"), v.literal("exact"));
+const policyEffect = v.union(v.literal("allow"), v.literal("deny"));
+const policyApprovalMode = v.union(v.literal("inherit"), v.literal("auto"), v.literal("required"));
+const ownerScopeType = v.union(v.literal("organization"), v.literal("workspace"));
 const credentialScope = v.union(v.literal("workspace"), v.literal("actor"));
 const credentialProvider = v.union(
   v.literal("local-convex"),
   })
     .index("by_task_sequence", ["taskId", "sequence"]),
-  // Workspace access policy rules used by the approval / tool firewall.
+  // Workspace + organization access policy rules used by the approval / tool firewall.
-  // `toolPathPattern` is matched against tool paths and combined with actor/client selectors.
+  // Rules can target specific actors and clients, and can match tool paths either exactly
-  // Higher `priority` wins when multiple policies match.
+  // or with a glob pattern.
   accessPolicies: defineTable({
     policyId: v.string(), // domain ID: policy_<uuid>
-    workspaceId: v.id("workspaces"),
+    scopeType: policyScopeType,
-    actorId: v.optional(v.string()), // account._id or anon_<uuid>
+    organizationId: v.id("organizations"),
+    workspaceId: v.optional(v.id("workspaces")),
+    targetActorId: v.optional(v.string()), // account._id or anon_<uuid>
     clientId: v.optional(v.string()), // client label: "web", "mcp", etc.
-    toolPathPattern: v.string(),
+    resourceType: policyResourceType,
-    decision: policyDecision,
+    resourcePattern: v.string(),
+    matchType: policyMatchType,
+    effect: policyEffect,
+    approvalMode: policyApprovalMode,
     priority: v.number(),
     createdAt: v.number(),
     updatedAt: v.number(),
   })
     .index("by_policy_id", ["policyId"])
-    .index("by_workspace_created", ["workspaceId", "createdAt"]),
+    .index("by_workspace_created", ["workspaceId", "createdAt"])
+    .index("by_organization_created", ["organizationId", "createdAt"]),
   // Stored credentials for tool sources.
   //
   // A single credential "connection" (credentialId) can have multiple rows to support
-  // different bindings (workspace-wide and per-actor). `bindingId` exists as a stable handle
+  // different bindings (workspace-wide and per-actor), and can be owned by either a
+  // workspace or an organization.
+  // `bindingId` exists as a stable handle
   // for UI/API operations that need an id before the connection id is known.
   //
   // Primary access patterns:
-  // - Resolve by (workspaceId, sourceKey, scopeKey).
+  // - Resolve by (workspaceId|organizationId, sourceKey, scopeKey).
-  // - List all credentials in workspace by createdAt.
+  // - List effective credentials for a workspace by createdAt.
   sourceCredentials: defineTable({
     bindingId: v.string(), // domain ID: bind_<uuid>
     credentialId: v.string(), // domain ID: conn_<uuid>
-    workspaceId: v.id("workspaces"),
+    ownerScopeType: ownerScopeType,
+    organizationId: v.id("organizations"),
+    workspaceId: v.optional(v.id("workspaces")),
     sourceKey: v.string(),
     scope: credentialScope,
     scopeKey: v.string(), // "workspace" or actor:<actorId>
     updatedAt: v.number(),
   })
     .index("by_workspace_created", ["workspaceId", "createdAt"])
+    .index("by_organization_created", ["organizationId", "createdAt"])
+    .index("by_organization_owner_created", ["organizationId", "ownerScopeType", "createdAt"])
     .index("by_workspace_source_scope_key", ["workspaceId", "sourceKey", "scopeKey"])
+    .index("by_organization_source_scope_key", ["organizationId", "sourceKey", "scopeKey"])
+    .index("by_organization_owner_source_scope_key", ["organizationId", "ownerScopeType", "sourceKey", "scopeKey"])
     .index("by_workspace_credential", ["workspaceId", "credentialId"])
+    .index("by_organization_credential", ["organizationId", "credentialId"])
+    .index("by_organization_owner_credential", ["organizationId", "ownerScopeType", "credentialId"])
+    .index("by_organization_source", ["organizationId", "sourceKey"])
     .index("by_binding_id", ["bindingId"]),
-  // Configured tool sources for a workspace (MCP servers, OpenAPI sources, GraphQL sources).
+  // Configured tool sources for a workspace/organization (MCP servers, OpenAPI sources, GraphQL sources).
   // `specHash` enables cache invalidation when the definition changes.
   // `authFingerprint` is used to determine whether cached tool materialization is still valid.
   //
   // Primary access patterns:
   // - Resolve by domain source id.
-  // - List sources by workspace, sorted by updatedAt.
+  // - List effective sources by workspace, sorted by updatedAt.
-  // - Enforce name uniqueness per workspace.
+  // - Enforce name uniqueness per owner scope.
   toolSources: defineTable({
     sourceId: v.string(), // domain ID: src_<uuid>
-    workspaceId: v.id("workspaces"),
+    ownerScopeType: ownerScopeType,
+    organizationId: v.id("organizations"),
+    workspaceId: v.optional(v.id("workspaces")),
     name: v.string(),
     type: toolSourceType,
     config: jsonObject,
   })
     .index("by_source_id", ["sourceId"])
     .index("by_workspace_updated", ["workspaceId", "updatedAt"])
-    .index("by_workspace_name", ["workspaceId", "name"]),
+    .index("by_organization_updated", ["organizationId", "updatedAt"])
+    .index("by_organization_owner_updated", ["organizationId", "ownerScopeType", "updatedAt"])
+    .index("by_workspace_name", ["workspaceId", "name"])
+    .index("by_organization_name", ["organizationId", "name"])
+    .index("by_organization_owner_name", ["organizationId", "ownerScopeType", "name"]),
   // Cached OpenAPI spec blobs stored in Convex storage.
   // (specUrl, version) uniquely identifies a stored spec payload.

executor/packages/database/convex/toolRegistry.ts+62−0

@@ -176,6 +176,68 @@ export const finishBuild = internalMutation({ · 175 unmodified lines
176	},	176	},
177	});	177	});
178		178
		179	export const pruneBuilds = internalMutation({
		180	args: {
		181	workspaceId: v.id("workspaces"),
		182	maxRetainedBuilds: v.optional(v.number()),
		183	},
		184	handler: async (ctx, args) => {
		185	const maxRetainedBuilds = Math.max(1, Math.min(10, Math.floor(args.maxRetainedBuilds ?? 2)));
		186	const state = await ctx.db
		187	.query("workspaceToolRegistryState")
		188	.withIndex("by_workspace", (q) => q.eq("workspaceId", args.workspaceId))
		189	.unique();
		190
		191	const protectedBuildIds = new Set<string>();
		192	if (state?.readyBuildId) protectedBuildIds.add(state.readyBuildId);
		193	if (state?.buildingBuildId) protectedBuildIds.add(state.buildingBuildId);
		194
		195	const toolEntries = await ctx.db
		196	.query("workspaceToolRegistry")
		197	.withIndex("by_workspace_build", (q) => q.eq("workspaceId", args.workspaceId))
		198	.collect();
		199
		200	const namespaceEntries = await ctx.db
		201	.query("workspaceToolNamespaces")
		202	.withIndex("by_workspace_build", (q) => q.eq("workspaceId", args.workspaceId))
		203	.collect();
		204
		205	const latestCreatedAtByBuild = new Map<string, number>();
		206	for (const entry of toolEntries) {
		207	const current = latestCreatedAtByBuild.get(entry.buildId) ?? 0;
		208	if (entry.createdAt > current) {
		209	latestCreatedAtByBuild.set(entry.buildId, entry.createdAt);
		210	}
		211	}
		212	for (const entry of namespaceEntries) {
		213	const current = latestCreatedAtByBuild.get(entry.buildId) ?? 0;
		214	if (entry.createdAt > current) {
		215	latestCreatedAtByBuild.set(entry.buildId, entry.createdAt);
		216	}
		217	}
		218
		219	const buildIdsByRecency = [...latestCreatedAtByBuild.entries()]
		220	.sort((a, b) => b[1] - a[1])
		221	.map(([buildId]) => buildId);
		222
		223	const retained = new Set<string>(buildIdsByRecency.slice(0, maxRetainedBuilds));
		224	for (const protectedBuildId of protectedBuildIds) {
		225	retained.add(protectedBuildId);
		226	}
		227
		228	for (const entry of toolEntries) {
		229	if (!retained.has(entry.buildId)) {
		230	await ctx.db.delete(entry._id);
		231	}
		232	}
		233	for (const entry of namespaceEntries) {
		234	if (!retained.has(entry.buildId)) {
		235	await ctx.db.delete(entry._id);
		236	}
		237	}
		238	},
		239	});
		240
179	export const getToolByPath = internalQuery({	241	export const getToolByPath = internalQuery({
180	args: {	242	args: {
181	workspaceId: v.id("workspaces"),	243	workspaceId: v.id("workspaces"),

executor/packages/database/convex/workspace.ts+51−1

 import { internal } from "./_generated/api";
 import { mutation } from "./_generated/server";
 import { workspaceMutation, workspaceQuery } from "../../core/src/function-builders";
+import { getOrganizationMembership, isAdminRole } from "../../core/src/identity";
 import {
   credentialProviderValidator,
   credentialScopeValidator,
   jsonObjectValidator,
+  ownerScopeTypeValidator,
+  policyApprovalModeValidator,
   policyDecisionValidator,
+  policyEffectValidator,
+  policyMatchTypeValidator,
+  policyScopeTypeValidator,
   toolSourceTypeValidator,
 } from "../src/database/validators";
   requireAdmin: true,
   args: {
     id: v.optional(v.string()),
+    scopeType: v.optional(policyScopeTypeValidator),
     actorId: v.optional(v.string()),
     clientId: v.optional(v.string()),
     toolPathPattern: v.string(),
-    decision: policyDecisionValidator,
+    decision: v.optional(policyDecisionValidator),
+    matchType: v.optional(policyMatchTypeValidator),
+    effect: v.optional(policyEffectValidator),
+    approvalMode: v.optional(policyApprovalModeValidator),
     priority: v.optional(v.number()),
   },
   handler: async (ctx, args) => {
+    if (args.scopeType === "organization") {
+      const organizationMembership = await getOrganizationMembership(ctx, ctx.workspace.organizationId, ctx.account._id);
+      if (!organizationMembership || !isAdminRole(organizationMembership.role)) {
+        throw new Error("Only organization admins can create organization-level policies");
+      }
+    }
     return await ctx.runMutation(internal.database.upsertAccessPolicy, {
       ...args,
       workspaceId: ctx.workspaceId,
   requireAdmin: true,
   args: {
     id: v.optional(v.string()),
+    ownerScopeType: v.optional(ownerScopeTypeValidator),
     sourceKey: v.string(),
     scope: credentialScopeValidator,
     actorId: v.optional(v.string()),
     overridesJson: v.optional(jsonObjectValidator),
   },
   handler: async (ctx, args) => {
+    if (args.ownerScopeType === "organization") {
+      const organizationMembership = await getOrganizationMembership(ctx, ctx.workspace.organizationId, ctx.account._id);
+      if (!organizationMembership || !isAdminRole(organizationMembership.role)) {
+        throw new Error("Only organization admins can manage organization-level credentials");
+      }
+    }
     return await ctx.runMutation(internal.database.upsertCredential, {
       ...args,
       workspaceId: ctx.workspaceId,
   requireAdmin: true,
   args: {
     id: v.optional(v.string()),
+    ownerScopeType: v.optional(ownerScopeTypeValidator),
     name: v.string(),
     type: toolSourceTypeValidator,
     config: jsonObjectValidator,
     enabled: v.optional(v.boolean()),
   },
   handler: async (ctx, args) => {
+    if (args.ownerScopeType === "organization") {
+      const organizationMembership = await getOrganizationMembership(ctx, ctx.workspace.organizationId, ctx.account._id);
+      if (!organizationMembership || !isAdminRole(organizationMembership.role)) {
+        throw new Error("Only organization admins can manage organization-level tool sources");
+      }
+    }
     return await ctx.runMutation(internal.database.upsertToolSource, {
       ...args,
       workspaceId: ctx.workspaceId,
     sourceId: v.string(),
   },
   handler: async (ctx, args) => {
+    const sources = await ctx.runQuery(internal.database.listToolSources, {
+      workspaceId: ctx.workspaceId,
+    });
+    let source: { id: string; ownerScopeType?: "organization" | "workspace" } | undefined;
+    for (const entry of sources as Array<{ id: string; ownerScopeType?: "organization" | "workspace" }>) {
+      if (entry.id === args.sourceId) {
+        source = entry;
+        break;
+      }
+    }
+    if (source?.ownerScopeType === "organization") {
+      const organizationMembership = await getOrganizationMembership(ctx, ctx.workspace.organizationId, ctx.account._id);
+      if (!organizationMembership || !isAdminRole(organizationMembership.role)) {
+        throw new Error("Only organization admins can delete organization-level tool sources");
+      }
+    }
     return await ctx.runMutation(internal.database.deleteToolSource, {
       ...args,
       workspaceId: ctx.workspaceId,

executor/packages/database/src/accounts/delete-current-account.ts+24−0

@@ -135,6 +135,30 @@ async function deleteOrganizationData( · 134 unmodified lines
135	await ctx.db.delete(seatState._id);	135	await ctx.db.delete(seatState._id);
136	}	136	}
137		137
		138	const policyDocs = await ctx.db
		139	.query("accessPolicies")
		140	.withIndex("by_organization_created", (q) => q.eq("organizationId", organizationId))
		141	.collect();
		142	for (const policy of policyDocs) {
		143	await ctx.db.delete(policy._id);
		144	}
		145
		146	const credentialDocs = await ctx.db
		147	.query("sourceCredentials")
		148	.withIndex("by_organization_created", (q) => q.eq("organizationId", organizationId))
		149	.collect();
		150	for (const credential of credentialDocs) {
		151	await ctx.db.delete(credential._id);
		152	}
		153
		154	const toolSources = await ctx.db
		155	.query("toolSources")
		156	.withIndex("by_organization_updated", (q) => q.eq("organizationId", organizationId))
		157	.collect();
		158	for (const source of toolSources) {
		159	await ctx.db.delete(source._id);
		160	}
		161
138	const workspaces = await ctx.db	162	const workspaces = await ctx.db
139	.query("workspaces")	163	.query("workspaces")
140	.withIndex("by_organization_created", (q) => q.eq("organizationId", organizationId))	164	.withIndex("by_organization_created", (q) => q.eq("organizationId", organizationId))

executor/packages/database/src/auth/identity.ts+7−3

 import { components } from "../../convex/_generated/api";
+import { z } from "zod";
 import type { RunQueryCtx } from "./types";
 type WorkosProfile = {
   profilePictureUrl?: string | null;
 };
+const nonEmptyTrimmedStringSchema = z.string().transform((value) => value.trim()).refine((value) => value.length > 0);
 function deriveFallbackUserLabel(workosUserId: string): string {
   return `User ${workosUserId.slice(-6)}`;
 }
 function getIdentityString(identity: Record<string, unknown>, keys: string[]): string | undefined {
   for (const key of keys) {
-    const value = identity[key];
+    const parsedValue = nonEmptyTrimmedStringSchema.safeParse(identity[key]);
-    if (typeof value === "string" && value.trim().length > 0) {
+    if (parsedValue.success) {
-      return value.trim();
+      return parsedValue.data;
     }
   }
   return undefined;
 }

executor/packages/database/src/credentials-node/upsert-credential.ts+100−85

-import { WorkOS } from "@workos-inc/node";
+import { Result } from "better-result";
+import { z } from "zod";
 import type { Id } from "../../convex/_generated/dataModel.d.ts";
 import type { ActionCtx } from "../../convex/_generated/server";
+import {
+  createWorkosClient,
+  extractWorkosVaultObjectId,
+  withWorkosVaultRetryResult,
+} from "../../../core/src/credentials/workos-vault";
 import {
   assertMatchesCanonicalActorId,
   canonicalActorIdForWorkspaceAccess,
 } from "../auth/actor_identity";
-import { asRecord } from "../lib/object";
 type Internal = typeof import("../../convex/_generated/api").internal;
 type SecretBackend = "local-convex" | "workos-vault";
+const recordSchema = z.record(z.unknown());
+const secretPayloadSchema = z.object({
+  __headers: z.record(z.unknown()).optional(),
+}).catchall(z.unknown());
+const listedCredentialSchema = z.object({
+  id: z.string().optional(),
+  bindingId: z.string().optional(),
+  ownerScopeType: z.enum(["organization", "workspace"]).optional(),
+  scope: z.enum(["workspace", "actor"]).optional(),
+  actorId: z.string().optional(),
+  secretJson: z.record(z.unknown()).optional(),
+});
+type ListedCredential = z.infer<typeof listedCredentialSchema>;
+function toRecordValue(value: unknown): Record<string, unknown> {
+  const parsed = recordSchema.safeParse(value);
+  return parsed.success ? parsed.data : {};
+}
 function normalizedActorId(scope: "workspace" | "actor", actorId?: string): string {
   if (scope !== "actor") return "";
   if (typeof actorId !== "string") return "";
   return process.env.WORKOS_API_KEY?.trim() ? "workos-vault" : "local-convex";
 }
-function extractObjectId(secretJson: Record<string, unknown>): string | null {
-  const candidate =
-    (typeof secretJson.objectId === "string" ? secretJson.objectId : "") ||
-    (typeof secretJson.id === "string" ? secretJson.id : "");
-  const trimmed = candidate.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
 function extractHeaderOverrides(secretJson: Record<string, unknown>): {
   cleanSecret: Record<string, unknown>;
   overridesJson: Record<string, unknown>;
 } {
-  const rawHeaders = asRecord(secretJson.__headers);
+  const parsedSecret = secretPayloadSchema.safeParse(secretJson);
+  const normalizedSecret = parsedSecret.success ? parsedSecret.data : {};
+  const rawHeaders = toRecordValue(normalizedSecret.__headers);
   const headers: Record<string, string> = {};
   for (const [name, value] of Object.entries(rawHeaders)) {
-    if (!name) continue;
+    const headerName = name.trim();
+    if (!headerName) continue;
     const text = typeof value === "string" ? value.trim() : String(value ?? "").trim();
     if (!text) continue;
-    headers[name.trim()] = text;
+    headers[headerName] = text;
   }
-  const { __headers: _headers, ...rest } = secretJson;
+  const { __headers: _headers, ...rest } = normalizedSecret;
   return {
-    cleanSecret: asRecord(rest),
+    cleanSecret: toRecordValue(rest),
     overridesJson: Object.keys(headers).length > 0 ? { headers } : {},
   };
 }
+function parseListedCredentials(value: unknown): ListedCredential[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const parsed = listedCredentialSchema.safeParse(entry);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
 function buildVaultObjectName(args: {
   workspaceId: string;
   sourceKey: string;
   return `executor-conn-${args.workspaceId.slice(0, 24)}-${sourceSegment}-${actorSegment.slice(0, 24)}-${crypto.randomUUID().slice(0, 8)}`;
 }
-function workosClient(): WorkOS {
-  const key = process.env.WORKOS_API_KEY?.trim();
-  if (!key) {
-    throw new Error("Encrypted storage requires WORKOS_API_KEY");
-  }
-  return new WorkOS(key);
-}
-function isRetryableVaultError(error: unknown): boolean {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  const message = error.message.toLowerCase();
-  return (
-    message.includes("not yet ready") ||
-    message.includes("can be retried") ||
-    (message.includes("kek") && message.includes("ready"))
-  );
-}
-async function sleep(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withVaultRetry<T>(operation: () => Promise<T>): Promise<T> {
-  const maxAttempts = 10;
-  const maxDelayMs = 10_000;
-  let delayMs = 500;
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (!isRetryableVaultError(error)) {
-        throw error;
-      }
-      if (attempt === maxAttempts) {
-        throw new Error(
-          "Encrypted storage is still initializing in WorkOS. Please wait about 60 seconds and retry.",
-        );
-      }
-      await sleep(delayMs);
-      delayMs = Math.min(delayMs * 2, maxDelayMs);
-    }
-  }
-  throw new Error("Unreachable retry state");
-}
 async function upsertVaultObject(args: {
   workspaceId: string;
   sourceKey: string;
   actorId: string;
   existingObjectId: string | null;
   payload: Record<string, unknown>;
-}): Promise<string> {
+}): Promise<Result<string, Error>> {
-  const workos = workosClient();
+  const workosResult = createWorkosClient();
+  if (workosResult.isErr()) {
+    return Result.err(workosResult.error);
+  }
+  const workos = workosResult.value;
   const value = JSON.stringify(args.payload);
   if (args.existingObjectId) {
     const objectId: string = args.existingObjectId;
-    const updated = await withVaultRetry(async () => {
+    const updatedResult = await withWorkosVaultRetryResult(async () => {
       return await workos.vault.updateObject({
         id: objectId,
         value,
       });
+    }, {
+      maxAttempts: 10,
+      initialDelayMs: 500,
+      maxDelayMs: 10_000,
+      exhaustionErrorMessage: "Encrypted storage is still initializing in WorkOS. Please wait about 60 seconds and retry.",
     });
-    return updated.id;
+    if (updatedResult.isErr()) {
+      return Result.err(updatedResult.error);
+    }
+    return Result.ok(updatedResult.value.id);
   }
-  const created = await withVaultRetry(async () => {
+  const createdResult = await withWorkosVaultRetryResult(async () => {
     return await workos.vault.createObject({
       name: buildVaultObjectName(args),
       value,
         workspace_id: args.workspaceId,
       },
     });
+  }, {
+    maxAttempts: 10,
+    initialDelayMs: 500,
+    maxDelayMs: 10_000,
+    exhaustionErrorMessage: "Encrypted storage is still initializing in WorkOS. Please wait about 60 seconds and retry.",
   });
+  if (createdResult.isErr()) {
+    return Result.err(createdResult.error);
+  }
-  return created.id;
+  return Result.ok(createdResult.value.id);
 }
 export async function upsertCredentialHandler(
     id?: string;
     workspaceId: Id<"workspaces">;
     sessionId?: string;
+    ownerScopeType?: "organization" | "workspace";
     sourceKey: string;
     scope: "workspace" | "actor";
     actorId?: string;
   }
   const actorId = normalizedActorId(args.scope, args.actorId ?? canonicalActorId);
-  const rawSubmittedSecret = asRecord(args.secretJson);
+  const ownerScopeType = args.ownerScopeType ?? "workspace";
+  const rawSubmittedSecret = toRecordValue(args.secretJson);
   const { cleanSecret: submittedSecret, overridesJson } = extractHeaderOverrides(rawSubmittedSecret);
   const existingBinding = await ctx.runQuery(internal.database.resolveCredential, {
     ...(args.scope === "actor" ? { actorId } : {}),
   });
-  const allCredentials: Array<Record<string, unknown>> = await ctx.runQuery(internal.database.listCredentials, {
+  const allCredentialsRaw = await ctx.runQuery(internal.database.listCredentials, {
     workspaceId: args.workspaceId,
   });
+  const allCredentials = parseListedCredentials(allCredentialsRaw);
   const requestedId = args.id?.trim();
   const existingConnection = requestedId
     ? allCredentials.find((credential) => {
-      const id = String(credential.id ?? "");
+      const id = (credential.id ?? "").trim();
-      const bindingId = String(credential.bindingId ?? "");
+      const bindingId = (credential.bindingId ?? "").trim();
       if (id !== requestedId && bindingId !== requestedId) return false;
-      if (String(credential.scope ?? "") !== args.scope) return false;
+      if ((credential.ownerScopeType ?? "workspace") !== ownerScopeType) return false;
+      if (credential.scope !== args.scope) return false;
       if (args.scope === "actor") {
-        return String(credential.actorId ?? "") === actorId;
+        return (credential.actorId ?? "").trim() === actorId;
       }
       return true;
     }) ?? allCredentials.find((credential) => {
-      const id = String(credential.id ?? "");
+      const id = (credential.id ?? "").trim();
-      const bindingId = String(credential.bindingId ?? "");
+      const bindingId = (credential.bindingId ?? "").trim();
       return id === requestedId || bindingId === requestedId;
     })
     : null;
-  const connectionId = String(existingConnection?.id ?? requestedId ?? "").trim() || undefined;
+  const connectionId = (existingConnection?.id ?? requestedId ?? "").trim() || undefined;
   const backend = configuredSecretBackend();
   if (backend === "local-convex") {
     const finalSecret = Object.keys(submittedSecret).length > 0
       ? submittedSecret
-      : asRecord(existingConnection?.secretJson ?? existingBinding?.secretJson);
+      : toRecordValue(existingConnection?.secretJson ?? existingBinding?.secretJson);
     if (Object.keys(finalSecret).length === 0) {
       throw new Error("Credential values are required");
     }
     return await ctx.runMutation(internal.database.upsertCredential, {
       id: connectionId,
       workspaceId: args.workspaceId,
+      ownerScopeType,
       sourceKey: args.sourceKey,
       scope: args.scope,
       ...(args.scope === "actor" ? { actorId } : {}),
     });
   }
-  const submittedObjectId = extractObjectId(submittedSecret);
+  const submittedObjectId = extractWorkosVaultObjectId(submittedSecret);
   if (submittedObjectId && /^gh[opu]_/.test(submittedObjectId)) {
     throw new Error("Encrypted storage value looks like a GitHub token. Paste the token in the token field.");
   }
-  const existingObjectId = extractObjectId(
+  const existingObjectId = extractWorkosVaultObjectId(
-    asRecord(existingConnection?.secretJson ?? existingBinding?.secretJson),
+    toRecordValue(existingConnection?.secretJson ?? existingBinding?.secretJson),
   );
   let finalObjectId = submittedObjectId;
   if (!finalObjectId && Object.keys(submittedSecret).length > 0) {
-    finalObjectId = await upsertVaultObject({
+    const upsertResult = await upsertVaultObject({
       workspaceId: args.workspaceId,
       sourceKey: args.sourceKey,
       scope: args.scope,
       existingObjectId,
       payload: submittedSecret,
     });
+    if (upsertResult.isErr()) {
+      throw upsertResult.error;
+    }
+    finalObjectId = upsertResult.value;
   }
   if (!finalObjectId && existingObjectId) {
   return await ctx.runMutation(internal.database.upsertCredential, {
     id: connectionId,
     workspaceId: args.workspaceId,
+    ownerScopeType,
     sourceKey: args.sourceKey,
     scope: args.scope,
     ...(args.scope === "actor" ? { actorId } : {}),

executor/packages/database/src/database/mappers.ts+59−13

 import type { Doc } from "../../convex/_generated/dataModel.d.ts";
-import { asRecord } from "../lib/object";
+import { z } from "zod";
+import { isRecord } from "../lib/object";
 import { DEFAULT_TASK_TIMEOUT_MS } from "../task/constants";
+const sourceAuthSchema = z.object({
+  type: z.string().optional(),
+  mode: z.enum(["workspace", "actor"]).optional(),
+  header: z.string().optional(),
+});
 function stableStringify(value: unknown): string {
   if (Array.isArray(value)) {
     return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
   }
-  if (value && typeof value === "object") {
+  if (isRecord(value)) {
-    const record = asRecord(value);
+    const record = value;
     const keys = Object.keys(record).sort();
     return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
   }
 }
 export function normalizeSourceAuthFingerprint(value: unknown): string {
-  const auth = asRecord(value);
+  const parsedAuth = sourceAuthSchema.safeParse(value);
-  const type = typeof auth.type === "string" ? auth.type.trim() : "none";
+  const auth = parsedAuth.success ? parsedAuth.data : {};
+  const type = (auth.type ?? "none").trim();
   const mode = auth.mode === "actor" ? "actor" : "workspace";
-  const header = typeof auth.header === "string" ? auth.header.trim().toLowerCase() : "";
+  const header = (auth.header ?? "").trim().toLowerCase();
   return stableStringify({
     type: type || "none",
     mode,
 }
 export function mapTask(doc: Doc<"tasks">) {
+  const metadata = isRecord(doc.metadata) ? doc.metadata : {};
   return {
     id: doc.taskId,
     code: doc.code,
     runtimeId: doc.runtimeId,
     status: doc.status,
     timeoutMs: typeof doc.timeoutMs === "number" ? doc.timeoutMs : DEFAULT_TASK_TIMEOUT_MS,
-    metadata: asRecord(doc.metadata),
+    metadata,
     workspaceId: doc.workspaceId,
     actorId: doc.actorId,
     clientId: doc.clientId,
 }
 export function mapPolicy(doc: Doc<"accessPolicies">) {
+  const legacyDecision = typeof Reflect.get(doc as object, "decision") === "string"
+    ? String(Reflect.get(doc as object, "decision"))
+    : undefined;
+  const resourcePattern = doc.resourcePattern
+    || (typeof Reflect.get(doc as object, "toolPathPattern") === "string"
+      ? String(Reflect.get(doc as object, "toolPathPattern"))
+      : "*");
+  const scopeType = doc.scopeType ?? (doc.workspaceId ? "workspace" : "organization");
+  const targetActorId = doc.targetActorId
+    ?? (typeof Reflect.get(doc as object, "actorId") === "string"
+      ? String(Reflect.get(doc as object, "actorId"))
+      : undefined);
+  const effect = doc.effect ?? (legacyDecision === "deny" ? "deny" : "allow");
+  const approvalMode = doc.approvalMode
+    ?? (legacyDecision === "require_approval" ? "required" : legacyDecision === "allow" ? "auto" : "inherit");
+  const decision = effect === "deny"
+    ? "deny"
+    : approvalMode === "required"
+      ? "require_approval"
+      : "allow";
   return {
     id: doc.policyId,
+    scopeType,
+    organizationId: doc.organizationId,
     workspaceId: doc.workspaceId,
-    actorId: doc.actorId,
+    targetActorId,
     clientId: doc.clientId,
-    toolPathPattern: doc.toolPathPattern,
+    resourceType: doc.resourceType ?? "tool_path",
-    decision: doc.decision,
+    resourcePattern,
+    matchType: doc.matchType ?? "glob",
+    effect,
+    approvalMode,
     priority: doc.priority,
     createdAt: doc.createdAt,
     updatedAt: doc.updatedAt,
+    // Legacy aliases retained during transition.
+    actorId: targetActorId,
+    toolPathPattern: resourcePattern,
+    decision,
   };
 }
 export function mapCredential(doc: Doc<"sourceCredentials">) {
+  const secretJson = isRecord(doc.secretJson) ? doc.secretJson : {};
+  const overridesJson = isRecord(doc.overridesJson) ? doc.overridesJson : {};
   return {
     id: doc.credentialId,
     bindingId: doc.bindingId,
+    ownerScopeType: doc.ownerScopeType ?? (doc.workspaceId ? "workspace" : "organization"),
+    organizationId: doc.organizationId,
     workspaceId: doc.workspaceId,
     sourceKey: doc.sourceKey,
     scope: doc.scope,
     actorId: doc.actorId || undefined,
     provider: doc.provider,
-    secretJson: asRecord(doc.secretJson),
+    secretJson,
-    overridesJson: asRecord(doc.overridesJson),
+    overridesJson,
     boundAuthFingerprint: doc.boundAuthFingerprint,
     createdAt: doc.createdAt,
     updatedAt: doc.updatedAt,
 }
 export function mapSource(doc: Doc<"toolSources">) {
+  const config = isRecord(doc.config) ? doc.config : {};
   return {
     id: doc.sourceId,
+    ownerScopeType: doc.ownerScopeType ?? (doc.workspaceId ? "workspace" : "organization"),
+    organizationId: doc.organizationId,
     workspaceId: doc.workspaceId,
     name: doc.name,
     type: doc.type,
-    config: asRecord(doc.config),
+    config,
     specHash: doc.specHash,
     authFingerprint: doc.authFingerprint,
     enabled: Boolean(doc.enabled),

executor/packages/database/src/database/readers.ts+18−3

@@ -1,7 +1,11 @@
1	import type { Doc } from "../../convex/_generated/dataModel.d.ts";	1	import type { Doc } from "../../convex/_generated/dataModel.d.ts";
2	import type { QueryCtx } from "../../convex/_generated/server";	2	import type { QueryCtx } from "../../convex/_generated/server";
		3	import { z } from "zod";
3	import { normalizeSourceAuthFingerprint } from "./mappers";	4	import { normalizeSourceAuthFingerprint } from "./mappers";
4	import { asRecord } from "../lib/object";	5
		6	const toolSourceConfigSchema = z.object({
		7	auth: z.unknown().optional(),
		8	});
5		9
6	export function mapAnonymousContext(doc: Doc<"anonymousSessions">) {	10	export function mapAnonymousContext(doc: Doc<"anonymousSessions">) {
7	return {	11	return {
@@ -69,9 +73,20 @@ export async function computeBoundAuthFingerprint( · 61 unmodified lines
69	.withIndex("by_source_id", (q) => q.eq("sourceId", sourceId))	73	.withIndex("by_source_id", (q) => q.eq("sourceId", sourceId))
70	.unique();	74	.unique();
71		75
72	if (!source \|\| source.workspaceId !== workspaceId) {	76	const workspace = await ctx.db.get(workspaceId);
		77	if (!source \|\| !workspace) {
		78	return normalizeSourceAuthFingerprint({ type: "none" });
		79	}
		80
		81	if (source.organizationId && source.organizationId !== workspace.organizationId) {
		82	return normalizeSourceAuthFingerprint({ type: "none" });
		83	}
		84
		85	const workspaceOwned = source.ownerScopeType === "workspace" \|\| (!source.ownerScopeType && Boolean(source.workspaceId));
		86	if (workspaceOwned && source.workspaceId !== workspaceId) {
73	return normalizeSourceAuthFingerprint({ type: "none" });	87	return normalizeSourceAuthFingerprint({ type: "none" });
74	}	88	}
75		89
76	return normalizeSourceAuthFingerprint(asRecord(source.config).auth);	90	const parsedConfig = toolSourceConfigSchema.safeParse(source.config);
		91	return normalizeSourceAuthFingerprint(parsedConfig.success ? parsedConfig.data.auth : undefined);
77	}	92	}

executor/packages/database/src/database/tool_source_config.ts+20−14

@@ -7,7 +7,6 @@ import type { · 6 unmodified lines
7	OpenApiToolSourceConfig,	7	OpenApiToolSourceConfig,
8	} from "../../../core/src/tool/source-types";	8	} from "../../../core/src/tool/source-types";
9	import type { ToolApprovalMode } from "../../../core/src/types";	9	import type { ToolApprovalMode } from "../../../core/src/types";
10	import { asRecord } from "../lib/object";
11		10
12	export type ToolSourceType = "mcp" \| "openapi" \| "graphql";	11	export type ToolSourceType = "mcp" \| "openapi" \| "graphql";
13		12
@@ -39,6 +38,8 @@ const overrideEntrySchema = z.object({ · 25 unmodified lines
39	});	38	});
40	const unknownRecordSchema = z.record(z.unknown());	39	const unknownRecordSchema = z.record(z.unknown());
41	const stringMapSchema = z.record(z.string());	40	const stringMapSchema = z.record(z.string());
		41	const trimmedStringSchema = z.string().transform((value) => value.trim());
		42	const nonEmptyTrimmedStringSchema = trimmedStringSchema.refine((value) => value.length > 0);
42	const basicAuthSchema = z.object({	43	const basicAuthSchema = z.object({
43	mode: authModeSchema.optional(),	44	mode: authModeSchema.optional(),
44	username: z.string().optional(),	45	username: z.string().optional(),
@@ -55,20 +56,24 @@ const apiKeyAuthSchema = z.object({ · 10 unmodified lines
55	});	56	});
56		57
57	function optionalTrimmedString(value: unknown): string \| undefined {	58	function optionalTrimmedString(value: unknown): string \| undefined {
58	if (typeof value !== "string") return undefined;	59	const parsed = trimmedStringSchema.safeParse(value);
59	const trimmed = value.trim();	60	if (!parsed.success \|\| parsed.data.length === 0) {
60	return trimmed.length > 0 ? trimmed : undefined;	61	return undefined;
		62	}
		63
		64	return parsed.data;
61	}	65	}
62		66
63	function requiredTrimmedString(	67	function requiredTrimmedString(
64	value: unknown,	68	value: unknown,
65	fieldName: string,	69	fieldName: string,
66	): Result<string, Error> {	70	): Result<string, Error> {
67	const trimmed = optionalTrimmedString(value);	71	const parsed = nonEmptyTrimmedStringSchema.safeParse(value);
68	if (!trimmed) {	72	if (!parsed.success) {
69	return Result.err(new Error(`Tool source ${fieldName} is required`));	73	return Result.err(new Error(`Tool source ${fieldName} is required`));
70	}	74	}
71	return Result.ok(trimmed);	75
		76	return Result.ok(parsed.data);
72	}	77	}
73		78
74	function normalizeStringMap(	79	function normalizeStringMap(
@@ -151,7 +156,12 @@ function normalizeOverrides( · 76 unmodified lines
151	function normalizeAuth(value: unknown): Result<OpenApiAuth \| undefined, Error> {	156	function normalizeAuth(value: unknown): Result<OpenApiAuth \| undefined, Error> {
152	if (value === undefined) return Result.ok(undefined);	157	if (value === undefined) return Result.ok(undefined);
153		158
154	const auth = asRecord(value);	159	const authRecord = unknownRecordSchema.safeParse(value);
		160	if (!authRecord.success) {
		161	return Result.err(new Error("Tool source auth.type is required when auth is provided"));
		162	}
		163
		164	const auth = authRecord.data;
155	const authType = optionalTrimmedString(auth.type);	165	const authType = optionalTrimmedString(auth.type);
156	if (!authType) {	166	if (!authType) {
157	return Result.err(new Error("Tool source auth.type is required when auth is provided"));	167	return Result.err(new Error("Tool source auth.type is required when auth is provided"));
@@ -217,13 +227,9 @@ function normalizeAuth(value: unknown): Result<OpenApiAuth \| undefined, Error> { · 59 unmodified lines
217	function normalizeSpec(	227	function normalizeSpec(
218	value: unknown,	228	value: unknown,
219	): Result<string \| Record<string, unknown>, Error> {	229	): Result<string \| Record<string, unknown>, Error> {
220	const stringSpec = z.string().safeParse(value);	230	const stringSpec = nonEmptyTrimmedStringSchema.safeParse(value);
221	if (stringSpec.success) {	231	if (stringSpec.success) {
222	const trimmed = stringSpec.data.trim();	232	return Result.ok(stringSpec.data);
223	if (!trimmed) {
224	return Result.err(new Error("Tool source spec is required"));
225	}
226	return Result.ok(trimmed);
227	}	233	}
228		234
229	const specObjectResult = unknownRecordSchema.safeParse(value);	235	const specObjectResult = unknownRecordSchema.safeParse(value);

executor/packages/database/src/database/validators.ts+5−0

 );
 export const policyDecisionValidator = v.union(v.literal("allow"), v.literal("require_approval"), v.literal("deny"));
+export const policyScopeTypeValidator = v.union(v.literal("organization"), v.literal("workspace"));
+export const policyMatchTypeValidator = v.union(v.literal("glob"), v.literal("exact"));
+export const policyEffectValidator = v.union(v.literal("allow"), v.literal("deny"));
+export const policyApprovalModeValidator = v.union(v.literal("inherit"), v.literal("auto"), v.literal("required"));
+export const ownerScopeTypeValidator = v.union(v.literal("organization"), v.literal("workspace"));
 export const credentialScopeValidator = v.union(v.literal("workspace"), v.literal("actor"));

executor/packages/database/src/lib/object.ts+9−10

@@ -1,13 +1,12 @@
1	export function asRecord(value: unknown): Record<string, unknown> {	1	import { z } from "zod";
2	if (value && typeof value === "object" && !Array.isArray(value)) {	2
3	return value as Record<string, unknown>;	3	const recordSchema = z.record(z.unknown());
4	}	4
5	return {};	5	export function isRecord(value: unknown): value is Record<string, unknown> {
		6	return recordSchema.safeParse(value).success;
6	}	7	}
7		8
8	export function asPayload(value: unknown): Record<string, unknown> {	9	export function toRecord(value: unknown): Record<string, unknown> {
9	if (value && typeof value === "object") {	10	const parsed = recordSchema.safeParse(value);
10	return value as Record<string, unknown>;	11	return parsed.success ? parsed.data : {};
11	}
12	return { value };
13	}	12	}

executor/packages/database/src/runtime/policy.ts+51−10

@@ -7,21 +7,55 @@ import type { · 6 unmodified lines
7	ToolDefinition,	7	ToolDefinition,
8	} from "../../../core/src/types";	8	} from "../../../core/src/types";
9		9
10	function matchesToolPath(pattern: string, toolPath: string): boolean {	10	function matchesToolPath(pattern: string, toolPath: string, matchType: "glob" \| "exact" = "glob"): boolean {
		11	if (matchType === "exact") {
		12	return pattern === toolPath;
		13	}
		14
11	const escaped = pattern.replace(/[.+?^${}()\|[\]\\]/g, "\\$&").replace(/\/g, ".");	15	const escaped = pattern.replace(/[.+?^${}()\|[\]\\]/g, "\\$&").replace(/\/g, ".");
12	const regex = new RegExp(`^${escaped}$`);	16	const regex = new RegExp(`^${escaped}$`);
13	return regex.test(toolPath);	17	return regex.test(toolPath);
14	}	18	}
15		19
16	function policySpecificity(policy: AccessPolicyRecord, actorId?: string, clientId?: string): number {	20	function policySpecificity(
		21	policy: AccessPolicyRecord,
		22	context: { workspaceId: string; actorId?: string; clientId?: string },
		23	): number {
		24	const scopeType = policy.scopeType ?? (policy.workspaceId ? "workspace" : "organization");
		25	const targetActorId = policy.targetActorId ?? policy.actorId;
		26	const resourcePattern = policy.resourcePattern ?? policy.toolPathPattern ?? "*";
		27	const matchType = policy.matchType ?? "glob";
		28
17	let score = 0;	29	let score = 0;
18	if (policy.actorId && actorId && policy.actorId === actorId) score += 4;	30	if (scopeType === "workspace" && policy.workspaceId === context.workspaceId) score += 16;
19	if (policy.clientId && clientId && policy.clientId === clientId) score += 2;	31	if (targetActorId && context.actorId && targetActorId === context.actorId) score += 64;
20	score += Math.max(1, policy.toolPathPattern.replace(/\*/g, "").length);	32	if (policy.clientId && context.clientId && policy.clientId === context.clientId) score += 4;
		33	if (matchType === "exact") score += 3;
		34	score += Math.max(1, resourcePattern.replace(/\*/g, "").length);
21	score += policy.priority;	35	score += policy.priority;
22	return score;	36	return score;
23	}	37	}
24		38
		39	function resolvePolicyDecision(policy: AccessPolicyRecord, defaultDecision: PolicyDecision): PolicyDecision {
		40	const effect = policy.effect ?? (policy.decision === "deny" ? "deny" : "allow");
		41	const approvalMode = policy.approvalMode
		42	?? (policy.decision === "require_approval" ? "required" : policy.decision === "allow" ? "auto" : "inherit");
		43
		44	if (effect === "deny") {
		45	return "deny";
		46	}
		47
		48	if (approvalMode === "required") {
		49	return "require_approval";
		50	}
		51
		52	if (approvalMode === "auto") {
		53	return "allow";
		54	}
		55
		56	return defaultDecision;
		57	}
		58
25	export function getDecisionForContext(	59	export function getDecisionForContext(
26	tool: ToolDefinition,	60	tool: ToolDefinition,
27	context: { workspaceId: string; actorId?: string; clientId?: string },	61	context: { workspaceId: string; actorId?: string; clientId?: string },
@@ -34,17 +68,24 @@ export function getDecisionForContext( · 6 unmodified lines
34	const defaultDecision: PolicyDecision = tool.approval === "required" ? "require_approval" : "allow";	68	const defaultDecision: PolicyDecision = tool.approval === "required" ? "require_approval" : "allow";
35	const candidates = policies	69	const candidates = policies
36	.filter((policy) => {	70	.filter((policy) => {
37	if (policy.actorId && policy.actorId !== context.actorId) return false;	71	const scopeType = policy.scopeType ?? (policy.workspaceId ? "workspace" : "organization");
		72	const targetActorId = policy.targetActorId ?? policy.actorId;
		73	const resourcePattern = policy.resourcePattern ?? policy.toolPathPattern;
		74	const matchType = policy.matchType ?? "glob";
		75
		76	if (!resourcePattern) return false;
		77	if (scopeType === "workspace" && policy.workspaceId !== context.workspaceId) return false;
		78	if (targetActorId && targetActorId !== context.actorId) return false;
38	if (policy.clientId && policy.clientId !== context.clientId) return false;	79	if (policy.clientId && policy.clientId !== context.clientId) return false;
39	return matchesToolPath(policy.toolPathPattern, tool.path);	80	return matchesToolPath(resourcePattern, tool.path, matchType);
40	})	81	})
41	.sort(	82	.sort(
42	(a, b) =>	83	(a, b) =>
43	policySpecificity(b, context.actorId, context.clientId)	84	policySpecificity(b, context)
44	- policySpecificity(a, context.actorId, context.clientId),	85	- policySpecificity(a, context),
45	);	86	);
46		87
47	return candidates[0]?.decision ?? defaultDecision;	88	return candidates[0] ? resolvePolicyDecision(candidates[0], defaultDecision) : defaultDecision;
48	}	89	}
49		90
50	export function getToolDecision(	91	export function getToolDecision(

executor/packages/database/src/runtime/tool_call_credentials.ts+43−58

 "use node";
 import { Result } from "better-result";
-import { z } from "zod";
 import type { ActionCtx } from "../../convex/_generated/server";
 import { internal } from "../../convex/_generated/api";
-import { resolveCredentialPayload } from "../../../core/src/credential-providers";
+import { resolveCredentialPayloadResult } from "../../../core/src/credential-providers";
+import {
+  buildCredentialAuthHeaders,
+  readCredentialOverrideHeaders,
+} from "../../../core/src/tool/source-auth";
 import type { ResolvedToolCredential, TaskRecord, ToolCallRecord, ToolCredentialSpec } from "../../../core/src/types";
 import { ToolCallControlError } from "../../../core/src/tool-call-control";
-import { asPayload } from "../lib/object";
-const bearerSecretSchema = z.object({
+export async function resolveCredentialHeadersResult(
-  token: z.coerce.string().optional(),
+  ctx: Pick<ActionCtx, "runQuery">,
-});
-const apiKeySecretSchema = z.object({
-  headerName: z.coerce.string().optional(),
-  value: z.coerce.string().optional(),
-  token: z.coerce.string().optional(),
-});
-const basicSecretSchema = z.object({
-  username: z.coerce.string().optional(),
-  password: z.coerce.string().optional(),
-});
-const credentialOverrideHeadersSchema = z.object({
-  headers: z.record(z.coerce.string()).optional(),
-});
-export async function resolveCredentialHeaders(
-  ctx: ActionCtx,
   spec: ToolCredentialSpec,
   task: TaskRecord,
-): Promise<ResolvedToolCredential | null> {
+): Promise<Result<ResolvedToolCredential | null, Error>> {
   const record = await ctx.runQuery(internal.database.resolveCredential, {
     workspaceId: task.workspaceId,
     sourceKey: spec.sourceKey,
     actorId: task.actorId,
   });
-  const source = record
+  const sourceResult = record
-    ? await resolveCredentialPayload(record)
+    ? await resolveCredentialPayloadResult(record)
-    : spec.staticSecretJson ?? null;
+    : Result.ok(spec.staticSecretJson ?? null);
-  if (!source) {
+  if (sourceResult.isErr()) {
-    return null;
+    return Result.err(
+      new Error(`Failed to resolve credential payload for '${spec.sourceKey}': ${sourceResult.error.message}`),
+    );
   }
-  const sourcePayload = asPayload(source);
-  const headers: Record<string, string> = {};
+  const source = sourceResult.value;
-  if (spec.authType === "bearer") {
+  if (!source) {
-    const parsedSecret = bearerSecretSchema.safeParse(sourcePayload);
+    return Result.ok(null);
-    const token = parsedSecret.success ? (parsedSecret.data.token ?? "").trim() : "";
-    if (token) headers.authorization = `Bearer ${token}`;
-  } else if (spec.authType === "apiKey") {
-    const parsedSecret = apiKeySecretSchema.safeParse(sourcePayload);
-    const headerName = spec.headerName
-      ?? (parsedSecret.success ? (parsedSecret.data.headerName ?? "x-api-key") : "x-api-key");
-    const value = parsedSecret.success
-      ? (parsedSecret.data.value ?? parsedSecret.data.token ?? "").trim()
-      : "";
-    if (value) headers[headerName] = value;
-  } else if (spec.authType === "basic") {
-    const parsedSecret = basicSecretSchema.safeParse(sourcePayload);
-    const username = parsedSecret.success ? (parsedSecret.data.username ?? "") : "";
-    const password = parsedSecret.success ? (parsedSecret.data.password ?? "") : "";
-    if (username || password) {
-      const encoded = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
-      headers.authorization = `Basic ${encoded}`;
-    }
   }
-  const bindingOverrides = credentialOverrideHeadersSchema.safeParse(record?.overridesJson ?? {});
+  const headers = buildCredentialAuthHeaders(
-  const overrideHeaders = bindingOverrides.success ? (bindingOverrides.data.headers ?? {}) : {};
+    {
+      authType: spec.authType,
+      headerName: spec.headerName,
+    },
+    source,
+  );
+  const overrideHeaders = readCredentialOverrideHeaders(record?.overridesJson);
   for (const [key, value] of Object.entries(overrideHeaders)) {
-    if (!key) continue;
     headers[key] = value;
   }
   if (Object.keys(headers).length === 0) {
-    return null;
+    return Result.ok(null);
   }
-  return {
+  return Result.ok({
     sourceKey: spec.sourceKey,
     mode: spec.mode,
     headers,
-  };
+  });
+}
+export async function resolveCredentialHeaders(
+  ctx: Pick<ActionCtx, "runQuery">,
+  spec: ToolCredentialSpec,
+  task: TaskRecord,
+): Promise<ResolvedToolCredential | null> {
+  const result = await resolveCredentialHeadersResult(ctx, spec, task);
+  if (result.isErr()) {
+    throw result.error;
+  }
+  return result.value;
 }
 export function validatePersistedCallRunnable(

executor/packages/database/src/runtime/tool_call_resolution.test.ts+54−0

@@ -0,0 +1,54 @@
	1	import { describe, expect, test } from "bun:test";
	2	import type { TaskRecord, ToolDefinition } from "../../../core/src/types";
	3	import { getGraphqlDecision } from "./tool_call_resolution";
	4
	5	const task: TaskRecord = {
	6	id: "task_1",
	7	code: "",
	8	runtimeId: "runtime_1",
	9	status: "running",
	10	timeoutMs: 30_000,
	11	metadata: {},
	12	workspaceId: "workspace_1" as TaskRecord["workspaceId"],
	13	actorId: "actor_1",
	14	clientId: "client_1",
	15	createdAt: 1,
	16	updatedAt: 1,
	17	};
	18
	19	const graphqlTool: ToolDefinition = {
	20	path: "linear.graphql",
	21	source: "graphql:linear",
	22	approval: "auto",
	23	description: "Raw GraphQL tool",
	24	_graphqlSource: "linear",
	25	run: async () => ({ data: null, errors: [] }),
	26	};
	27
	28	describe("getGraphqlDecision", () => {
	29	test("supports raw string GraphQL query input", () => {
	30	const decision = getGraphqlDecision(
	31	task,
	32	graphqlTool,
	33	"query { teams { nodes { id } } }",
	34	undefined,
	35	[],
	36	);
	37
	38	expect(decision.decision).toBe("allow");
	39	expect(decision.effectivePaths).toEqual(["linear.query.teams"]);
	40	});
	41
	42	test("derives require_approval for raw string mutation input", () => {
	43	const decision = getGraphqlDecision(
	44	task,
	45	graphqlTool,
	46	"mutation { issueBatchCreate(input: { issues: [] }) { success } }",
	47	undefined,
	48	[],
	49	);
	50
	51	expect(decision.decision).toBe("require_approval");
	52	expect(decision.effectivePaths).toEqual(["linear.mutation.issuebatchcreate"]);
	53	});
	54	});

executor/packages/database/src/runtime/tool_call_resolution.ts+43−14

 import { parseGraphqlOperationPaths } from "../../../core/src/graphql/operation-paths";
 import type { AccessPolicyRecord, PolicyDecision, TaskRecord, ToolDefinition } from "../../../core/src/types";
 import { parseSerializedTool, rehydrateTools } from "../../../core/src/tool/source-serialization";
-import { asPayload } from "../lib/object";
 import { getDecisionForContext, getToolDecision } from "./policy";
-import { getReadyRegistryBuildId } from "./tool_registry_state";
+import { getReadyRegistryBuildIdResult } from "./tool_registry_state";
 import { normalizeToolPathForLookup, toPreferredToolPath } from "./tool_paths";
 import { baseTools } from "./workspace_tools";
   serializedToolJson: z.string(),
 });
+const graphqlDecisionInputSchema = z.union([
+  z.string(),
+  z.object({ query: z.string().optional() }).catchall(z.unknown()),
+]);
+function getGraphqlQueryFromInput(input: unknown): string {
+  const parsedInput = graphqlDecisionInputSchema.safeParse(input);
+  if (!parsedInput.success) {
+    return "";
+  }
+  if (typeof parsedInput.data === "string") {
+    return parsedInput.data;
+  }
+  return parsedInput.data.query ?? "";
+}
 async function searchRegistryEntries(
   ctx: ActionCtx,
   args: { workspaceId: TaskRecord["workspaceId"]; buildId: string; query: string; limit: number },
   workspaceTools: Map<string, ToolDefinition> | undefined,
   policies: AccessPolicyRecord[],
 ): { decision: PolicyDecision; effectivePaths: string[] } {
-  const sourceName = tool._graphqlSource!;
+  const sourceName = tool._graphqlSource;
-  const payload = asPayload(input);
+  if (!sourceName) {
-  const queryString = typeof payload.query === "string" ? payload.query : "";
+    return { decision: getToolDecision(task, tool, policies), effectivePaths: [tool.path] };
+  }
+  const queryString = getGraphqlQueryFromInput(input);
   if (!queryString.trim()) {
     return { decision: getToolDecision(task, tool, policies), effectivePaths: [tool.path] };
     return Result.ok({ tool: builtin, resolvedToolPath: toolPath });
   }
-  const buildId = await getReadyRegistryBuildId(ctx, {
+  const buildIdResult = await getReadyRegistryBuildIdResult(ctx, {
     workspaceId: task.workspaceId,
     actorId: task.actorId,
     clientId: task.clientId,
     refreshOnStale: true,
   });
+  if (buildIdResult.isErr()) {
+    return Result.err(buildIdResult.error);
+  }
+  const buildId = buildIdResult.value;
   let resolvedToolPath = toolPath;
   let entry = await getRegistryToolByPath(ctx, {
     if (hits.length > 0) {
       // Prefer exact match on preferred path formatting, otherwise shortest canonical path.
       const exact = hits.find((hit) => toPreferredToolPath(hit.path) === toPreferredToolPath(toolPath));
-      entry = exact ?? hits.sort((a, b) => a.path.length - b.path.length || a.path.localeCompare(b.path))[0]!;
+      const shortest = [...hits]
-      resolvedToolPath = entry.path;
+        .sort((a, b) => a.path.length - b.path.length || a.path.localeCompare(b.path))[0];
+      entry = exact ?? shortest ?? null;
+      if (entry) {
+        resolvedToolPath = entry.path;
+      }
     }
   }
     return Result.err(new Error(unknownToolErrorMessage(toolPath, suggestions)));
   }
-  const serializedResult = Result.try(() => {
+  let parsedSerialized: unknown;
-    return JSON.parse(entry.serializedToolJson);
+  try {
-  });
+    parsedSerialized = JSON.parse(entry.serializedToolJson);
-  if (serializedResult.isErr()) {
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     return Result.err(
-      new Error(`Failed to parse tool registry entry '${resolvedToolPath}': ${serializedResult.error.message}`),
+      new Error(`Failed to parse tool registry entry '${resolvedToolPath}': ${message}`),
     );
   }
-  const serialized = parseSerializedTool(serializedResult.value);
+  const serialized = parseSerializedTool(parsedSerialized);
   if (serialized.isErr()) {
     return Result.err(
       new Error(`Failed to parse tool registry entry '${resolvedToolPath}': ${serialized.error.message}`),

executor/packages/database/src/runtime/tool_invocation.ts+27−21

   decodeToolCallControlSignal,
   ToolCallControlError,
 } from "../../../core/src/tool-call-control";
-import { asPayload } from "../lib/object";
 import { getToolDecision, getDecisionForContext } from "./policy";
 import { baseTools } from "./workspace_tools";
 import { publishTaskEvent } from "./events";
 import { completeToolCall, denyToolCall, failToolCall } from "./tool_call_lifecycle";
-import { resolveCredentialHeaders, validatePersistedCallRunnable } from "./tool_call_credentials";
+import { resolveCredentialHeadersResult, validatePersistedCallRunnable } from "./tool_call_credentials";
 import { getGraphqlDecision, resolveToolForCall } from "./tool_call_resolution";
-import { getReadyRegistryBuildId } from "./tool_registry_state";
+import { getReadyRegistryBuildIdResult } from "./tool_registry_state";
+const payloadRecordSchema = z.record(z.unknown());
 function createApprovalId(): string {
   return `approval_${crypto.randomUUID()}`;
   displayOutput?: string;
 };
-const accessPolicyRecordSchema = z.object({
-  id: z.string(),
-  workspaceId: z.custom<TaskRecord["workspaceId"]>(),
-  actorId: z.string().optional(),
-  clientId: z.string().optional(),
-  toolPathPattern: z.string(),
-  decision: z.enum(["allow", "require_approval", "deny"]),
-  priority: z.number(),
-  createdAt: z.number(),
-  updatedAt: z.number(),
-});
 const registryNamespaceSchema = z.object({
   namespace: z.string(),
   toolCount: z.number(),
   compact: z.boolean().optional(),
 });
+function toInputPayload(value: unknown): Record<string, unknown> {
+  const parsed = payloadRecordSchema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  return value === undefined ? {} : { value };
+}
 async function upsertRequestedToolCall(
   ctx: ActionCtx,
   args: { taskId: string; callId: string; workspaceId: TaskRecord["workspaceId"]; toolPath: string },
   workspaceId: TaskRecord["workspaceId"],
 ): Promise<AccessPolicyRecord[]> {
   const policies = await ctx.runQuery(internal.database.listAccessPolicies, { workspaceId });
-  const parsed = z.array(accessPolicyRecordSchema).safeParse(policies);
+  return policies as AccessPolicyRecord[];
-  return parsed.success ? parsed.data : [];
 }
 async function listRegistryNamespaces(
     // Fast system tools are handled server-side from the registry.
     if (toolPath === "discover" || toolPath === "catalog.namespaces" || toolPath === "catalog.tools") {
-      const buildId = await getReadyRegistryBuildId(ctx, {
+      const buildIdResult = await getReadyRegistryBuildIdResult(ctx, {
         workspaceId: task.workspaceId,
         actorId: task.actorId,
         clientId: task.clientId,
         refreshOnStale: true,
       });
+      if (buildIdResult.isErr()) {
+        throw buildIdResult.error;
+      }
+      const buildId = buildIdResult.value;
       const payload = typeof input === "string"
         ? { query: input }
-        : asPayload(input);
+        : toInputPayload(input);
       const isAllowed = (path: string, approval: ToolDefinition["approval"]) => {
         const policyProbeTool: ToolDefinition = {
           path,
     let credential: ResolvedToolCredential | undefined;
     if (tool.credential) {
-      const resolved = await resolveCredentialHeaders(ctx, tool.credential, task);
+      const credentialResult = await resolveCredentialHeadersResult(ctx, tool.credential, task);
+      if (credentialResult.isErr()) {
+        throw credentialResult.error;
+      }
+      const resolved = credentialResult.value;
       if (!resolved) {
         throw new Error(`Missing credential for source '${tool.credential.sourceKey}' (${tool.credential.mode} scope)`);
       }
           taskId: task.id,
           callId,
           toolPath: approval.toolPath,
-          input: asPayload(approval.input),
+          input: toInputPayload(approval.input),
           createdAt: approval.createdAt,
         });
       }

executor/packages/database/src/runtime/tool_registry_state.ts+48−27

 "use node";
+import { Result } from "better-result";
 import { z } from "zod";
 import type { ActionCtx } from "../../convex/_generated/server";
 import type { Id } from "../../convex/_generated/dataModel.d.ts";
   readyBuildId?: string;
 } | null;
-type ToolSourceState = {
-  id: string;
-  updatedAt: number;
-  enabled: boolean;
-};
 const registryStateSchema = z.object({
   signature: z.string(),
   readyBuildId: z.string().optional(),
 const toolSourceStateSchema = z.object({
   id: z.string(),
+  type: z.string().optional(),
+  ownerScopeType: z.string().optional(),
+  organizationId: z.string().optional(),
+  workspaceId: z.string().optional(),
+  specHash: z.string().optional(),
+  authFingerprint: z.string().optional(),
   updatedAt: z.number(),
   enabled: z.boolean().optional(),
-});
+}).transform((source) => ({
+  id: source.id,
+  type: source.type,
+  ownerScopeType: source.ownerScopeType,
+  organizationId: source.organizationId,
+  workspaceId: source.workspaceId,
+  specHash: source.specHash,
+  authFingerprint: source.authFingerprint,
+  updatedAt: source.updatedAt,
+  enabled: source.enabled !== false,
+}));
+type ToolSourceState = z.infer<typeof toolSourceStateSchema>;
+const toolSourceStateListSchema = z.array(toolSourceStateSchema);
 function toRegistryState(value: unknown): RegistryState {
   const parsed = registryStateSchema.safeParse(value);
 }
 function toToolSourceStateList(value: unknown): ToolSourceState[] {
-  if (!Array.isArray(value)) {
+  const parsed = toolSourceStateListSchema.safeParse(value);
+  if (!parsed.success) {
     return [];
   }
-  const normalized: ToolSourceState[] = [];
+  return parsed.data;
-  for (const entry of value) {
-    const parsed = toolSourceStateSchema.safeParse(entry);
-    if (!parsed.success) continue;
-    normalized.push({
-      id: parsed.data.id,
-      updatedAt: parsed.data.updatedAt,
-      enabled: parsed.data.enabled !== false,
-    });
-  }
-  return normalized;
 }
 async function readRegistryState(
   };
 }
-export async function getReadyRegistryBuildId(
+export async function getReadyRegistryBuildIdResult(
   ctx: Pick<ActionCtx, "runQuery" | "runAction">,
   args: {
     workspaceId: Id<"workspaces">;
     clientId?: string;
     refreshOnStale?: boolean;
   },
-): Promise<string> {
+): Promise<Result<string, Error>> {
   const initial = await readRegistryState(ctx, args.workspaceId);
   if (initial.isReady && initial.buildId) {
-    return initial.buildId;
+    return Result.ok(initial.buildId);
   }
   if (args.refreshOnStale) {
     const refreshed = await readRegistryState(ctx, args.workspaceId);
     if (refreshed.isReady && refreshed.buildId) {
-      return refreshed.buildId;
+      return Result.ok(refreshed.buildId);
     }
   }
-  throw new Error(
+  return Result.err(
-    "Tool registry is not ready (or is stale). Open Tools to refresh, or call listToolsWithWarnings to rebuild.",
+    new Error("Tool registry is not ready (or is stale). Open Tools to refresh, or call listToolsWithWarnings to rebuild."),
   );
 }
+export async function getReadyRegistryBuildId(
+  ctx: Pick<ActionCtx, "runQuery" | "runAction">,
+  args: {
+    workspaceId: Id<"workspaces">;
+    actorId?: string;
+    clientId?: string;
+    refreshOnStale?: boolean;
+  },
+): Promise<string> {
+  const buildIdResult = await getReadyRegistryBuildIdResult(ctx, args);
+  if (buildIdResult.isErr()) {
+    throw buildIdResult.error;
+  }
+  return buildIdResult.value;
+}

executor/packages/database/src/runtime/tool_source_loading.ts+89−74

   prepareOpenApiSpec,
   type CompiledToolSourceArtifact,
 } from "../../../core/src/tool-sources";
-import { resolveCredentialPayload } from "../../../core/src/credential-providers";
+import { resolveCredentialPayloadResult } from "../../../core/src/credential-providers";
-import { buildStaticAuthHeaders } from "../../../core/src/tool/source-auth";
+import {
+  buildCredentialAuthHeaders,
+  buildStaticAuthHeaders,
+  readCredentialOverrideHeaders,
+} from "../../../core/src/tool/source-auth";
 import type {
   ExternalToolSourceConfig,
   GraphqlToolSourceConfig,
 /** Cache version - bump when tool snapshot/registry/type-hint semantics change. */
 const TOOL_SOURCE_CACHE_VERSION = "v25";
+const OPENAPI_PREPARED_CACHE_VERSION = "openapi_v1";
 const openApiAuthModeSchema = z.enum(["static", "workspace", "actor"]);
   }),
 ]);
-const bearerSecretSchema = z.object({ token: z.coerce.string().optional() });
-const apiKeySecretSchema = z.object({
-  value: z.coerce.string().optional(),
-  token: z.coerce.string().optional(),
-});
-const basicSecretSchema = z.object({
-  username: z.coerce.string().optional(),
-  password: z.coerce.string().optional(),
-});
-const credentialOverrideHeadersSchema = z.object({
-  headers: z.record(z.coerce.string()).optional(),
-});
 const preparedOpenApiSpecSchema = z.object({
   servers: z.array(z.string()),
   paths: z.record(z.unknown()),
   };
 }
-export function sourceSignature(workspaceId: string, sources: Array<{ id: string; updatedAt: number; enabled: boolean }>): string {
+export function sourceSignature(
+  workspaceId: string,
+  sources: Array<{
+    id: string;
+    type?: string;
+    ownerScopeType?: string;
+    organizationId?: string;
+    workspaceId?: string;
+    specHash?: string;
+    authFingerprint?: string;
+    updatedAt: number;
+    enabled: boolean;
+  }>,
+): string {
   const parts = sources
-    .map((source) => `${source.id}:${source.updatedAt}:${source.enabled ? 1 : 0}`)
+    .map((source) => {
+      const type = source.type ?? "unknown";
+      const ownerScopeType = source.ownerScopeType ?? "workspace";
+      const org = source.organizationId ?? "";
+      const ws = source.workspaceId ?? "";
+      const specHash = source.specHash ?? "";
+      const authFingerprint = source.authFingerprint ?? "";
+      const enabled = source.enabled ? 1 : 0;
+      return `${source.id}:${type}:${ownerScopeType}:${org}:${ws}:${specHash}:${authFingerprint}:${source.updatedAt}:${enabled}`;
+    })
     .sort();
   return `${TOOL_SOURCE_CACHE_VERSION}|${workspaceId}|${parts.join(",")}`;
 }
   return Result.ok(result);
 }
-function buildHeadersFromCredentialSecret(
+function toCredentialHeaderSpec(auth: OpenApiAuth):
-  auth: OpenApiAuth,
+  | { authType: "bearer" | "apiKey" | "basic"; headerName?: string }
-  secret: Record<string, unknown>,
+  | null {
-): Record<string, string> {
+  if (auth.type === "none") {
-  if (auth.type === "bearer") {
+    return null;
-    const parsedSecret = bearerSecretSchema.safeParse(secret);
-    const token = parsedSecret.success ? (parsedSecret.data.token ?? "").trim() : "";
-    return token ? { authorization: `Bearer ${token}` } : {};
   }
   if (auth.type === "apiKey") {
-    const parsedSecret = apiKeySecretSchema.safeParse(secret);
+    return {
-    const value = parsedSecret.success
+      authType: "apiKey",
-      ? (parsedSecret.data.value ?? parsedSecret.data.token ?? "").trim()
+      headerName: auth.header,
-      : "";
+    };
-    return value ? { [auth.header]: value } : {};
-  }
-  if (auth.type === "basic") {
-    const parsedSecret = basicSecretSchema.safeParse(secret);
-    const username = parsedSecret.success ? (parsedSecret.data.username ?? "") : "";
-    const password = parsedSecret.success ? (parsedSecret.data.password ?? "") : "";
-    if (!username && !password) {
-      return {};
-    }
-    const encoded = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
-    return { authorization: `Basic ${encoded}` };
   }
-  return {};
+  return {
+    authType: auth.type,
+  };
 }
 async function resolveMcpDiscoveryHeaders(
     };
   }
-  try {
+  const secretResult = await resolveCredentialPayloadResult(record);
-    const secret = await resolveCredentialPayload(record);
+  if (secretResult.isErr()) {
-    if (!secret) {
+    return {
-      return {
+      headers: {},
-        headers: {},
+      warnings: [`Source '${source.name}': failed to resolve MCP credential for discovery: ${secretResult.error.message}`],
-        warnings: [`Source '${source.name}': credential payload unavailable for MCP discovery`],
+    };
-      };
+  }
-    }
-    const headers = buildHeadersFromCredentialSecret(auth, secret);
+  const secret = secretResult.value;
-    const parsedOverrides = credentialOverrideHeadersSchema.safeParse(record.overridesJson ?? {});
+  if (!secret) {
-    const overrideHeaders = parsedOverrides.success ? (parsedOverrides.data.headers ?? {}) : {};
+    return {
-    for (const [key, value] of Object.entries(overrideHeaders)) {
+      headers: {},
-      if (!key) continue;
+      warnings: [`Source '${source.name}': credential payload unavailable for MCP discovery`],
-      headers[key] = value;
+    };
-    }
+  }
-    if (Object.keys(headers).length === 0) {
+  const authSpec = toCredentialHeaderSpec(auth);
-      return {
+  if (!authSpec) {
-        headers: {},
+    return { headers: {}, warnings: [] };
-        warnings: [`Source '${source.name}': credential did not produce MCP auth headers for discovery`],
+  }
-      };
-    }
-    return { headers, warnings: [] };
+  const headers = buildCredentialAuthHeaders(authSpec, secret);
-  } catch (error) {
+  const overrideHeaders = readCredentialOverrideHeaders(record.overridesJson);
-    const message = error instanceof Error ? error.message : String(error);
+  for (const [key, value] of Object.entries(overrideHeaders)) {
+    headers[key] = value;
+  }
+  if (Object.keys(headers).length === 0) {
     return {
       headers: {},
-      warnings: [`Source '${source.name}': failed to resolve MCP credential for discovery: ${message}`],
+      warnings: [`Source '${source.name}': credential did not produce MCP auth headers for discovery`],
     };
   }
+  return { headers, warnings: [] };
 }
 async function loadCachedOpenApiSpec(
   try {
     const entry = await ctx.runQuery(internal.openApiSpecCache.getEntry, {
       specUrl,
-      version: TOOL_SOURCE_CACHE_VERSION,
+      version: OPENAPI_PREPARED_CACHE_VERSION,
       maxAgeMs: OPENAPI_SPEC_CACHE_TTL_MS,
     });
       const blob = await ctx.storage.get(entry.storageId);
       if (blob) {
         const json = await blob.text();
-        const parsedResult = Result.try(() => JSON.parse(json));
+        let parsedJson: unknown;
-        if (parsedResult.isOk()) {
+        try {
-          const prepared = toPreparedOpenApiSpec(parsedResult.value);
+          parsedJson = JSON.parse(json);
+        } catch {
+          parsedJson = undefined;
+        }
+        if (parsedJson !== undefined) {
+          const prepared = toPreparedOpenApiSpec(parsedJson);
           if (prepared && (!includeDts || getDtsStatus(prepared) !== "skipped")) {
             return prepared;
           }
     const storageId = await ctx.storage.store(blob);
     await ctx.runMutation(internal.openApiSpecCache.putEntry, {
       specUrl,
-      version: TOOL_SOURCE_CACHE_VERSION,
+      version: OPENAPI_PREPARED_CACHE_VERSION,
       storageId,
       sizeBytes: json.length,
     });
   ctx: ActionCtx,
   source: ExternalToolSourceConfig,
   options: { includeDts?: boolean; workspaceId: Id<"workspaces">; actorId?: string },
-): Promise<{ artifact?: CompiledToolSourceArtifact; warnings: string[]; openApiDts?: string }> {
+): Promise<{ artifact?: CompiledToolSourceArtifact; warnings: string[]; openApiDts?: string; openApiSourceKey?: string }> {
   const includeDts = options.includeDts ?? true;
   if (source.type === "openapi" && typeof source.spec === "string") {
       const warnings = (prepared.warnings ?? []).map(
         (warning) => `Source '${source.name}': ${warning}`,
       );
-      return { artifact, warnings, openApiDts: prepared.dts };
+      return {
+        artifact,
+        warnings,
+        openApiDts: prepared.dts,
+        openApiSourceKey: source.sourceKey ?? `openapi:${source.name}`,
+      };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {

executor/packages/database/src/runtime/workspace_tools.ts+65−31

@@ -30,7 +30,6 @@ import { computeOpenApiSourceQuality, listVisibleToolDescriptors } from "./tool_ · 29 unmodified lines
30	import { loadSourceArtifact, normalizeExternalToolSource, sourceSignature } from "./tool_source_loading";	30	import { loadSourceArtifact, normalizeExternalToolSource, sourceSignature } from "./tool_source_loading";
31	import { registrySignatureForWorkspace } from "./tool_registry_state";	31	import { registrySignatureForWorkspace } from "./tool_registry_state";
32	import { normalizeToolPathForLookup } from "./tool_paths";	32	import { normalizeToolPathForLookup } from "./tool_paths";
33	import { asPayload } from "../lib/object";
34		33
35	const baseTools = new Map<string, ToolDefinition>();	34	const baseTools = new Map<string, ToolDefinition>();
36		35
@@ -39,6 +38,33 @@ const adminAnnouncementInputSchema = z.object({ · 2 unmodified lines
39	message: z.string().optional(),	38	message: z.string().optional(),
40	});	39	});
41		40
		41	const actorScopedMcpAuthSchema = z.object({
		42	mode: z.literal("actor"),
		43	});
		44
		45	const toolHintSchema = z.object({
		46	inputHint: z.string().optional(),
		47	outputHint: z.string().optional(),
		48	requiredInputKeys: z.array(z.string()).optional(),
		49	previewInputKeys: z.array(z.string()).optional(),
		50	});
		51
		52	const payloadRecordSchema = z.record(z.unknown());
		53
		54	function toInputPayload(value: unknown): Record<string, unknown> {
		55	const parsed = payloadRecordSchema.safeParse(value);
		56	if (parsed.success) {
		57	return parsed.data;
		58	}
		59
		60	return value === undefined ? {} : { value };
		61	}
		62
		63	function toJsonSchema(value: unknown): JsonSchema {
		64	const parsed = payloadRecordSchema.safeParse(value);
		65	return parsed.success ? parsed.data : {};
		66	}
		67
42	async function listWorkspaceToolSources(	68	async function listWorkspaceToolSources(
43	ctx: ActionCtx,	69	ctx: ActionCtx,
44	workspaceId: Id<"workspaces">,	70	workspaceId: Id<"workspaces">,
@@ -56,17 +82,23 @@ async function listWorkspaceAccessPolicies( · 11 unmodified lines
56	}	82	}
57		83
58	async function parseWorkspaceToolSnapshotFromBlob(blob: Blob): Promise<Result<WorkspaceToolSnapshot, Error>> {	84	async function parseWorkspaceToolSnapshotFromBlob(blob: Blob): Promise<Result<WorkspaceToolSnapshot, Error>> {
59	const textResult = await Result.tryPromise(async () => await blob.text());	85	let text: string;
60	if (textResult.isErr()) {	86	try {
61	return Result.err(new Error(`Failed to read cache blob: ${textResult.error.message}`));	87	text = await blob.text();
		88	} catch (error) {
		89	const message = error instanceof Error ? error.message : String(error);
		90	return Result.err(new Error(`Failed to read cache blob: ${message}`));
62	}	91	}
63		92
64	const jsonResult = Result.try(() => JSON.parse(textResult.value));	93	let parsedJson: unknown;
65	if (jsonResult.isErr()) {	94	try {
66	return Result.err(new Error(`Failed to parse cache JSON: ${jsonResult.error.message}`));	95	parsedJson = JSON.parse(text);
		96	} catch (error) {
		97	const message = error instanceof Error ? error.message : String(error);
		98	return Result.err(new Error(`Failed to parse cache JSON: ${message}`));
67	}	99	}
68		100
69	return parseWorkspaceToolSnapshot(jsonResult.value);	101	return parseWorkspaceToolSnapshot(parsedJson);
70	}	102	}
71		103
72	// Minimal built-in tools used by tests/demos.	104	// Minimal built-in tools used by tests/demos.
@@ -98,7 +130,7 @@ baseTools.set("admin.send_announcement", { · 25 unmodified lines
98	},	130	},
99	},	131	},
100	run: async (input: unknown) => {	132	run: async (input: unknown) => {
101	const parsedInput = adminAnnouncementInputSchema.safeParse(asPayload(input));	133	const parsedInput = adminAnnouncementInputSchema.safeParse(toInputPayload(input));
102	const channel = parsedInput.success ? (parsedInput.data.channel ?? "") : "";	134	const channel = parsedInput.success ? (parsedInput.data.channel ?? "") : "";
103	const message = parsedInput.success ? (parsedInput.data.message ?? "") : "";	135	const message = parsedInput.success ? (parsedInput.data.message ?? "") : "";
104	return { ok: true, channel, message };	136	return { ok: true, channel, message };
@@ -401,13 +433,6 @@ function normalizeHint(type?: string): string { · 296 unmodified lines
401	return type && type.trim().length > 0 ? type : "unknown";	433	return type && type.trim().length > 0 ? type : "unknown";
402	}	434	}
403		435
404	function asJsonSchema(value: unknown): JsonSchema {
405	if (!value \|\| typeof value !== "object" \|\| Array.isArray(value)) {
406	return {};
407	}
408	return asPayload(value);
409	}
410
411	async function buildWorkspaceToolRegistry(	436	async function buildWorkspaceToolRegistry(
412	ctx: ActionCtx,	437	ctx: ActionCtx,
413	args: {	438	args: {
@@ -433,24 +458,24 @@ async function buildWorkspaceToolRegistry( · 19 unmodified lines
433	const normalizedPath = normalizeToolPathForLookup(st.path);	458	const normalizedPath = normalizeToolPathForLookup(st.path);
434	const searchText = `${st.path} ${preferredPath} ${aliases.join(" ")} ${st.description} ${st.source ?? ""}`.toLowerCase();	459	const searchText = `${st.path} ${preferredPath} ${aliases.join(" ")} ${st.description} ${st.source ?? ""}`.toLowerCase();
435		460
436	const inputSchema = asJsonSchema(st.typing?.inputSchema);	461	const inputSchema = toJsonSchema(st.typing?.inputSchema);
437	const outputSchema = asJsonSchema(st.typing?.outputSchema);	462	const outputSchema = toJsonSchema(st.typing?.outputSchema);
		463	const parsedTyping = toolHintSchema.safeParse(st.typing);
		464	const typing = parsedTyping.success ? parsedTyping.data : {};
438		465
439	const requiredInputKeys = Array.isArray(st.typing?.requiredInputKeys)	466	const requiredInputKeys = typing.requiredInputKeys ?? extractTopLevelRequiredKeys(inputSchema);
440	? st.typing!.requiredInputKeys!.filter((v): v is string => typeof v === "string")	467	const previewInputKeys = typing.previewInputKeys ?? buildPreviewKeys(inputSchema);
441	: extractTopLevelRequiredKeys(inputSchema);	468	const inputHint = typing.inputHint?.trim();
442	const previewInputKeys = Array.isArray(st.typing?.previewInputKeys)	469	const outputHint = typing.outputHint?.trim();
443	? st.typing!.previewInputKeys!.filter((v): v is string => typeof v === "string")
444	: buildPreviewKeys(inputSchema);
445		470
446	const displayInput = typeof st.typing?.inputHint === "string" && st.typing.inputHint.trim().length > 0	471	const displayInput = inputHint && inputHint.length > 0
447	? st.typing.inputHint.trim()	472	? inputHint
448	: (Object.keys(inputSchema).length === 0	473	: (Object.keys(inputSchema).length === 0
449	? "{}"	474	? "{}"
450	: normalizeHint(jsonSchemaTypeHintFallback(inputSchema)));	475	: normalizeHint(jsonSchemaTypeHintFallback(inputSchema)));
451		476
452	const displayOutput = typeof st.typing?.outputHint === "string" && st.typing.outputHint.trim().length > 0	477	const displayOutput = outputHint && outputHint.length > 0
453	? st.typing.outputHint.trim()	478	? outputHint
454	: (Object.keys(outputSchema).length === 0	479	: (Object.keys(outputSchema).length === 0
455	? "unknown"	480	? "unknown"
456	: normalizeHint(jsonSchemaTypeHintFallback(outputSchema)));	481	: normalizeHint(jsonSchemaTypeHintFallback(outputSchema)));
@@ -525,6 +550,11 @@ async function buildWorkspaceToolRegistry( · 68 unmodified lines
525	buildId,	550	buildId,
526	});	551	});
527		552
		553	await ctx.runMutation(internal.toolRegistry.pruneBuilds, {
		554	workspaceId: args.workspaceId,
		555	maxRetainedBuilds: 2,
		556	});
		557
528	return { buildId };	558	return { buildId };
529	}	559	}
530		560
@@ -553,8 +583,9 @@ export async function getWorkspaceTools( · 22 unmodified lines
553	if (source.type !== "mcp") {	583	if (source.type !== "mcp") {
554	return false;	584	return false;
555	}	585	}
556	const auth = asPayload(source.config.auth);	586
557	return auth?.mode === "actor";	587	const auth = actorScopedMcpAuthSchema.safeParse(source.config.auth);
		588	return auth.success;
558	});	589	});
559	const skipCacheRead = (options.skipCacheRead ?? false) \|\| hasActorScopedMcpSource;	590	const skipCacheRead = (options.skipCacheRead ?? false) \|\| hasActorScopedMcpSource;
560	const skipCacheWrite = hasActorScopedMcpSource;	591	const skipCacheWrite = hasActorScopedMcpSource;
@@ -670,6 +701,7 @@ export async function getWorkspaceTools( · 109 unmodified lines
670	timedOut: boolean;	701	timedOut: boolean;
671	sourceName: string;	702	sourceName: string;
672	openApiDts?: string;	703	openApiDts?: string;
		704	openApiSourceKey?: string;
673	}>((resolve) => {	705	}>((resolve) => {
674	timer = setTimeout(() => {	706	timer = setTimeout(() => {
675	resolve({	707	resolve({
@@ -678,6 +710,7 @@ export async function getWorkspaceTools( · 2 unmodified lines
678	timedOut: true,	710	timedOut: true,
679	sourceName: config.name,	711	sourceName: config.name,
680	openApiDts: undefined,	712	openApiDts: undefined,
		713	openApiSourceKey: config.type === "openapi" ? (config.sourceKey ?? `openapi:${config.name}`) : undefined,
681	});	714	});
682	}, sourceTimeoutMs);	715	}, sourceTimeoutMs);
683	});	716	});
@@ -739,7 +772,8 @@ export async function getWorkspaceTools( · 55 unmodified lines
739	const openApiDtsBySource: Record<string, string> = {};	772	const openApiDtsBySource: Record<string, string> = {};
740	for (const loaded of loadedSources) {	773	for (const loaded of loadedSources) {
741	if (loaded.openApiDts && loaded.openApiDts.trim().length > 0) {	774	if (loaded.openApiDts && loaded.openApiDts.trim().length > 0) {
742	openApiDtsBySource[`openapi:${loaded.sourceName}`] = loaded.openApiDts;	775	const sourceKey = loaded.openApiSourceKey ?? `openapi:${loaded.sourceName}`;
		776	openApiDtsBySource[sourceKey] = loaded.openApiDts;
743	}	777	}
744	}	778	}
745	const typeBundle = buildWorkspaceTypeBundle({	779	const typeBundle = buildWorkspaceTypeBundle({

executor/packages/runner-sandbox-host/src/bridge.ts+42−35

@@ -1,6 +1,7 @@
1	import { Result } from "better-result";	1	import { Result } from "better-result";
2	import { api } from "@executor/database/convex/_generated/api";	2	import { api } from "@executor/database/convex/_generated/api";
3	import { ConvexClient, ConvexHttpClient } from "convex/browser";	3	import { ConvexClient, ConvexHttpClient } from "convex/browser";
		4	import { z } from "zod";
4	import type {	5	import type {
5	BridgeEntrypointContext,	6	BridgeEntrypointContext,
6	BridgeProps,	7	BridgeProps,
@@ -10,33 +11,41 @@ import type { · 3 unmodified lines
10		11
11	const APPROVAL_SUBSCRIPTION_TIMEOUT_MS = 10 * 60 * 1000;	12	const APPROVAL_SUBSCRIPTION_TIMEOUT_MS = 10 * 60 * 1000;
12		13
13	function asObject(value: unknown): Record<string, unknown> {	14	const bridgePropsSchema: z.ZodType<BridgeProps> = z.object({
14	if (value && typeof value === "object" && !Array.isArray(value)) {	15	callbackConvexUrl: z.string(),
15	return value as Record<string, unknown>;	16	callbackInternalSecret: z.string(),
16	}	17	taskId: z.string(),
17	return {};	18	});
18	}	19
19		20	const toolCallResultSchema: z.ZodType<ToolCallResult> = z.union([
20	function isBridgeProps(value: unknown): value is BridgeProps {	21	z.object({ ok: z.literal(true), value: z.unknown().optional() }),
21	const props = asObject(value);	22	z.object({
22	return (	23	ok: z.literal(false),
23	typeof props.callbackConvexUrl === "string"	24	kind: z.literal("pending"),
24	&& typeof props.callbackInternalSecret === "string"	25	approvalId: z.string(),
25	&& typeof props.taskId === "string"	26	error: z.string().optional(),
26	);	27	retryAfterMs: z.number().optional(),
		28	}),
		29	z.object({
		30	ok: z.literal(false),
		31	kind: z.enum(["denied", "failed"]),
		32	error: z.string().optional(),
		33	approvalId: z.string().optional(),
		34	retryAfterMs: z.number().optional(),
		35	}),
		36	]);
		37
		38	const recordSchema = z.record(z.unknown());
		39
		40	function hasToolBridgeExport(
		41	value: Record<string, unknown>,
		42	): value is { ToolBridge: WorkerEntrypointExports["ToolBridge"] } {
		43	return typeof value.ToolBridge === "function";
27	}	44	}
28		45
29	function isToolCallResult(value: unknown): value is ToolCallResult {	46	function asObject(value: unknown): Record<string, unknown> {
30	const record = asObject(value);	47	const parsed = recordSchema.safeParse(value);
31	if (record.ok === true) {	48	return parsed.success ? parsed.data : {};
32	return true;
33	}
34
35	if (record.ok === false) {
36	return record.kind === "pending" \|\| record.kind === "denied" \|\| record.kind === "failed";
37	}
38
39	return false;
40	}	49	}
41		50
42	export function getBridgePropsFromContext(	51	export function getBridgePropsFromContext(
@@ -47,11 +56,12 @@ export function getBridgePropsFromContext( · 4 unmodified lines
47	throw new Error("WorkerEntrypoint context is unavailable");	56	throw new Error("WorkerEntrypoint context is unavailable");
48	}	57	}
49		58
50	if (!isBridgeProps(context.props)) {	59	const parsedProps = bridgePropsSchema.safeParse(context.props);
		60	if (!parsedProps.success) {
51	throw new Error("ToolBridge props are missing or invalid");	61	throw new Error("ToolBridge props are missing or invalid");
52	}	62	}
53		63
54	return context.props;	64	return parsedProps.data;
55	}	65	}
56		66
57	export function getEntrypointExports(ctx: ExecutionContext): WorkerEntrypointExports {	67	export function getEntrypointExports(ctx: ExecutionContext): WorkerEntrypointExports {
@@ -63,11 +73,11 @@ export function getEntrypointExports(ctx: ExecutionContext): WorkerEntrypointExp · 5 unmodified lines
63	}	73	}
64		74
65	const exportsObject = asObject(exportsValue);	75	const exportsObject = asObject(exportsValue);
66	if (typeof exportsObject.ToolBridge !== "function") {	76	if (!hasToolBridgeExport(exportsObject)) {
67	throw new Error("Execution context ToolBridge export is unavailable");	77	throw new Error("Execution context ToolBridge export is unavailable");
68	}	78	}
69		79
70	return { ToolBridge: exportsObject.ToolBridge as WorkerEntrypointExports["ToolBridge"] };	80	return { ToolBridge: exportsObject.ToolBridge };
71	}	81	}
72		82
73	function createConvexClient(callbackConvexUrl: string): ConvexHttpClient {	83	function createConvexClient(callbackConvexUrl: string): ConvexHttpClient {
@@ -157,16 +167,13 @@ export async function callToolWithBridge( · 83 unmodified lines
157	return { ok: false, kind: "failed", error: `Tool callback failed: ${message}` };	167	return { ok: false, kind: "failed", error: `Tool callback failed: ${message}` };
158	}	168	}
159		169
160	const result = response.value;	170	const parsedResult = toolCallResultSchema.safeParse(response.value);
161	if (!isToolCallResult(result)) {	171	if (!parsedResult.success) {
162	return { ok: false, kind: "failed", error: "Tool callback returned invalid result payload" };	172	return { ok: false, kind: "failed", error: "Tool callback returned invalid result payload" };
163	}	173	}
		174	const result = parsedResult.data;
164		175
165	if (!result.ok && result.kind === "pending") {	176	if (!result.ok && result.kind === "pending") {
166	if (!result.approvalId) {
167	return { ok: false, kind: "failed", error: "Approval pending without approvalId" };
168	}
169
170	const approvalId = result.approvalId;	177	const approvalId = result.approvalId;
171	const wait = await Result.tryPromise(() => waitForApprovalUpdate(props, approvalId));	178	const wait = await Result.tryPromise(() => waitForApprovalUpdate(props, approvalId));
172	if (wait.isErr()) {	179	if (wait.isErr()) {

executor/packages/runner-sandbox-host/src/request.ts+18−6

-import { Result } from "better-result";
+import { z } from "zod";
 import type { RunRequest } from "./types";
+const runRequestSchema: z.ZodType<RunRequest> = z.object({
+  taskId: z.string().min(1),
+  code: z.string().min(1),
+  timeoutMs: z.number().int().positive().optional(),
+  callback: z.object({
+    convexUrl: z.string().min(1),
+    internalSecret: z.string().min(1),
+  }),
+});
 export async function parseRunRequest(request: Request): Promise<RunRequest | Response> {
-  const parsed = await Result.tryPromise(() => request.json() as Promise<RunRequest>);
+  let rawBody: unknown;
-  if (parsed.isErr()) {
+  try {
+    rawBody = await request.json();
+  } catch {
     return Response.json({ error: "Invalid JSON body" }, { status: 400 });
   }
-  const body = parsed.value;
+  const body = runRequestSchema.safeParse(rawBody);
-  if (!body.taskId || !body.code || !body.callback?.convexUrl || !body.callback?.internalSecret) {
+  if (!body.success) {
     return Response.json(
       { error: "Missing required fields: taskId, code, callback.convexUrl, callback.internalSecret" },
       { status: 400 },
     );
   }
-  return body;
+  return body.data;
 }

executor/packages/runner-sandbox-host/src/sandbox.ts+32−15

@@ -1,7 +1,14 @@
1	import { Result } from "better-result";	1	import { z } from "zod";
2	import type { Env, RunRequest, RunResult } from "./types";	2	import type { Env, RunRequest, RunResult } from "./types";
3	import { getEntrypointExports } from "./bridge";	3	import { getEntrypointExports } from "./bridge";
4		4
		5	const runResultSchema: z.ZodType<RunResult> = z.object({
		6	status: z.enum(["completed", "failed", "timed_out", "denied"]),
		7	result: z.unknown().optional(),
		8	error: z.string().optional(),
		9	exitCode: z.number().optional(),
		10	});
		11
5	/**	12	/**
6	* Build the user code module. The code is wrapped in an exported async	13	* Build the user code module. The code is wrapped in an exported async
7	* function `run(tools, console)` so the harness can call it with controlled	14	* function `run(tools, console)` so the harness can call it with controlled
@@ -51,32 +58,42 @@ export async function executeSandboxRun( · 43 unmodified lines
51	const controller = new AbortController();	58	const controller = new AbortController();
52	const timer = setTimeout(() => controller.abort(), timeoutMs);	59	const timer = setTimeout(() => controller.abort(), timeoutMs);
53		60
54	const response = await Result.tryPromise(() =>	61	let response: Response;
55	entrypoint.fetch("http://sandbox.internal/run", {	62	try {
		63	response = await entrypoint.fetch("http://sandbox.internal/run", {
56	method: "POST",	64	method: "POST",
57	signal: controller.signal,	65	signal: controller.signal,
58	}),	66	});
59	);	67	} catch (error) {
60		68	clearTimeout(timer);
61	clearTimeout(timer);	69	if (error instanceof DOMException && error.name === "AbortError") {
62
63	if (response.isErr()) {
64	const cause = response.error.cause;
65	if (cause instanceof DOMException && cause.name === "AbortError") {
66	return {	70	return {
67	status: "timed_out",	71	status: "timed_out",
68	error: `Execution timed out after ${timeoutMs}ms`,	72	error: `Execution timed out after ${timeoutMs}ms`,
69	};	73	};
70	}	74	}
71	throw cause;	75	throw error;
72	}	76	}
73		77
74	const body = await Result.tryPromise(() => response.value.json() as Promise<RunResult>);	78	clearTimeout(timer);
75	if (body.isErr()) {	79
		80	let body: unknown;
		81	try {
		82	body = await response.json();
		83	} catch {
76	return {	84	return {
77	status: "failed",	85	status: "failed",
78	error: "Sandbox isolate returned invalid JSON",	86	error: "Sandbox isolate returned invalid JSON",
79	};	87	};
80	}	88	}
81	return body.value;	89
		90	const parsedBody = runResultSchema.safeParse(body);
		91	if (!parsedBody.success) {
		92	return {
		93	status: "failed",
		94	error: "Sandbox isolate returned invalid response payload",
		95	};
		96	}
		97
		98	return parsedBody.data;
82	}	99	}

executor/packages/runner-sandbox-host/src/types.ts+20−9

 export interface RunRequest {
   taskId: string;
   code: string;
-  timeoutMs: number;
+  timeoutMs?: number;
   callback: {
     convexUrl: string;
     internalSecret: string;
   exitCode?: number;
 }
-export interface ToolCallResult {
+export type ToolCallResult =
-  ok: true | false;
+  | {
-  value?: unknown;
+      ok: true;
-  error?: string;
+      value?: unknown;
-  kind?: "pending" | "denied" | "failed";
+    }
-  approvalId?: string;
+  | {
-  retryAfterMs?: number;
+      ok: false;
-}
+      kind: "pending";
+      approvalId: string;
+      error?: string;
+      retryAfterMs?: number;
+    }
+  | {
+      ok: false;
+      kind: "denied" | "failed";
+      error?: string;
+      approvalId?: string;
+      retryAfterMs?: number;
+    };
 export interface BridgeProps {
   callbackConvexUrl: string;

opencode.json+21−11

 {
   "$schema": "https://opencode.ai/config.json",
-  "mcp":{
+  "mcp": {
     "answeroverflow": {
-		"type": "remote",
+      "type": "remote",
-		"url": "https://www.answeroverflow.com/mcp",
+      "url": "https://www.answeroverflow.com/mcp",
-		"enabled": true
+      "enabled": true
-	},
+    },
-	"oracle": {
+    "oracle": {
-		"type": "local",
+      "type": "local",
-		"command": ["npx", "-y", "@steipete/oracle", "oracle-mcp"],
+      "command": ["npx", "-y", "@steipete/oracle", "oracle-mcp"],
-		"enabled": true
+      "enabled": true
-	}
+    }
   },
-  "agent":{
+  "agent": {
     "quick-build": {
       "mode": "primary",
       "description": "A smaller context winder but extremely fast at working",
         "edit": true,
         "bash": true
       }
+    },
+    "quick-build-subagent": {
+      "mode": "subagent",
+      "description": "A smaller context winder but extremely fast at working",
+      "model": "openai/gpt-5.3-codex-spark",
+      "tools": {
+        "write": true,
+        "edit": true,
+        "bash": true
+      }
     }
   }
 }