lael-labs/executor

executor/packages/core/src/mcp-server.ts+5−15

 // Input schema — when context is bound, workspace fields aren't needed
 // ---------------------------------------------------------------------------
-function toAnySchema(schema: unknown): AnySchema {
+const FULL_INPUT: AnySchema = z.object({
-  return schema as AnySchema;
-}
-const FULL_INPUT = toAnySchema(z.object({
   code: z.string().min(1),
   timeoutMs: z.number().int().min(1).max(600_000).optional(),
   runtimeId: z.string().optional(),
   sessionId: z.string().optional(),
   waitForResult: z.boolean().optional(),
   resultTimeoutMs: z.number().int().min(100).max(900_000).optional(),
-}));
+});
-const BOUND_INPUT = toAnySchema(z.object({
+const BOUND_INPUT: AnySchema = z.object({
   code: z.string().min(1),
   timeoutMs: z.number().int().min(1).max(600_000).optional(),
   runtimeId: z.string().optional(),
   metadata: z.record(z.string(), z.any()).optional(),
-}));
+});
 // ---------------------------------------------------------------------------
 // MCP server factory
     },
   );
   const onApprovalPrompt = createMcpApprovalPrompt(mcp);
-  const registerTool = (mcp.registerTool as (
+  mcp.registerTool(
-    name: string,
-    config: { description: string; inputSchema: AnySchema },
-    cb: ReturnType<typeof createRunCodeTool>,
-  ) => void).bind(mcp);
-  registerTool(
     "run_code",
     {
       description: buildRunCodeDescription(),

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

@@ -17,9 +17,7 @@ export const createTaskEvent = internalMutation({ · 16 unmodified lines
17	throw new Error(`Task not found for event: ${args.taskId}`);	17	throw new Error(`Task not found for event: ${args.taskId}`);
18	}	18	}
19		19
20	const currentSequence = typeof (task as { nextEventSequence?: unknown }).nextEventSequence === "number"	20	const currentSequence = task.nextEventSequence ?? 0;
21	? (task as { nextEventSequence: number }).nextEventSequence
22	: 0;
23	const sequence = currentSequence + 1;	21	const sequence = currentSequence + 1;
24	const createdAt = Date.now();	22	const createdAt = Date.now();
25		23

executor/packages/database/src/database/tool_source_config.test.ts+51−0

@@ -0,0 +1,51 @@
	1	import { expect, test } from "bun:test";
	2	import { normalizeExternalToolSource } from "../runtime/tool_source_loading";
	3	import { normalizeToolSourceConfig } from "./tool_source_config";
	4
	5	test("normalizeToolSourceConfig returns an error result for invalid mcp config", () => {
	6	const result = normalizeToolSourceConfig("mcp", {});
	7
	8	expect(result.isErr()).toBe(true);
	9	if (result.isErr()) {
	10	expect(result.error.message).toBe("Tool source url is required");
	11	}
	12	});
	13
	14	test("normalizeToolSourceConfig trims and normalizes openapi auth/header values", () => {
	15	const result = normalizeToolSourceConfig("openapi", {
	16	spec: " https://example.com/openapi.json ",
	17	baseUrl: " https://api.example.com ",
	18	auth: {
	19	type: "apiKey",
	20	header: " x-api-key ",
	21	value: "token-value",
	22	},
	23	});
	24
	25	expect(result.isOk()).toBe(true);
	26	if (result.isOk()) {
	27	expect(result.value.spec).toBe("https://example.com/openapi.json");
	28	expect(result.value.baseUrl).toBe("https://api.example.com");
	29	expect(result.value.auth?.type).toBe("apiKey");
	30	if (result.value.auth?.type === "apiKey") {
	31	expect(result.value.auth.header).toBe("x-api-key");
	32	expect(result.value.auth.value).toBe("token-value");
	33	}
	34	}
	35	});
	36
	37	test("normalizeExternalToolSource returns error result with source context", () => {
	38	const result = normalizeExternalToolSource({
	39	id: "src_123",
	40	type: "graphql",
	41	name: "bad-graphql",
	42	config: {},
	43	});
	44
	45	expect(result.isErr()).toBe(true);
	46	if (result.isErr()) {
	47	expect(result.error.message).toBe(
	48	"Failed to normalize 'bad-graphql' source config: Tool source endpoint is required",
	49	);
	50	}
	51	});

executor/packages/database/src/database/tool_source_config.ts+44−3

@@ -1,9 +1,34 @@
1	import { Result } from "better-result";	1	import { Result } from "better-result";
2	import type { OpenApiAuth } from "../../../core/src/tool/source-types";	2	import type {
		3	GraphqlToolSourceConfig,
		4	McpToolSourceConfig,
		5	OpenApiAuth,
		6	OpenApiToolSourceConfig,
		7	} from "../../../core/src/tool/source-types";
3	import type { ToolApprovalMode } from "../../../core/src/types";	8	import type { ToolApprovalMode } from "../../../core/src/types";
4	import { asRecord } from "../lib/object";	9	import { asRecord } from "../lib/object";
5		10
6	type ToolSourceType = "mcp" \| "openapi" \| "graphql";	11	export type ToolSourceType = "mcp" \| "openapi" \| "graphql";
		12
		13	export type NormalizedMcpToolSourceConfig = Pick<
		14	McpToolSourceConfig,
		15	"url" \| "auth" \| "discoveryHeaders" \| "transport" \| "queryParams" \| "defaultApproval" \| "overrides"
		16	>;
		17
		18	export type NormalizedGraphqlToolSourceConfig = Pick<
		19	GraphqlToolSourceConfig,
		20	"endpoint" \| "schema" \| "auth" \| "defaultQueryApproval" \| "defaultMutationApproval" \| "overrides"
		21	>;
		22
		23	export type NormalizedOpenApiToolSourceConfig = Pick<
		24	OpenApiToolSourceConfig,
		25	"spec" \| "collectionUrl" \| "postmanProxyUrl" \| "baseUrl" \| "auth" \| "defaultReadApproval" \| "defaultWriteApproval" \| "overrides"
		26	>;
		27
		28	export type NormalizedToolSourceConfig =
		29	\| NormalizedMcpToolSourceConfig
		30	\| NormalizedGraphqlToolSourceConfig
		31	\| NormalizedOpenApiToolSourceConfig;
7		32
8	function optionalTrimmedString(value: unknown): string \| undefined {	33	function optionalTrimmedString(value: unknown): string \| undefined {
9	if (typeof value !== "string") return undefined;	34	if (typeof value !== "string") return undefined;
@@ -164,10 +189,26 @@ function normalizeSpec( · 154 unmodified lines
164	return Result.ok(specObject);	189	return Result.ok(specObject);
165	}	190	}
166		191
		192	export function normalizeToolSourceConfig(
		193	type: "mcp",
		194	rawConfig: unknown,
		195	): Result<NormalizedMcpToolSourceConfig, Error>;
		196	export function normalizeToolSourceConfig(
		197	type: "graphql",
		198	rawConfig: unknown,
		199	): Result<NormalizedGraphqlToolSourceConfig, Error>;
		200	export function normalizeToolSourceConfig(
		201	type: "openapi",
		202	rawConfig: unknown,
		203	): Result<NormalizedOpenApiToolSourceConfig, Error>;
		204	export function normalizeToolSourceConfig(
		205	type: ToolSourceType,
		206	rawConfig: unknown,
		207	): Result<NormalizedToolSourceConfig, Error>;
167	export function normalizeToolSourceConfig(	208	export function normalizeToolSourceConfig(
168	type: ToolSourceType,	209	type: ToolSourceType,
169	rawConfig: unknown,	210	rawConfig: unknown,
170	): Result<Record<string, unknown>, Error> {	211	): Result<NormalizedToolSourceConfig, Error> {
171	const config = asRecord(rawConfig);	212	const config = asRecord(rawConfig);
172		213
173	if (type === "mcp") {	214	if (type === "mcp") {

executor/packages/database/src/runtime/tool_call_credentials.ts+9−8

 import { internal } from "../../convex/_generated/api";
 import { resolveCredentialPayload } from "../../../core/src/credential-providers";
 import { APPROVAL_DENIED_PREFIX } from "../../../core/src/execution-constants";
-import type { CredentialScope, ResolvedToolCredential, TaskRecord, ToolCallRecord, ToolCredentialSpec } from "../../../core/src/types";
+import type { ResolvedToolCredential, TaskRecord, ToolCallRecord, ToolCredentialSpec } from "../../../core/src/types";
 import { asPayload } from "../lib/object";
 export async function resolveCredentialHeaders(
   const record = await ctx.runQuery(internal.database.resolveCredential, {
     workspaceId: task.workspaceId,
     sourceKey: spec.sourceKey,
-    scope: spec.mode as CredentialScope,
+    scope: spec.mode,
     actorId: task.actorId,
   });
   if (!source) {
     return null;
   }
+  const sourcePayload = asPayload(source);
   const headers: Record<string, string> = {};
   if (spec.authType === "bearer") {
-    const token = String((source as Record<string, unknown>).token ?? "").trim();
+    const token = String(sourcePayload.token ?? "").trim();
     if (token) headers.authorization = `Bearer ${token}`;
   } else if (spec.authType === "apiKey") {
-    const headerName = spec.headerName ?? String((source as Record<string, unknown>).headerName ?? "x-api-key");
+    const headerName = spec.headerName ?? String(sourcePayload.headerName ?? "x-api-key");
-    const value = String((source as Record<string, unknown>).value ?? (source as Record<string, unknown>).token ?? "").trim();
+    const value = String(sourcePayload.value ?? sourcePayload.token ?? "").trim();
     if (value) headers[headerName] = value;
   } else if (spec.authType === "basic") {
-    const username = String((source as Record<string, unknown>).username ?? "");
+    const username = String(sourcePayload.username ?? "");
-    const password = String((source as Record<string, unknown>).password ?? "");
+    const password = String(sourcePayload.password ?? "");
     if (username || password) {
       const encoded = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
       headers.authorization = `Basic ${encoded}`;
     }
   }
-  const bindingOverrides = asPayload((record?.overridesJson as unknown) ?? {});
+  const bindingOverrides = asPayload(record?.overridesJson ?? {});
   const overrideHeaders = asPayload(bindingOverrides.headers);
   for (const [key, value] of Object.entries(overrideHeaders)) {
     if (!key) continue;

executor/packages/database/src/runtime/tool_call_resolution.ts+16−8

 "use node";
+import { Result } from "better-result";
 import type { ActionCtx } from "../../convex/_generated/server";
 import { internal } from "../../convex/_generated/api";
 import { parseGraphqlOperationPaths } from "../../../core/src/graphql/operation-paths";
 import type { AccessPolicyRecord, PolicyDecision, TaskRecord, ToolDefinition } from "../../../core/src/types";
 import { rehydrateTools, type SerializedTool } from "../../../core/src/tool/source-serialization";
+import { asPayload } from "../lib/object";
 import { getDecisionForContext, getToolDecision } from "./policy";
 import { getReadyRegistryBuildId } from "./tool_registry_state";
 import { normalizeToolPathForLookup, toPreferredToolPath } from "./tool_paths";
   policies: AccessPolicyRecord[],
 ): { decision: PolicyDecision; effectivePaths: string[] } {
   const sourceName = tool._graphqlSource!;
-  const payload = input && typeof input === "object" ? (input as Record<string, unknown>) : {};
+  const payload = asPayload(input);
   const queryString = typeof payload.query === "string" ? payload.query : "";
   if (!queryString.trim()) {
   ctx: ActionCtx,
   task: TaskRecord,
   toolPath: string,
-): Promise<{
+): Promise<Result<{
   tool: ToolDefinition;
   resolvedToolPath: string;
-}> {
+}, Error>> {
   const builtin = baseTools.get(toolPath);
   if (builtin) {
-    return { tool: builtin, resolvedToolPath: toolPath };
+    return Result.ok({ tool: builtin, resolvedToolPath: toolPath });
   }
   const buildId = await getReadyRegistryBuildId(ctx, {
   if (!entry) {
     const suggestions = await suggestFromRegistry(ctx, task.workspaceId, buildId, toolPath);
-    throw new Error(unknownToolErrorMessage(toolPath, suggestions));
+    return Result.err(new Error(unknownToolErrorMessage(toolPath, suggestions)));
   }
-  const serialized = JSON.parse(entry.serializedToolJson) as SerializedTool;
+  const serializedResult = Result.try(() => JSON.parse(entry.serializedToolJson) as SerializedTool);
+  if (serializedResult.isErr()) {
+    return Result.err(
+      new Error(`Failed to parse tool registry entry '${resolvedToolPath}': ${serializedResult.error.message}`),
+    );
+  }
+  const serialized = serializedResult.value;
   const [tool] = rehydrateTools([serialized], baseTools);
   if (!tool) {
-    throw new Error(`Failed to rehydrate tool: ${resolvedToolPath}`);
+    return Result.err(new Error(`Failed to rehydrate tool: ${resolvedToolPath}`));
   }
-  return { tool, resolvedToolPath };
+  return Result.ok({ tool, resolvedToolPath });
 }

executor/packages/database/src/runtime/tool_invocation.ts+238−200

@@ -2,7 +2,10 @@ · 1 unmodified line
2		2
3	import type { ActionCtx } from "../../convex/_generated/server";	3	import type { ActionCtx } from "../../convex/_generated/server";
4	import { internal } from "../../convex/_generated/api";	4	import { internal } from "../../convex/_generated/api";
5	import { APPROVAL_PENDING_PREFIX } from "../../../core/src/execution-constants";	5	import {
		6	APPROVAL_DENIED_PREFIX,
		7	APPROVAL_PENDING_PREFIX,
		8	} from "../../../core/src/execution-constants";
6	import type {	9	import type {
7	AccessPolicyRecord,	10	AccessPolicyRecord,
8	PolicyDecision,	11	PolicyDecision,
@@ -66,237 +69,265 @@ export async function invokeTool(ctx: ActionCtx, task: TaskRecord, call: ToolCal · 57 unmodified lines
66	})) as ToolCallRecord;	69	})) as ToolCallRecord;
67	assertPersistedCallRunnable(persistedCall, callId);	70	assertPersistedCallRunnable(persistedCall, callId);
68		71
69	const policies = await ctx.runQuery(internal.database.listAccessPolicies, { workspaceId: task.workspaceId });	72	let effectiveToolPath = toolPath;
70	const typedPolicies = policies as AccessPolicyRecord[];	73	try {
71		74	const policies = await ctx.runQuery(internal.database.listAccessPolicies, { workspaceId: task.workspaceId });
72	// Fast system tools are handled server-side from the registry.	75	const typedPolicies = policies as AccessPolicyRecord[];
73	if (toolPath === "discover" \|\| toolPath === "catalog.namespaces" \|\| toolPath === "catalog.tools") {	76	const finalizeImmediateTool = async (value: unknown): Promise<unknown> => {
74	const toolRegistry = internal.toolRegistry;	77	if (persistedCall.status === "requested") {
75	const buildId = await getReadyRegistryBuildId(ctx, {	78	await publishTaskEvent(ctx, task.id, "task", "tool.call.started", {
76	workspaceId: task.workspaceId,	79	taskId: task.id,
77	actorId: task.actorId,	80	callId,
78	clientId: task.clientId,	81	toolPath,
79	refreshOnStale: true,	82	approval: "auto",
80	});	83	});
81		84	}
82	const payload = typeof input === "string"	85	await completeToolCall(ctx, {
83	? { query: input }	86	taskId: task.id,
84	: (input && typeof input === "object" ? (input as Record<string, unknown>) : {});	87	callId,
85	const isAllowed = (path: string, approval: ToolDefinition["approval"]) =>	88	toolPath,
86	getDecisionForContext(	89	});
87	{ path, approval, description: "", run: async () => null } as ToolDefinition,	90	return value;
88	{ workspaceId: task.workspaceId, actorId: task.actorId, clientId: task.clientId },
89	typedPolicies,
90	) !== "deny";
91
92	const normalizeHint = (value: unknown, fallback: string) => {
93	const str = typeof value === "string" ? value.trim() : "";
94	return str.length > 0 ? str : fallback;
95	};	91	};
96		92
97	if (toolPath === "catalog.namespaces") {	93	// Fast system tools are handled server-side from the registry.
98	const limit = Math.max(1, Math.min(200, Number(payload.limit ?? 200)));	94	if (toolPath === "discover" \|\| toolPath === "catalog.namespaces" \|\| toolPath === "catalog.tools") {
99	const namespaces = await ctx.runQuery(toolRegistry.listNamespaces, {	95	const toolRegistry = internal.toolRegistry;
		96	const buildId = await getReadyRegistryBuildId(ctx, {
100	workspaceId: task.workspaceId,	97	workspaceId: task.workspaceId,
101	buildId,	98	actorId: task.actorId,
102	limit,	99	clientId: task.clientId,
103	}) as Array<{ namespace: string; toolCount: number; samplePaths: string[] }>;	100	refreshOnStale: true,
104	return { namespaces, total: namespaces.length };	101	});
105	}
106		102
107	if (toolPath === "catalog.tools") {	103	const payload = typeof input === "string"
108	const namespace = String(payload.namespace ?? "").trim().toLowerCase();	104	? { query: input }
109	const query = String(payload.query ?? "").trim();	105	: asPayload(input);
110	const limit = Math.max(1, Math.min(200, Number(payload.limit ?? 50)));	106	const isAllowed = (path: string, approval: ToolDefinition["approval"]) => {
111		107	const policyProbeTool: ToolDefinition = {
112	const raw = query	108	path,
113	? await ctx.runQuery(toolRegistry.searchTools, {	109	approval,
114	workspaceId: task.workspaceId,	110	description: "",
115	buildId,	111	run: async () => null,
116	query,	112	};
117	limit,	113	return getDecisionForContext(
118	})	114	policyProbeTool,
119	: namespace	115	{ workspaceId: task.workspaceId, actorId: task.actorId, clientId: task.clientId },
120	? await ctx.runQuery(toolRegistry.listToolsByNamespace, {	116	typedPolicies,
		117	) !== "deny";
		118	};
		119
		120	const normalizeHint = (value: unknown, fallback: string) => {
		121	const str = typeof value === "string" ? value.trim() : "";
		122	return str.length > 0 ? str : fallback;
		123	};
		124
		125	if (toolPath === "catalog.namespaces") {
		126	const limit = Math.max(1, Math.min(200, Number(payload.limit ?? 200)));
		127	const namespaces = await ctx.runQuery(toolRegistry.listNamespaces, {
		128	workspaceId: task.workspaceId,
		129	buildId,
		130	limit,
		131	}) as Array<{ namespace: string; toolCount: number; samplePaths: string[] }>;
		132	return await finalizeImmediateTool({ namespaces, total: namespaces.length });
		133	}
		134
		135	if (toolPath === "catalog.tools") {
		136	const namespace = String(payload.namespace ?? "").trim().toLowerCase();
		137	const query = String(payload.query ?? "").trim();
		138	const limit = Math.max(1, Math.min(200, Number(payload.limit ?? 50)));
		139
		140	const raw = query
		141	? await ctx.runQuery(toolRegistry.searchTools, {
121	workspaceId: task.workspaceId,	142	workspaceId: task.workspaceId,
122	buildId,	143	buildId,
123	namespace,	144	query,
124	limit,	145	limit,
125	})	146	})
126	: [];	147	: namespace
		148	? await ctx.runQuery(toolRegistry.listToolsByNamespace, {
		149	workspaceId: task.workspaceId,
		150	buildId,
		151	namespace,
		152	limit,
		153	})
		154	: [];
		155
		156	const results = (raw as RegistryToolEntry[])
		157	.filter((entry) => !namespace \|\| String(entry.preferredPath ?? entry.path ?? "").toLowerCase().startsWith(`${namespace}.`))
		158	.filter((entry) => isAllowed(entry.path, entry.approval))
		159	.slice(0, limit)
		160	.map((entry) => {
		161	const preferredPath = entry.preferredPath ?? entry.path;
		162	return {
		163	path: preferredPath,
		164	source: entry.source,
		165	approval: entry.approval,
		166	description: entry.description,
		167	input: normalizeHint(entry.displayInput, "{}"),
		168	output: normalizeHint(entry.displayOutput, "unknown"),
		169	// required keys are encoded in the `input` type hint
		170	};
		171	});
		172
		173	return await finalizeImmediateTool({ results, total: results.length });
		174	}
		175
		176	// discover
		177	const query = String(payload.query ?? "").trim();
		178	const limit = Math.max(1, Math.min(50, Number(payload.limit ?? 8)));
		179	const compact = payload.compact === false ? false : true;
		180	const hits = await ctx.runQuery(toolRegistry.searchTools, {
		181	workspaceId: task.workspaceId,
		182	buildId,
		183	query,
		184	limit: Math.max(limit * 2, limit),
		185	}) as RegistryToolEntry[];
127		186
128	const results = (raw as RegistryToolEntry[])	187	const filtered = hits
129	.filter((entry) => !namespace \|\| String(entry.preferredPath ?? entry.path ?? "").toLowerCase().startsWith(`${namespace}.`))
130	.filter((entry) => isAllowed(entry.path, entry.approval))	188	.filter((entry) => isAllowed(entry.path, entry.approval))
131	.slice(0, limit)	189	.slice(0, limit);
132	.map((entry) => {	190
133	const preferredPath = entry.preferredPath ?? entry.path;	191	const results = filtered.map((entry) => {
134	return {	192	const preferredPath = entry.preferredPath ?? entry.path;
135	path: preferredPath,	193	const description = compact ? String(entry.description ?? "").split("\n")[0] : entry.description;
136	source: entry.source,	194	return {
137	approval: entry.approval,	195	path: preferredPath,
138	description: entry.description,	196	source: entry.source,
139	input: normalizeHint(entry.displayInput, "{}"),	197	approval: entry.approval,
140	output: normalizeHint(entry.displayOutput, "unknown"),	198	description,
141	// required keys are encoded in the `input` type hint	199	input: normalizeHint(entry.displayInput, "{}"),
142	};	200	output: normalizeHint(entry.displayOutput, "unknown"),
143	});	201	// required keys are encoded in the `input` type hint
144		202	};
145	return { results, total: results.length };	203	});
146	}
147
148	// discover
149	const query = String(payload.query ?? "").trim();
150	const limit = Math.max(1, Math.min(50, Number(payload.limit ?? 8)));
151	const compact = payload.compact === false ? false : true;
152	const hits = await ctx.runQuery(toolRegistry.searchTools, {
153	workspaceId: task.workspaceId,
154	buildId,
155	query,
156	limit: Math.max(limit * 2, limit),
157	}) as RegistryToolEntry[];
158
159	const filtered = hits
160	.filter((entry) => isAllowed(entry.path, entry.approval))
161	.slice(0, limit);
162
163	const results = filtered.map((entry) => {
164	const preferredPath = entry.preferredPath ?? entry.path;
165	const description = compact ? String(entry.description ?? "").split("\n")[0] : entry.description;
166	return {
167	path: preferredPath,
168	source: entry.source,
169	approval: entry.approval,
170	description,
171	input: normalizeHint(entry.displayInput, "{}"),
172	output: normalizeHint(entry.displayOutput, "unknown"),
173	// required keys are encoded in the `input` type hint
174	};
175	});
176
177	const bestPath = results[0]?.path ?? null;
178	return {
179	bestPath,
180	results,
181	total: results.length,
182	};
183	}
184
185	let { tool, resolvedToolPath } = await resolveToolForCall(ctx, task, toolPath);
186		204
187	let decision: PolicyDecision;	205	const bestPath = results[0]?.path ?? null;
188	let effectiveToolPath = resolvedToolPath;	206	return await finalizeImmediateTool({
189	if (tool._graphqlSource) {	207	bestPath,
190	const result = getGraphqlDecision(task, tool, input, undefined, typedPolicies);	208	results,
191	decision = result.decision;	209	total: results.length,
192	if (result.effectivePaths.length > 0) {	210	});
193	effectiveToolPath = result.effectivePaths.join(", ");
194	}	211	}
195	} else {
196	decision = getToolDecision(task, tool, typedPolicies);
197	}
198
199	const publishToolStarted = persistedCall.status === "requested";
200		212
201	if (decision === "deny") {	213	const resolvedToolResult = await resolveToolForCall(ctx, task, toolPath);
202	const deniedMessage = `${effectiveToolPath} (policy denied)`;	214	if (resolvedToolResult.isErr()) {
203	await denyToolCall(ctx, {	215	throw resolvedToolResult.error;
204	task,
205	callId,
206	toolPath: effectiveToolPath,
207	deniedMessage,
208	reason: "policy_deny",
209	});
210	}
211
212	let credential: ResolvedToolCredential \| undefined;
213	if (tool.credential) {
214	const resolved = await resolveCredentialHeaders(ctx, tool.credential, task);
215	if (!resolved) {
216	throw new Error(`Missing credential for source '${tool.credential.sourceKey}' (${tool.credential.mode} scope)`);
217	}	216	}
218	credential = resolved;	217	const { tool, resolvedToolPath } = resolvedToolResult.value;
219	}	218
220		219	let decision: PolicyDecision;
221	if (publishToolStarted) {	220	effectiveToolPath = resolvedToolPath;
222	await publishTaskEvent(ctx, task.id, "task", "tool.call.started", {	221	if (tool._graphqlSource) {
223	taskId: task.id,	222	const result = getGraphqlDecision(task, tool, input, undefined, typedPolicies);
224	callId,	223	decision = result.decision;
225	toolPath: effectiveToolPath,	224	if (result.effectivePaths.length > 0) {
226	approval: decision === "require_approval" ? "required" : "auto",	225	effectiveToolPath = result.effectivePaths.join(", ");
227	});	226	}
228	}	227	} else {
229		228	decision = getToolDecision(task, tool, typedPolicies);
230	let approvalSatisfied = false;
231	if (persistedCall.approvalId) {
232	const existingApproval = await ctx.runQuery(internal.database.getApproval, {
233	approvalId: persistedCall.approvalId,
234	});
235	if (!existingApproval) {
236	throw new Error(`Approval ${persistedCall.approvalId} not found for call ${callId}`);
237	}	229	}
238		230
239	if (existingApproval.status === "pending") {	231	const publishToolStarted = persistedCall.status === "requested";
240	throw new Error(`${APPROVAL_PENDING_PREFIX}${existingApproval.id}`);
241	}
242		232
243	if (existingApproval.status === "denied") {	233	if (decision === "deny") {
244	await denyToolCallForApproval(ctx, {	234	const deniedMessage = `${effectiveToolPath} (policy denied)`;
		235	await denyToolCall(ctx, {
245	task,	236	task,
246	callId,	237	callId,
247	toolPath: effectiveToolPath,	238	toolPath: effectiveToolPath,
248	approvalId: existingApproval.id,	239	deniedMessage,
		240	reason: "policy_deny",
249	});	241	});
250	}	242	}
251		243
252	approvalSatisfied = existingApproval.status === "approved";	244	let credential: ResolvedToolCredential \| undefined;
253	}	245	if (tool.credential) {
254		246	const resolved = await resolveCredentialHeaders(ctx, tool.credential, task);
255	if (decision === "require_approval" && !approvalSatisfied) {	247	if (!resolved) {
256	const approvalId = persistedCall.approvalId ?? createApprovalId();	248	throw new Error(`Missing credential for source '${tool.credential.sourceKey}' (${tool.credential.mode} scope)`);
257	let approval = await ctx.runQuery(internal.database.getApproval, {	249	}
258	approvalId,	250	credential = resolved;
259	});	251	}
260		252
261	if (!approval) {	253	if (publishToolStarted) {
262	approval = await ctx.runMutation(internal.database.createApproval, {	254	await publishTaskEvent(ctx, task.id, "task", "tool.call.started", {
263	id: approvalId,
264	taskId: task.id,	255	taskId: task.id,
		256	callId,
265	toolPath: effectiveToolPath,	257	toolPath: effectiveToolPath,
266	input,	258	approval: decision === "require_approval" ? "required" : "auto",
267	});	259	});
		260	}
268		261
269	await publishTaskEvent(ctx, task.id, "approval", "approval.requested", {	262	let approvalSatisfied = false;
270	approvalId: approval.id,	263	if (persistedCall.approvalId) {
271	taskId: task.id,	264	const existingApproval = await ctx.runQuery(internal.database.getApproval, {
272	callId,	265	approvalId: persistedCall.approvalId,
273	toolPath: approval.toolPath,
274	input: asPayload(approval.input),
275	createdAt: approval.createdAt,
276	});	266	});
		267	if (!existingApproval) {
		268	throw new Error(`Approval ${persistedCall.approvalId} not found for call ${callId}`);
		269	}
		270
		271	if (existingApproval.status === "pending") {
		272	throw new Error(`${APPROVAL_PENDING_PREFIX}${existingApproval.id}`);
		273	}
		274
		275	if (existingApproval.status === "denied") {
		276	await denyToolCallForApproval(ctx, {
		277	task,
		278	callId,
		279	toolPath: effectiveToolPath,
		280	approvalId: existingApproval.id,
		281	});
		282	}
		283
		284	approvalSatisfied = existingApproval.status === "approved";
277	}	285	}
278		286
279	await ctx.runMutation(internal.database.setToolCallPendingApproval, {	287	if (decision === "require_approval" && !approvalSatisfied) {
280	taskId: task.id,	288	const approvalId = persistedCall.approvalId ?? createApprovalId();
281	callId,	289	let approval = await ctx.runQuery(internal.database.getApproval, {
282	approvalId: approval.id,	290	approvalId,
283	});	291	});
284		292
285	if (approval.status === "pending") {	293	if (!approval) {
286	throw new Error(`${APPROVAL_PENDING_PREFIX}${approval.id}`);	294	approval = await ctx.runMutation(internal.database.createApproval, {
287	}	295	id: approvalId,
		296	taskId: task.id,
		297	toolPath: effectiveToolPath,
		298	input,
		299	});
288		300
289	if (approval.status === "denied") {	301	await publishTaskEvent(ctx, task.id, "approval", "approval.requested", {
290	await denyToolCallForApproval(ctx, {	302	approvalId: approval.id,
291	task,	303	taskId: task.id,
		304	callId,
		305	toolPath: approval.toolPath,
		306	input: asPayload(approval.input),
		307	createdAt: approval.createdAt,
		308	});
		309	}
		310
		311	await ctx.runMutation(internal.database.setToolCallPendingApproval, {
		312	taskId: task.id,
292	callId,	313	callId,
293	toolPath: effectiveToolPath,
294	approvalId: approval.id,	314	approvalId: approval.id,
295	});	315	});
		316
		317	if (approval.status === "pending") {
		318	throw new Error(`${APPROVAL_PENDING_PREFIX}${approval.id}`);
		319	}
		320
		321	if (approval.status === "denied") {
		322	await denyToolCallForApproval(ctx, {
		323	task,
		324	callId,
		325	toolPath: effectiveToolPath,
		326	approvalId: approval.id,
		327	});
		328	}
296	}	329	}
297	}
298		330
299	try {
300	const context: ToolRunContext = {	331	const context: ToolRunContext = {
301	taskId: task.id,	332	taskId: task.id,
302	workspaceId: task.workspaceId,	333	workspaceId: task.workspaceId,
@@ -315,12 +346,19 @@ export async function invokeTool(ctx: ActionCtx, task: TaskRecord, call: ToolCal · 12 unmodified lines
315	return value;	346	return value;
316	} catch (error) {	347	} catch (error) {
317	const message = describeError(error);	348	const message = describeError(error);
318	await failToolCall(ctx, {	349	const isApprovalControlSignal =
319	taskId: task.id,	350	message.startsWith(APPROVAL_PENDING_PREFIX) \|\|
320	callId,	351	message.startsWith(APPROVAL_DENIED_PREFIX);
321	error: message,	352
322	toolPath: effectiveToolPath,	353	if (!isApprovalControlSignal) {
323	});	354	await failToolCall(ctx, {
		355	taskId: task.id,
		356	callId,
		357	error: message,
		358	toolPath: effectiveToolPath,
		359	});
		360	}
		361
324	throw error;	362	throw error;
325	}	363	}
326	}	364	}

executor/packages/database/src/runtime/tool_registry_state.ts+42−3

@@ -3,6 +3,7 @@ · 2 unmodified lines
3	import type { ActionCtx } from "../../convex/_generated/server";	3	import type { ActionCtx } from "../../convex/_generated/server";
4	import type { Id } from "../../convex/_generated/dataModel.d.ts";	4	import type { Id } from "../../convex/_generated/dataModel.d.ts";
5	import { internal } from "../../convex/_generated/api";	5	import { internal } from "../../convex/_generated/api";
		6	import { asPayload } from "../lib/object";
6	import { sourceSignature } from "./tool_source_loading";	7	import { sourceSignature } from "./tool_source_loading";
7		8
8	export const TOOL_REGISTRY_SIGNATURE_PREFIX = "toolreg_v2\|";	9	export const TOOL_REGISTRY_SIGNATURE_PREFIX = "toolreg_v2\|";
@@ -26,14 +27,52 @@ type ToolSourceState = { · 17 unmodified lines
26	enabled: boolean;	27	enabled: boolean;
27	};	28	};
28		29
		30	function toRegistryState(value: unknown): RegistryState {
		31	if (!value \|\| typeof value !== "object" \|\| Array.isArray(value)) {
		32	return null;
		33	}
		34
		35	const state = asPayload(value);
		36	if (typeof state.signature !== "string") {
		37	return null;
		38	}
		39
		40	return {
		41	signature: state.signature,
		42	readyBuildId: typeof state.readyBuildId === "string" ? state.readyBuildId : undefined,
		43	};
		44	}
		45
		46	function toToolSourceStateList(value: unknown): ToolSourceState[] {
		47	if (!Array.isArray(value)) {
		48	return [];
		49	}
		50
		51	const normalized: ToolSourceState[] = [];
		52	for (const entry of value) {
		53	const record = asPayload(entry);
		54	if (typeof record.id !== "string") continue;
		55	if (typeof record.updatedAt !== "number") continue;
		56	normalized.push({
		57	id: record.id,
		58	updatedAt: record.updatedAt,
		59	enabled: record.enabled !== false,
		60	});
		61	}
		62
		63	return normalized;
		64	}
		65
29	async function readRegistryState(	66	async function readRegistryState(
30	ctx: Pick<ActionCtx, "runQuery">,	67	ctx: Pick<ActionCtx, "runQuery">,
31	workspaceId: Id<"workspaces">,	68	workspaceId: Id<"workspaces">,
32	): Promise<{ buildId?: string; isReady: boolean }> {	69	): Promise<{ buildId?: string; isReady: boolean }> {
33	const [state, sources] = await Promise.all([	70	const [rawState, rawSources] = await Promise.all([
34	ctx.runQuery(internal.toolRegistry.getState, { workspaceId }) as Promise<RegistryState>,	71	ctx.runQuery(internal.toolRegistry.getState, { workspaceId }),
35	ctx.runQuery(internal.database.listToolSources, { workspaceId }) as Promise<ToolSourceState[]>,	72	ctx.runQuery(internal.database.listToolSources, { workspaceId }),
36	]);	73	]);
		74	const state = toRegistryState(rawState);
		75	const sources = toToolSourceStateList(rawSources);
37		76
38	const expectedSignature = registrySignatureForWorkspace(workspaceId, sources);	77	const expectedSignature = registrySignatureForWorkspace(workspaceId, sources);
39	const buildId = state?.readyBuildId;	78	const buildId = state?.readyBuildId;

executor/packages/database/src/runtime/tool_source_loading.ts+47−27

 "use node";
+import { Result } from "better-result";
 import type { ActionCtx } from "../../convex/_generated/server";
 import { internal } from "../../convex/_generated/api";
 import type { Id } from "../../convex/_generated/dataModel.d.ts";
   type: ToolSourceRecord["type"];
   name: string;
   config: Record<string, unknown>;
-}): ExternalToolSourceConfig {
+}): Result<ExternalToolSourceConfig, Error> {
-  const configResult = normalizeToolSourceConfig(raw.type, raw.config);
-  if (configResult.isErr()) {
-    throw new Error(`Failed to normalize '${raw.name}' source config: ${configResult.error.message}`);
-  }
-  const config = configResult.value;
   if (raw.type === "mcp") {
+    const configResult = normalizeToolSourceConfig("mcp", raw.config);
+    if (configResult.isErr()) {
+      return Result.err(
+        new Error(`Failed to normalize '${raw.name}' source config: ${configResult.error.message}`),
+      );
+    }
+    const config = configResult.value;
     const result: McpToolSourceConfig = {
       type: "mcp",
       name: raw.name,
       sourceId: raw.id,
       sourceKey: `source:${raw.id}`,
-      url: String(config.url),
+      url: config.url,
-      auth: config.auth as McpToolSourceConfig["auth"],
+      auth: config.auth,
-      transport: config.transport as McpToolSourceConfig["transport"],
+      transport: config.transport,
-      queryParams: config.queryParams as McpToolSourceConfig["queryParams"],
+      queryParams: config.queryParams,
-      defaultApproval: config.defaultApproval as McpToolSourceConfig["defaultApproval"],
+      defaultApproval: config.defaultApproval,
-      overrides: config.overrides as McpToolSourceConfig["overrides"],
+      overrides: config.overrides,
     };
-    return result;
+    return Result.ok(result);
   }
   if (raw.type === "graphql") {
+    const configResult = normalizeToolSourceConfig("graphql", raw.config);
+    if (configResult.isErr()) {
+      return Result.err(
+        new Error(`Failed to normalize '${raw.name}' source config: ${configResult.error.message}`),
+      );
+    }
+    const config = configResult.value;
     const result: GraphqlToolSourceConfig = {
       type: "graphql",
       name: raw.name,
       sourceId: raw.id,
       sourceKey: `source:${raw.id}`,
-      endpoint: String(config.endpoint),
+      endpoint: config.endpoint,
-      schema: config.schema as GraphqlToolSourceConfig["schema"],
+      schema: config.schema,
-      auth: config.auth as GraphqlToolSourceConfig["auth"],
+      auth: config.auth,
-      defaultQueryApproval: config.defaultQueryApproval as GraphqlToolSourceConfig["defaultQueryApproval"],
+      defaultQueryApproval: config.defaultQueryApproval,
-      defaultMutationApproval: config.defaultMutationApproval as GraphqlToolSourceConfig["defaultMutationApproval"],
+      defaultMutationApproval: config.defaultMutationApproval,
-      overrides: config.overrides as GraphqlToolSourceConfig["overrides"],
+      overrides: config.overrides,
     };
-    return result;
+    return Result.ok(result);
+  }
+  const configResult = normalizeToolSourceConfig("openapi", raw.config);
+  if (configResult.isErr()) {
+    return Result.err(
+      new Error(`Failed to normalize '${raw.name}' source config: ${configResult.error.message}`),
+    );
   }
+  const config = configResult.value;
   const result: OpenApiToolSourceConfig = {
     type: "openapi",
     name: raw.name,
     sourceId: raw.id,
     sourceKey: `source:${raw.id}`,
-    spec: config.spec as OpenApiToolSourceConfig["spec"],
+    spec: config.spec,
-    baseUrl: config.baseUrl as OpenApiToolSourceConfig["baseUrl"],
+    collectionUrl: config.collectionUrl,
-    auth: config.auth as OpenApiToolSourceConfig["auth"],
+    postmanProxyUrl: config.postmanProxyUrl,
-    defaultReadApproval: config.defaultReadApproval as OpenApiToolSourceConfig["defaultReadApproval"],
+    baseUrl: config.baseUrl,
-    defaultWriteApproval: config.defaultWriteApproval as OpenApiToolSourceConfig["defaultWriteApproval"],
+    auth: config.auth,
-    overrides: config.overrides as OpenApiToolSourceConfig["overrides"],
+    defaultReadApproval: config.defaultReadApproval,
+    defaultWriteApproval: config.defaultWriteApproval,
+    overrides: config.overrides,
   };
-  return result;
+  return Result.ok(result);
 }
 function buildHeadersFromCredentialSecret(

executor/packages/database/src/runtime/workspace_tools.ts+9−8

 import { loadSourceArtifact, normalizeExternalToolSource, sourceSignature } from "./tool_source_loading";
 import { registrySignatureForWorkspace } from "./tool_registry_state";
 import { normalizeToolPathForLookup } from "./tool_paths";
+import { asPayload } from "../lib/object";
 const baseTools = new Map<string, ToolDefinition>();
     },
   },
   run: async (input: unknown) => {
-    const payload = input && typeof input === "object" ? (input as Record<string, unknown>) : {};
+    const payload = asPayload(input);
     const channel = typeof payload.channel === "string" ? payload.channel : "";
     const message = typeof payload.message === "string" ? payload.message : "";
     return { ok: true, channel, message };
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
   }
-  return value as JsonSchema;
+  return asPayload(value);
 }
 async function buildWorkspaceToolRegistry(
     if (source.type !== "mcp") {
       return false;
     }
-    const auth = source.config.auth as Record<string, unknown> | undefined;
+    const auth = asPayload(source.config.auth);
     return auth?.mode === "actor";
   });
   const skipCacheRead = (options.skipCacheRead ?? false) || hasActorScopedMcpSource;
   const warnings: string[] = [];
   const normalizeSourcesStartedAt = Date.now();
   for (const source of sources) {
-    try {
+    const normalizedResult = normalizeExternalToolSource(source);
-      configs.push(normalizeExternalToolSource(source));
+    if (normalizedResult.isErr()) {
-    } catch (error) {
+      warnings.push(`Source '${source.name}': ${normalizedResult.error.message}`);
-      const message = error instanceof Error ? error.message : String(error);
+      continue;
-      warnings.push(`Source '${source.name}': ${message}`);
     }
+    configs.push(normalizedResult.value);
   }
   traceStep("normalizeSources", normalizeSourcesStartedAt);