lael-labs/executor

.gitignore+3−0

@@ -41,3 +41,6 @@ convex_local_storage/ · 40 unmodified lines
41		41
42	# Generated push env file	42	# Generated push env file
43	executor/.env.executor-push	43	executor/.env.executor-push
		44
		45	# Dev runner PID file
		46	.dev.pids

assistant/packages/server/src/index.ts+21−12

@@ -32,18 +32,27 @@ if (PINNED_WORKSPACE_ID && PINNED_ACTOR_ID) { · 31 unmodified lines
32	clientId: PINNED_CLIENT_ID,	32	clientId: PINNED_CLIENT_ID,
33	};	33	};
34	} else {	34	} else {
35	try {	35	const MAX_RETRIES = 30;
36	const bootstrap = await convex.mutation(api.database.bootstrapAnonymousSession, {	36	const RETRY_DELAY_MS = 2000;
37	sessionId: ANON_SESSION_ID,	37	for (let attempt = 1; ; attempt++) {
38	});	38	try {
39	ctx = {	39	const bootstrap = await convex.mutation(api.database.bootstrapAnonymousSession, {
40	workspaceId: bootstrap.workspaceId,	40	sessionId: ANON_SESSION_ID,
41	actorId: bootstrap.actorId,	41	});
42	clientId: PINNED_CLIENT_ID ?? bootstrap.clientId,	42	ctx = {
43	};	43	workspaceId: bootstrap.workspaceId,
44	} catch (error) {	44	actorId: bootstrap.actorId,
45	console.error("Failed to bootstrap executor context from Convex at", CONVEX_URL, error);	45	clientId: PINNED_CLIENT_ID ?? bootstrap.clientId,
46	process.exit(1);	46	};
		47	break;
		48	} catch (error) {
		49	if (attempt >= MAX_RETRIES) {
		50	console.error("Failed to bootstrap executor context from Convex at", CONVEX_URL, error);
		51	process.exit(1);
		52	}
		53	console.log(`[assistant] Waiting for Convex functions... (attempt ${attempt}/${MAX_RETRIES})`);
		54	await Bun.sleep(RETRY_DELAY_MS);
		55	}
47	}	56	}
48	}	57	}
49		58

dev.ts+63−44

@@ -6,15 +6,20 @@ · 5 unmodified lines
6	* Reads all configuration from the root .env file (auto-loaded by Bun).	6	* Reads all configuration from the root .env file (auto-loaded by Bun).
7	*	7	*
8	* Starts:	8	* Starts:
9	* 1. Convex cloud dev function push (once)	9	* 1. Convex cloud dev function watcher ─┐
10	* 2. Convex cloud dev function watcher	10	* 2. Executor web UI (port 3002) ├─ all started concurrently
11	* 3. Executor web UI (port 3002)	11	* 3. Assistant server (port 3000) │
12	* 4. Assistant server (port 3000)	12	* 4. Discord bot ─┘
13	* 5. Discord bot
14	*	13	*
15	* All processes are killed when this script exits (Ctrl+C).	14	* All processes are killed when this script exits (Ctrl+C).
		15	* PIDs are written to .dev.pids for use with `bun run kill:all`.
16	*/	16	*/
17		17
		18	import { join } from "node:path";
		19	import { unlinkSync } from "node:fs";
		20
		21	const PID_FILE = join(import.meta.dir, ".dev.pids");
		22
18	const colors = {	23	const colors = {
19	convex: "\x1b[36m", // cyan	24	convex: "\x1b[36m", // cyan
20	web: "\x1b[34m", // blue	25	web: "\x1b[34m", // blue
@@ -31,6 +36,15 @@ function prefix(name: ServiceName, line: string): string { · 10 unmodified lines
31		36
32	const procs: Bun.Subprocess[] = [];	37	const procs: Bun.Subprocess[] = [];
33		38
		39	function writePidFile() {
		40	const pids = [process.pid, ...procs.map((p) => p.pid)].join("\n");
		41	Bun.write(PID_FILE, pids);
		42	}
		43
		44	function removePidFile() {
		45	try { unlinkSync(PID_FILE); } catch {}
		46	}
		47
34	function toSiteUrl(convexUrl: string): string {	48	function toSiteUrl(convexUrl: string): string {
35	if (convexUrl.includes(".convex.cloud")) {	49	if (convexUrl.includes(".convex.cloud")) {
36	return convexUrl.replace(".convex.cloud", ".convex.site");	50	return convexUrl.replace(".convex.cloud", ".convex.site");
@@ -59,6 +73,7 @@ function spawnService(name: ServiceName, cmd: string[], opts: { · 22 unmodified lines
59	env: { ...Bun.env, FORCE_COLOR: "1", ...opts.env },	73	env: { ...Bun.env, FORCE_COLOR: "1", ...opts.env },
60	});	74	});
61	procs.push(proc);	75	procs.push(proc);
		76	writePidFile();
62		77
63	const stream = async (s: ReadableStream<Uint8Array>, isErr: boolean) => {	78	const stream = async (s: ReadableStream<Uint8Array>, isErr: boolean) => {
64	const reader = s.getReader();	79	const reader = s.getReader();
@@ -87,60 +102,68 @@ function spawnService(name: ServiceName, cmd: string[], opts: { · 22 unmodified lines
87	return proc;	102	return proc;
88	}	103	}
89		104
90	// ── Convex cloud deployment ──	105	// ── Cleanup ──
91		106
92	async function pushConvexFunctions(): Promise<void> {	107	function shutdown() {
93	console.log(prefix("convex", "Pushing functions..."));	108	console.log("\nShutting down all services...");
		109	for (const proc of procs) proc.kill();
		110	removePidFile();
		111	process.exit(0);
		112	}
94		113
95	const proc = Bun.spawn([	114	process.on("SIGINT", shutdown);
96	"bunx", "convex", "dev", "--once",	115	process.on("SIGTERM", shutdown);
97	"--typecheck", "disable",	116
98	], {	117	// ── Kill stale processes from a previous run ──
99	cwd: "./executor",	118
100	stdout: "pipe",	119	const DEV_PORTS = [3000, 3002];
101	stderr: "pipe",	120
102	env: { ...Bun.env, FORCE_COLOR: "1" },	121	async function killStaleProcesses() {
103	});	122	let killed = 0;
104		123
105	const stdout = await Bun.readableStreamToText(proc.stdout);	124	// Kill tracked PIDs
106	const stderr = await Bun.readableStreamToText(proc.stderr);	125	const file = Bun.file(PID_FILE);
107	const code = await proc.exited;	126	if (await file.exists()) {
		127	const pids = (await file.text())
		128	.split("\n").map((l) => l.trim()).filter(Boolean).map(Number).filter((n) => !isNaN(n));
108		129
109	if (stdout.trim()) console.log(prefix("convex", stdout.trim()));	130	for (const pid of pids) {
110	if (code !== 0) {	131	try { Bun.spawnSync(["pkill", "-TERM", "--parent", String(pid)]); } catch {}
111	console.error(prefix("convex", `Push failed (exit ${code}): ${stderr.trim()}`));	132	try { process.kill(pid, "SIGTERM"); killed++; } catch {}
112	throw new Error("Convex function push failed");	133	}
		134	removePidFile();
113	}	135	}
114	console.log(prefix("convex", "Functions ready!"));
115	}
116		136
117	// ── Cleanup ──	137	// Kill anything still on dev ports
		138	for (const port of DEV_PORTS) {
		139	const result = Bun.spawnSync(["fuser", "-k", `${port}/tcp`], { stderr: "pipe" });
		140	const stderr = result.stderr.toString().trim();
		141	if (stderr && stderr.includes(String(port))) killed++;
		142	}
118		143
119	process.on("SIGINT", () => {	144	if (killed > 0) {
120	console.log("\nShutting down all services...");	145	console.log(`Killed ${killed} stale process(es) from previous run.\n`);
121	for (const proc of procs) proc.kill();	146	await Bun.sleep(500);
122	process.exit(0);	147	}
123	});	148	}
124	process.on("SIGTERM", () => {
125	for (const proc of procs) proc.kill();
126	process.exit(0);
127	});
128		149
129	// ── Start everything ──	150	// ── Start everything ──
130		151
		152	await killStaleProcesses();
		153
		154	// Write PID file immediately so kill:all works even before services spawn
		155	writePidFile();
		156
131	console.log("Starting all services...\n");	157	console.log("Starting all services...\n");
132	if (!Bun.env.DISCORD_BOT_TOKEN) {	158	if (!Bun.env.DISCORD_BOT_TOKEN) {
133	console.log(`${colors.bot}[bot]${colors.reset} Skipped — no DISCORD_BOT_TOKEN set\n`);	159	console.log(`${colors.bot}[bot]${colors.reset} Skipped — no DISCORD_BOT_TOKEN set\n`);
134	}	160	}
135		161
136	// 1. Push functions (must complete before executor starts)
137	await pushConvexFunctions();
138
139	const urls = resolveExecutorUrls();	162	const urls = resolveExecutorUrls();
140	console.log(prefix("convex", `Using Convex URL: ${urls.convexUrl}`));	163	console.log(prefix("convex", `Using Convex URL: ${urls.convexUrl}`));
141	console.log(prefix("convex", `Using executor HTTP URL: ${urls.executorUrl}`));	164	console.log(prefix("convex", `Using executor HTTP URL: ${urls.executorUrl}`));
142		165
143	// 2. Start Convex file watcher (repushes on changes)	166	// 2. Start Convex file watcher (non-blocking — repushes on changes)
144	spawnService("convex", [	167	spawnService("convex", [
145	"bunx", "convex", "dev",	168	"bunx", "convex", "dev",
146	"--typecheck", "disable",	169	"--typecheck", "disable",
@@ -153,9 +176,6 @@ spawnService("web", ["bun", "run", "dev", "--", "-p", "3002"], { · 6 unmodified lines
153	cwd: "./executor/apps/web",	176	cwd: "./executor/apps/web",
154	});	177	});
155		178
156	// Small delay for web to be ready
157	await Bun.sleep(1200);
158
159	spawnService("assistant", ["bun", "run", "dev"], {	179	spawnService("assistant", ["bun", "run", "dev"], {
160	cwd: "./assistant/packages/server",	180	cwd: "./assistant/packages/server",
161	env: {	181	env: {
@@ -167,7 +187,6 @@ spawnService("assistant", ["bun", "run", "dev"], { · 5 unmodified lines
167	});	187	});
168		188
169	if (Bun.env.DISCORD_BOT_TOKEN) {	189	if (Bun.env.DISCORD_BOT_TOKEN) {
170	await Bun.sleep(1000);
171	spawnService("bot", ["bun", "run", "dev"], {	190	spawnService("bot", ["bun", "run", "dev"], {
172	cwd: "./assistant/packages/bot",	191	cwd: "./assistant/packages/bot",
173	env: {	192	env: {

executor/apps/web/src/components/approvals-view.tsx+3−3

     try {
       await resolveApproval({
         workspaceId: context.workspaceId,
+        sessionId: context.sessionId,
         approvalId: approval.id,
         decision,
-        reviewerId: context.actorId,
       });
       toast.success(
         decision === "approved"
   const { context, loading: sessionLoading } = useSession();
   const approvals = useQuery(
-    convexApi.database.listPendingApprovals,
+    convexApi.workspace.listPendingApprovals,
-    context ? { workspaceId: context.workspaceId } : "skip",
+    context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
   );
   const approvalsLoading = !!context && approvals === undefined;

executor/apps/web/src/components/code-editor.tsx+108−7

@@ -36,12 +36,6 @@ function buildTree(tools: ToolDescriptor[]): NamespaceNode { · 35 unmodified lines
36		36
37	function emitToolMethod(tool: ToolDescriptor): string {	37	function emitToolMethod(tool: ToolDescriptor): string {
38	const funcName = tool.path.split(".").pop()!;	38	const funcName = tool.path.split(".").pop()!;
39	const hasArgsType = Boolean(tool.argsType?.trim());
40	const argsType = hasArgsType ? tool.argsType!.trim() : "Record<string, unknown>";
41	const returnsType = tool.returnsType?.trim() \|\| "unknown";
42	const inputParam = !hasArgsType \|\| argsType === "{}"
43	? `input?: ${argsType}`
44	: `input: ${argsType}`;
45	const approvalNote =	39	const approvalNote =
46	tool.approval === "required"	40	tool.approval === "required"
47	? " Requires approval - execution will pause until approved."	41	? " Requires approval - execution will pause until approved."
@@ -50,6 +44,24 @@ function emitToolMethod(tool: ToolDescriptor): string { · 2 unmodified lines
50	? `${tool.description}${approvalNote}`	44	? `${tool.description}${approvalNote}`
51	: approvalNote \|\| "Call this tool.";	45	: approvalNote \|\| "Call this tool.";
52		46
		47	// For OpenAPI tools with operationId, use indexed access types for precise IntelliSense
		48	if (tool.operationId) {
		49	const opKey = JSON.stringify(tool.operationId);
		50	return ` /**
		51	* ${desc}
		52	*${tool.source ? ` @source ${tool.source}` : ""}
		53	*/
		54	${funcName}(input: ToolInput<operations[${opKey}]>): Promise<ToolOutput<operations[${opKey}]>>;`;
		55	}
		56
		57	// Fallback for MCP, GraphQL, builtins — use argsType/returnsType strings
		58	const hasArgsType = Boolean(tool.argsType?.trim());
		59	const argsType = hasArgsType ? tool.argsType!.trim() : "Record<string, unknown>";
		60	const returnsType = tool.returnsType?.trim() \|\| "unknown";
		61	const inputParam = !hasArgsType \|\| argsType === "{}"
		62	? `input?: ${argsType}`
		63	: `input: ${argsType}`;
		64
53	return ` /**	65	return ` /**
54	* ${desc}	66	* ${desc}
55	*${tool.source ? ` @source ${tool.source}` : ""}	67	*${tool.source ? ` @source ${tool.source}` : ""}
@@ -94,10 +106,28 @@ function countAllTools(node: NamespaceNode): number { · 38 unmodified lines
94	return count;	106	return count;
95	}	107	}
96		108
		109	/** TS helper types for OpenAPI indexed access (same as typechecker.ts) */
		110	const OPENAPI_HELPER_TYPES = `
		111	type _OrEmpty<T> = [T] extends [never] ? {} : T;
		112	type _Simplify<T> = { [K in keyof T]: T[K] } & {};
		113	type ToolInput<Op> = _Simplify<
		114	_OrEmpty<Op extends { parameters: { query: infer Q } } ? { [K in keyof Q]: Q[K] } : never> &
		115	_OrEmpty<Op extends { parameters: { path: infer P } } ? { [K in keyof P]: P[K] } : never> &
		116	_OrEmpty<Op extends { requestBody: { content: { "application/json": infer B } } } ? B : never>
		117	>;
		118	type ToolOutput<Op> =
		119	Op extends { responses: { 200: { content: { "application/json": infer R } } } } ? R :
		120	Op extends { responses: { 201: { content: { "application/json": infer R } } } } ? R :
		121	Op extends { responses: { 202: { content: { "application/json": infer R } } } } ? R :
		122	Op extends { responses: { 204: { content: never } } } ? void :
		123	unknown;
		124	`;
		125
97	function generateToolsDts(tools: ToolDescriptor[]): string {	126	function generateToolsDts(tools: ToolDescriptor[]): string {
98	const root = buildTree(tools);	127	const root = buildTree(tools);
99	const schemaTypeAliases = new Map<string, string>();
100		128
		129	// Legacy compat: collect schemaTypes from tools that use the old format
		130	const schemaTypeAliases = new Map<string, string>();
101	for (const tool of tools) {	131	for (const tool of tools) {
102	if (!tool.schemaTypes) continue;	132	if (!tool.schemaTypes) continue;
103	for (const [name, type] of Object.entries(tool.schemaTypes)) {	133	for (const [name, type] of Object.entries(tool.schemaTypes)) {
@@ -134,9 +164,16 @@ function generateToolsDts(tools: ToolDescriptor[]): string { · 30 unmodified lines
134	* Tools marked with "approval: required" will pause execution until approved.	164	* Tools marked with "approval: required" will pause execution until approved.
135	*/	165	*/
136	`;	166	`;
		167
		168	// Legacy schema type aliases
137	if (schemaTypeAliases.size > 0) {	169	if (schemaTypeAliases.size > 0) {
138	dts += Array.from(schemaTypeAliases, ([name, type]) => `type ${name} = ${type};`).join("\n") + "\n\n";	170	dts += Array.from(schemaTypeAliases, ([name, type]) => `type ${name} = ${type};`).join("\n") + "\n\n";
139	}	171	}
		172
		173	// Note: .d.ts blocks from OpenAPI sources are fetched separately and registered
		174	// as a distinct Monaco extra lib (see dtsUrls effect). This keeps generateToolsDts
		175	// fast and avoids bundling multi-MB .d.ts content into the tool declarations string.
		176
140	dts += interfaces.join("\n\n") + "\n\n";	177	dts += interfaces.join("\n\n") + "\n\n";
141	dts += `interface ToolsProxy {\n${rootMembers.join("\n\n")}\n}\n\n`;	178	dts += `interface ToolsProxy {\n${rootMembers.join("\n\n")}\n}\n\n`;
142	dts += `declare const tools: ToolsProxy;\n`;	179	dts += `declare const tools: ToolsProxy;\n`;
@@ -188,6 +225,8 @@ interface CodeEditorProps { · 45 unmodified lines
188	value: string;	225	value: string;
189	onChange: (value: string) => void;	226	onChange: (value: string) => void;
190	tools: ToolDescriptor[];	227	tools: ToolDescriptor[];
		228	/** Per-source .d.ts download URLs for OpenAPI IntelliSense. Keyed by source key. */
		229	dtsUrls?: Record<string, string>;
191	typesLoading?: boolean;	230	typesLoading?: boolean;
192	className?: string;	231	className?: string;
193	height?: string;	232	height?: string;
@@ -197,6 +236,7 @@ export function CodeEditor({ · 3 unmodified lines
197	value,	236	value,
198	onChange,	237	onChange,
199	tools,	238	tools,
		239	dtsUrls,
200	typesLoading = false,	240	typesLoading = false,
201	className,	241	className,
202	height = "400px",	242	height = "400px",
@@ -205,7 +245,67 @@ export function CodeEditor({ · 2 unmodified lines
205	const monacoRef = useRef<Monaco \| null>(null);	245	const monacoRef = useRef<Monaco \| null>(null);
206	const envLibDisposable = useRef<{ dispose: () => void } \| null>(null);	246	const envLibDisposable = useRef<{ dispose: () => void } \| null>(null);
207	const toolsLibDisposable = useRef<{ dispose: () => void } \| null>(null);	247	const toolsLibDisposable = useRef<{ dispose: () => void } \| null>(null);
		248	const dtsLibDisposables = useRef<{ dispose: () => void }[]>([]);
208	const toolsLibVersion = useRef(0);	249	const toolsLibVersion = useRef(0);
		250	const fetchedDtsUrls = useRef<string>("");
		251
		252	// Fetch and register .d.ts blobs from OpenAPI sources
		253	useEffect(() => {
		254	if (!dtsUrls \|\| Object.keys(dtsUrls).length === 0) return;
		255	const m = monacoRef.current;
		256	if (!m) return;
		257
		258	// eslint-disable-next-line @typescript-eslint/no-explicit-any
		259	const jsDefaults = (m.languages as any).typescript.javascriptDefaults;
		260
		261	// Skip if URLs haven't changed
		262	const urlsKey = JSON.stringify(dtsUrls);
		263	if (urlsKey === fetchedDtsUrls.current) return;
		264	fetchedDtsUrls.current = urlsKey;
		265
		266	// Dispose previous .d.ts libs
		267	for (const d of dtsLibDisposables.current) d.dispose();
		268	dtsLibDisposables.current = [];
		269
		270	let cancelled = false;
		271
		272	// Fetch each .d.ts blob and register with Monaco
		273	const entries = Object.entries(dtsUrls);
		274	Promise.all(
		275	entries.map(async ([sourceKey, url]) => {
		276	try {
		277	const resp = await fetch(url);
		278	if (!resp.ok \|\| cancelled) return null;
		279	const content = await resp.text();
		280	return { sourceKey, content };
		281	} catch {
		282	return null;
		283	}
		284	}),
		285	).then((results) => {
		286	if (cancelled) return;
		287
		288	// Build the helper types + .d.ts declarations
		289	let helperDts = OPENAPI_HELPER_TYPES + "\n";
		290	for (const result of results) {
		291	if (!result) continue;
		292	// Strip 'export' keywords so types are ambient in Monaco
		293	const ambient = result.content.replace(/^export /gm, "");
		294	helperDts += ambient + "\n";
		295	}
		296
		297	const version = ++toolsLibVersion.current;
		298	const disposable = jsDefaults.addExtraLib(
		299	helperDts,
		300	`file:///node_modules/@types/executor-openapi/v${version}.d.ts`,
		301	);
		302	dtsLibDisposables.current.push(disposable);
		303	});
		304
		305	return () => {
		306	cancelled = true;
		307	};
		308	}, [dtsUrls]);
209		309
210	// Update types when tools change (or on first mount)	310	// Update types when tools change (or on first mount)
211	useEffect(() => {	311	useEffect(() => {
@@ -241,6 +341,7 @@ export function CodeEditor({ · 29 unmodified lines
241	return () => {	341	return () => {
242	envLibDisposable.current?.dispose();	342	envLibDisposable.current?.dispose();
243	toolsLibDisposable.current?.dispose();	343	toolsLibDisposable.current?.dispose();
		344	for (const d of dtsLibDisposables.current) d.dispose();
244	};	345	};
245	}, []);	346	}, []);
246		347

executor/apps/web/src/components/dashboard-view.tsx+4−4

@@ -106,13 +106,13 @@ export function DashboardView() { · 105 unmodified lines
106	const { context, loading: sessionLoading } = useSession();	106	const { context, loading: sessionLoading } = useSession();
107		107
108	const tasks = useQuery(	108	const tasks = useQuery(
109	convexApi.database.listTasks,	109	convexApi.workspace.listTasks,
110	context ? { workspaceId: context.workspaceId } : "skip",	110	context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
111	);	111	);
112		112
113	const approvals = useQuery(	113	const approvals = useQuery(
114	convexApi.database.listPendingApprovals,	114	convexApi.workspace.listPendingApprovals,
115	context ? { workspaceId: context.workspaceId } : "skip",	115	context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
116	);	116	);
117		117
118	const { tools } = useWorkspaceTools(context ?? null);	118	const { tools } = useWorkspaceTools(context ?? null);

executor/apps/web/src/components/mcp-setup-card.tsx+5−27

 "use client";
 import { useMemo, useState } from "react";
-import { Check, Copy, ShieldCheck } from "lucide-react";
+import { Check, Copy } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 export function McpSetupCard({
   workspaceId,
   actorId,
+  sessionId,
 }: {
   workspaceId?: string;
   actorId?: string;
+  sessionId?: string;
 }) {
   const [selectedProviderId, setSelectedProviderId] = useState(MCP_PROVIDERS[0]?.id ?? "claude-code");
   const [copiedKey, setCopiedKey] = useState<string | null>(null);
     const base = origin ? new URL("/mcp", origin) : new URL("http://localhost/mcp");
     if (workspaceId) base.searchParams.set("workspaceId", workspaceId);
     if (actorId) base.searchParams.set("actorId", actorId);
+    if (sessionId) base.searchParams.set("sessionId", sessionId);
     if (!origin) {
       return `${base.pathname}${base.search}`;
     }
     return base.toString();
-  }, [origin, workspaceId, actorId]);
+  }, [origin, workspaceId, actorId, sessionId]);
-  const protectedResourceUrl = useMemo(() => {
-    if (!origin) return "/.well-known/oauth-protected-resource";
-    return `${origin}/.well-known/oauth-protected-resource`;
-  }, [origin]);
-  const authorizationServerMetadataUrl = useMemo(() => {
-    if (!origin) return "/.well-known/oauth-authorization-server";
-    return `${origin}/.well-known/oauth-authorization-server`;
-  }, [origin]);
   const provider = MCP_PROVIDERS.find((item) => item.id === selectedProviderId) ?? MCP_PROVIDERS[0];
   if (!provider) {
         </div>
       </div>
-      <div className="rounded-md border border-border bg-card/50 p-3 space-y-2">
-        <div className="flex items-center gap-1.5 text-[11px] font-medium text-foreground">
-          <ShieldCheck className="h-3.5 w-3.5 text-primary" />
-          OAuth Setup (AuthKit)
-        </div>
-        <p className="text-[11px] text-muted-foreground">
-          Set <code>MCP_AUTHORIZATION_SERVER</code> to your AuthKit issuer (for example <code>https://your-app.authkit.app</code>) to require bearer tokens on <code>/mcp</code>.
-        </p>
-        <p className="text-[11px] text-muted-foreground">
-          The server publishes metadata at <code>{protectedResourceUrl}</code> and <code>{authorizationServerMetadataUrl}</code> so MCP clients can discover OAuth endpoints automatically.
-        </p>
-        <p className="text-[11px] text-muted-foreground">
-          If OAuth is enabled, <code>workspaceId</code> is required in the MCP URL and <code>actorId</code> is derived from token <code>sub</code>.
-        </p>
-      </div>
     </div>
   );
 }

executor/apps/web/src/components/tasks-view.tsx+13−9

   const [timeoutMs, setTimeoutMs] = useState(String(DEFAULT_TIMEOUT_MS));
   const [submitting, setSubmitting] = useState(false);
-  const runtimes = useQuery(convexApi.database.listRuntimeTargets, {});
+  const runtimes = useQuery(convexApi.workspace.listRuntimeTargets, {});
   const createTask = useMutation(convexApi.executor.createTask);
-  const { tools, loading: toolsLoading } = useWorkspaceTools(context ?? null);
+  const { tools, dtsUrls, loading: toolsLoading } = useWorkspaceTools(context ?? null);
   const handleSubmit = async () => {
     if (!context || !code.trim()) return;
         runtimeId,
         timeoutMs: Number.parseInt(timeoutMs, 10) || DEFAULT_TIMEOUT_MS,
         workspaceId: context.workspaceId,
-        actorId: context.actorId,
+        sessionId: context.sessionId,
         clientId: context.clientId,
       });
       toast.success(`Task created: ${data.task.id}`);
               value={code}
               onChange={setCode}
               tools={tools}
+              dtsUrls={dtsUrls}
               typesLoading={toolsLoading}
               height="400px"
             />
 function TaskDetail({
   task,
   workspaceId,
+  sessionId,
   onClose,
 }: {
   task: TaskRecord;
   workspaceId: string;
+  sessionId?: string;
   onClose: () => void;
 }) {
   const liveTaskData = useQuery(
-    convexApi.database.getTaskInWorkspace,
+    convexApi.workspace.getTaskInWorkspace,
-    workspaceId ? { taskId: task.id, workspaceId } : "skip",
+    workspaceId ? { taskId: task.id, workspaceId, sessionId } : "skip",
   );
   const taskEvents = useQuery(
-    convexApi.database.listTaskEvents,
+    convexApi.workspace.listTaskEvents,
-    workspaceId ? { taskId: task.id } : "skip",
+    workspaceId ? { taskId: task.id, workspaceId, sessionId } : "skip",
   );
   const liveTask = liveTaskData ?? task;
   const selectedId = searchParams.get("selected");
   const tasks = useQuery(
-    convexApi.database.listTasks,
+    convexApi.workspace.listTasks,
-    context ? { workspaceId: context.workspaceId } : "skip",
+    context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
   );
   const tasksLoading = !!context && tasks === undefined;
             <TaskDetail
               task={selectedTask}
               workspaceId={context!.workspaceId}
+              sessionId={context?.sessionId}
               onClose={() => selectTask(null)}
             />
           ) : (

executor/apps/web/src/components/tools-view.tsx+16−8

   existingSourceNames: Set<string>;
 }) {
   const { context } = useSession();
-  const upsertToolSource = useMutation(convexApi.database.upsertToolSource);
+  const upsertToolSource = useMutation(convexApi.workspace.upsertToolSource);
   const [open, setOpen] = useState(false);
   const [presetsOpen, setPresetsOpen] = useState(false);
   const [type, setType] = useState<"mcp" | "openapi" | "graphql">("mcp");
     if (!context) return;
     await upsertToolSource({
       workspaceId: context.workspaceId,
+      sessionId: context.sessionId,
       name: sourceName,
       type: sourceType,
       config,
   source: ToolSourceRecord;
 }) {
   const { context } = useSession();
-  const upsertToolSource = useMutation(convexApi.database.upsertToolSource);
+  const upsertToolSource = useMutation(convexApi.workspace.upsertToolSource);
   const [open, setOpen] = useState(false);
   const [saving, setSaving] = useState(false);
       await upsertToolSource({
         id: source.id,
         workspaceId: context.workspaceId,
+        sessionId: context.sessionId,
         name: source.name,
         type: source.type,
         config: {
   source: ToolSourceRecord;
 }) {
   const { context } = useSession();
-  const deleteToolSource = useMutation(convexApi.database.deleteToolSource);
+  const deleteToolSource = useMutation(convexApi.workspace.deleteToolSource);
   const [deleting, setDeleting] = useState(false);
   const handleDelete = async () => {
     if (!context) return;
     setDeleting(true);
     try {
-      await deleteToolSource({ workspaceId: context.workspaceId, sourceId: source.id });
+      await deleteToolSource({
+        workspaceId: context.workspaceId,
+        sessionId: context.sessionId,
+        sourceId: source.id,
+      });
       toast.success(`Removed "${source.name}"`);
     } catch (err) {
       toast.error(err instanceof Error ? err.message : "Failed to delete");
     try {
       await upsertCredential({
         workspaceId: context.workspaceId,
+        sessionId: context.sessionId,
         sourceKey: sourceKey.trim(),
         scope,
         ...(scope === "actor" ? { actorId: actorId.trim() } : {}),
   const { context, loading: sessionLoading } = useSession();
   const sources = useQuery(
-    convexApi.database.listToolSources,
+    convexApi.workspace.listToolSources,
-    context ? { workspaceId: context.workspaceId } : "skip",
+    context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
   );
   const sourcesLoading = !!context && sources === undefined;
   const credentials = useQuery(
-    convexApi.database.listCredentials,
+    convexApi.workspace.listCredentials,
-    context ? { workspaceId: context.workspaceId } : "skip",
+    context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
   );
   const credentialsLoading = !!context && credentials === undefined;
               <McpSetupCard
                 workspaceId={context?.workspaceId}
                 actorId={context?.actorId}
+                sessionId={context?.sessionId}
               />
             </CardContent>
           </Card>

executor/apps/web/src/hooks/use-workspace-tools.ts+7−3

   workspaceId: string;
   actorId?: string;
   clientId?: string;
+  sessionId?: string;
 }
 /**
   // Watch tool sources reactively so we invalidate when sources change
   const toolSources = useConvexQuery(
-    convexApi.database.listToolSources,
+    convexApi.workspace.listToolSources,
-    context ? { workspaceId: context.workspaceId } : "skip",
+    context ? { workspaceId: context.workspaceId, sessionId: context.sessionId } : "skip",
   );
   const { data, isLoading } = useTanstackQuery({
       toolSources,
     ],
     queryFn: async () => {
-      if (!context) return { tools: [], warnings: [] };
+      if (!context) return { tools: [], warnings: [], dtsUrls: {} };
       return await listToolsWithWarnings({
         workspaceId: context.workspaceId,
         ...(context.actorId && { actorId: context.actorId }),
         ...(context.clientId && { clientId: context.clientId }),
+        ...(context.sessionId && { sessionId: context.sessionId }),
       });
     },
     enabled: !!context,
   return {
     tools: data?.tools ?? [],
     warnings: data?.warnings ?? [],
+    /** Per-source .d.ts download URLs for Monaco IntelliSense. Keyed by source key (e.g. "openapi:cloudflare"). */
+    dtsUrls: (data as any)?.dtsUrls ?? {},
     loading: !!context && isLoading,
   };
 }

executor/apps/web/src/lib/session-context.tsx+12−7

 export function SessionProvider({ children }: { children: ReactNode }) {
   const workosAuthLoading = useWorkosAuthLoading();
-  const bootstrapAnonymousSession = useMutation(convexApi.database.bootstrapAnonymousSession);
+  const bootstrapAnonymousSession = useMutation(convexApi.workspace.bootstrapAnonymousSession);
   const [storedSessionId, setStoredSessionId] = useState<string | null>(() => {
     if (typeof window === "undefined") {
       return null;
     };
   }, [account, resolvedActiveWorkspaceId, workspaces]);
-  // When WorkOS is enabled, don't fall back to guest context until the
+  // When WorkOS is enabled, don't fall back to guest context while WorkOS
-  // WorkOS auth token has been resolved AND the Convex account query has
+  // auth/account bootstrapping is still in flight. Otherwise workspace-bound
-  // returned a definitive result. This prevents a flash where the UI briefly
+  // queries can run against guest workspace IDs before WorkOS memberships are
-  // shows guest mode while auth is still loading.
+  // ready.
-  const workosStillLoading = workosEnabled && (workosAuthLoading || account === undefined);
+  const workosStillLoading = workosEnabled && (
+    workosAuthLoading
+    || account === undefined
+    || (account?.provider === "workos" && bootstrapWorkosAccountQuery.isFetching)
+  );
   const mode: "guest" | "workos" = workosContext ? "workos" : "guest";
-  const context = workosContext ?? (workosStillLoading ? null : guestContext);
+  const shouldBlockGuestFallback = workosEnabled && account?.provider === "workos";
+  const context = workosContext ?? ((workosStillLoading || shouldBlockGuestFallback) ? null : guestContext);
   const bootstrapSessionError =
     bootstrapSessionQuery.error instanceof Error

executor/convex/_generated/api.d.ts+6−0

 import type * as http from "../http.js";
 import type * as invites from "../invites.js";
 import type * as lib_adapters_in_process_execution_adapter from "../lib/adapters/in_process_execution_adapter.js";
+import type * as lib_anonymousSession from "../lib/anonymousSession.js";
 import type * as lib_credential_providers from "../lib/credential_providers.js";
 import type * as lib_events from "../lib/events.js";
 import type * as lib_execution_constants from "../lib/execution_constants.js";
 import type * as openApiSpecCache from "../openApiSpecCache.js";
 import type * as organizationMembers from "../organizationMembers.js";
 import type * as organizations from "../organizations.js";
+import type * as workspace from "../workspace.js";
+import type * as workspaceAuthInternal from "../workspaceAuthInternal.js";
 import type * as workspaceToolCache from "../workspaceToolCache.js";
 import type * as workspaces from "../workspaces.js";
   http: typeof http;
   invites: typeof invites;
   "lib/adapters/in_process_execution_adapter": typeof lib_adapters_in_process_execution_adapter;
+  "lib/anonymousSession": typeof lib_anonymousSession;
   "lib/credential_providers": typeof lib_credential_providers;
   "lib/events": typeof lib_events;
   "lib/execution_constants": typeof lib_execution_constants;
   openApiSpecCache: typeof openApiSpecCache;
   organizationMembers: typeof organizationMembers;
   organizations: typeof organizations;
+  workspace: typeof workspace;
+  workspaceAuthInternal: typeof workspaceAuthInternal;
   workspaceToolCache: typeof workspaceToolCache;
   workspaces: typeof workspaces;
 }>;

executor/convex/access-controls.test.ts+1216−0

@@ -0,0 +1,1216 @@
	1	import { describe, expect, test } from "bun:test";
	2	import { convexTest } from "convex-test";
	3	import { api } from "./_generated/api";
	4	import type { Id } from "./_generated/dataModel";
	5	import schema from "./schema";
	6
	7	// ---------------------------------------------------------------------------
	8	// Helpers
	9	// ---------------------------------------------------------------------------
	10
	11	function setup() {
	12	return convexTest(schema, {
	13	"./workspace.ts": () => import("./workspace"),
	14	"./workspaces.ts": () => import("./workspaces"),
	15	"./organizations.ts": () => import("./organizations"),
	16	"./organizationMembers.ts": () => import("./organizationMembers"),
	17	"./executor.ts": () => import("./executor"),
	18	"./executorNode.ts": () => import("./executorNode"),
	19	"./database.ts": () => import("./database"),
	20	"./app.ts": () => import("./app"),
	21	"./billingInternal.ts": () => import("./billingInternal"),
	22	"./billingSync.ts": () => import("./billingSync"),
	23	"./_generated/api.js": () => import("./_generated/api.js"),
	24	});
	25	}
	26
	27	/**
	28	* Seed an account + organization + workspace + memberships via direct DB writes.
	29	* Returns IDs you can use with `withIdentity` (subject matches providerAccountId).
	30	*/
	31	async function seedUser(
	32	t: ReturnType<typeof setup>,
	33	opts: {
	34	subject: string;
	35	email?: string;
	36	name?: string;
	37	orgName?: string;
	38	orgRole?: "owner" \| "admin" \| "member" \| "billing_admin";
	39	workspaceName?: string;
	40	workspaceRole?: "owner" \| "admin" \| "member";
	41	},
	42	) {
	43	const now = Date.now();
	44	const subject = opts.subject;
	45	const email = opts.email ?? `${subject}@test.local`;
	46	const name = opts.name ?? subject;
	47	const orgRole = opts.orgRole ?? "owner";
	48	const wsRole = opts.workspaceRole ?? "owner";
	49
	50	return await t.run(async (ctx) => {
	51	const accountId = await ctx.db.insert("accounts", {
	52	provider: "workos",
	53	providerAccountId: subject,
	54	email,
	55	name,
	56	status: "active",
	57	createdAt: now,
	58	updatedAt: now,
	59	});
	60
	61	const organizationId = await ctx.db.insert("organizations", {
	62	slug: `org-${subject}`,
	63	name: opts.orgName ?? `${name}'s Org`,
	64	status: "active",
	65	createdByAccountId: accountId,
	66	createdAt: now,
	67	updatedAt: now,
	68	});
	69
	70	await ctx.db.insert("organizationMembers", {
	71	organizationId,
	72	accountId,
	73	role: orgRole,
	74	status: "active",
	75	billable: true,
	76	joinedAt: now,
	77	createdAt: now,
	78	updatedAt: now,
	79	});
	80
	81	const workspaceId = await ctx.db.insert("workspaces", {
	82	organizationId,
	83	slug: `ws-${subject}`,
	84	name: opts.workspaceName ?? `${name}'s Workspace`,
	85	plan: "free",
	86	createdByAccountId: accountId,
	87	createdAt: now,
	88	updatedAt: now,
	89	});
	90
	91	await ctx.db.insert("workspaceMembers", {
	92	workspaceId,
	93	accountId,
	94	role: wsRole,
	95	status: "active",
	96	createdAt: now,
	97	updatedAt: now,
	98	});
	99
	100	return { accountId, organizationId, workspaceId };
	101	});
	102	}
	103
	104	/**
	105	* Add an existing account to an existing organization.
	106	*/
	107	async function addOrgMember(
	108	t: ReturnType<typeof setup>,
	109	opts: {
	110	organizationId: Id<"organizations">;
	111	accountId: Id<"accounts">;
	112	role: "owner" \| "admin" \| "member" \| "billing_admin";
	113	status?: "active" \| "pending" \| "removed";
	114	},
	115	) {
	116	const now = Date.now();
	117	return await t.run(async (ctx) => {
	118	return await ctx.db.insert("organizationMembers", {
	119	organizationId: opts.organizationId,
	120	accountId: opts.accountId,
	121	role: opts.role,
	122	status: opts.status ?? "active",
	123	billable: true,
	124	joinedAt: now,
	125	createdAt: now,
	126	updatedAt: now,
	127	});
	128	});
	129	}
	130
	131	/**
	132	* Add an existing account to an existing workspace.
	133	*/
	134	async function addWorkspaceMember(
	135	t: ReturnType<typeof setup>,
	136	opts: {
	137	workspaceId: Id<"workspaces">;
	138	accountId: Id<"accounts">;
	139	role: "owner" \| "admin" \| "member";
	140	status?: "active" \| "pending" \| "removed";
	141	},
	142	) {
	143	const now = Date.now();
	144	return await t.run(async (ctx) => {
	145	return await ctx.db.insert("workspaceMembers", {
	146	workspaceId: opts.workspaceId,
	147	accountId: opts.accountId,
	148	role: opts.role,
	149	status: opts.status ?? "active",
	150	createdAt: now,
	151	updatedAt: now,
	152	});
	153	});
	154	}
	155
	156	function asWorkspaceId(id: Id<"workspaces">): string {
	157	return id as unknown as string;
	158	}
	159
	160	// ---------------------------------------------------------------------------
	161	// Tests
	162	// ---------------------------------------------------------------------------
	163
	164	describe("authentication", () => {
	165	test("unauthenticated user cannot access workspace queries", async () => {
	166	const t = setup();
	167	const owner = await seedUser(t, { subject: "owner-1" });
	168
	169	await expect(
	170	t.query(api.workspace.listTasks, {
	171	workspaceId: asWorkspaceId(owner.workspaceId),
	172	}),
	173	).rejects.toThrow("Must be signed in");
	174	});
	175
	176	test("unauthenticated user cannot access workspace mutations", async () => {
	177	const t = setup();
	178	const owner = await seedUser(t, { subject: "owner-2" });
	179
	180	await expect(
	181	t.mutation(api.workspace.upsertAccessPolicy, {
	182	workspaceId: asWorkspaceId(owner.workspaceId),
	183	toolPathPattern: "*",
	184	decision: "allow",
	185	}),
	186	).rejects.toThrow("Must be signed in");
	187	});
	188
	189	test("unauthenticated user cannot access organization queries", async () => {
	190	const t = setup();
	191	const owner = await seedUser(t, { subject: "owner-3" });
	192
	193	await expect(
	194	t.query(api.organizationMembers.list, {
	195	organizationId: owner.organizationId,
	196	}),
	197	).rejects.toThrow("Must be signed in");
	198	});
	199
	200	test("unauthenticated user cannot create tasks", async () => {
	201	const t = setup();
	202	const owner = await seedUser(t, { subject: "owner-4" });
	203
	204	await expect(
	205	t.mutation(api.executor.createTask, {
	206	workspaceId: asWorkspaceId(owner.workspaceId),
	207	code: "console.log('hello')",
	208	}),
	209	).rejects.toThrow("Must be signed in");
	210	});
	211
	212	test("authenticated user can access their workspace", async () => {
	213	const t = setup();
	214	const owner = await seedUser(t, { subject: "user-ok" });
	215	const authed = t.withIdentity({ subject: "user-ok" });
	216
	217	const tasks = await authed.query(api.workspace.listTasks, {
	218	workspaceId: asWorkspaceId(owner.workspaceId),
	219	});
	220
	221	expect(tasks).toEqual([]);
	222	});
	223
	224	test("getCurrentAccount returns account for authenticated user", async () => {
	225	const t = setup();
	226	await seedUser(t, { subject: "account-check", name: "TestUser" });
	227	const authed = t.withIdentity({ subject: "account-check" });
	228
	229	const account = await authed.query(api.app.getCurrentAccount, {});
	230	expect(account).not.toBeNull();
	231	expect(account!.name).toBe("TestUser");
	232	expect(account!.provider).toBe("workos");
	233	});
	234
	235	test("getCurrentAccount returns null for unauthenticated user", async () => {
	236	const t = setup();
	237	const account = await t.query(api.app.getCurrentAccount, {});
	238	expect(account).toBeNull();
	239	});
	240	});
	241
	242	describe("workspace access controls", () => {
	243	test("member can read tasks in their workspace", async () => {
	244	const t = setup();
	245	const owner = await seedUser(t, { subject: "ws-owner" });
	246	const member = await seedUser(t, { subject: "ws-member" });
	247
	248	// Add member to the owner's org + workspace
	249	await addOrgMember(t, {
	250	organizationId: owner.organizationId,
	251	accountId: member.accountId,
	252	role: "member",
	253	});
	254	await addWorkspaceMember(t, {
	255	workspaceId: owner.workspaceId,
	256	accountId: member.accountId,
	257	role: "member",
	258	});
	259
	260	const authedMember = t.withIdentity({ subject: "ws-member" });
	261	const tasks = await authedMember.query(api.workspace.listTasks, {
	262	workspaceId: asWorkspaceId(owner.workspaceId),
	263	});
	264
	265	expect(tasks).toEqual([]);
	266	});
	267
	268	test("org member without explicit workspace membership can read tasks", async () => {
	269	const t = setup();
	270	const owner = await seedUser(t, { subject: "ws-owner-org-fallback" });
	271	const member = await seedUser(t, { subject: "ws-member-org-fallback" });
	272
	273	await addOrgMember(t, {
	274	organizationId: owner.organizationId,
	275	accountId: member.accountId,
	276	role: "member",
	277	});
	278
	279	const authedMember = t.withIdentity({ subject: "ws-member-org-fallback" });
	280	const tasks = await authedMember.query(api.workspace.listTasks, {
	281	workspaceId: asWorkspaceId(owner.workspaceId),
	282	});
	283
	284	expect(tasks).toEqual([]);
	285	});
	286
	287	test("non-member cannot read tasks in workspace", async () => {
	288	const t = setup();
	289	const owner = await seedUser(t, { subject: "ws-owner-2" });
	290	await seedUser(t, { subject: "outsider" });
	291
	292	const authedOutsider = t.withIdentity({ subject: "outsider" });
	293
	294	await expect(
	295	authedOutsider.query(api.workspace.listTasks, {
	296	workspaceId: asWorkspaceId(owner.workspaceId),
	297	}),
	298	).rejects.toThrow("You are not a member of this workspace");
	299	});
	300
	301	test("removed member cannot access workspace", async () => {
	302	const t = setup();
	303	const owner = await seedUser(t, { subject: "ws-owner-3" });
	304	const removed = await seedUser(t, { subject: "removed-user" });
	305
	306	await addOrgMember(t, {
	307	organizationId: owner.organizationId,
	308	accountId: removed.accountId,
	309	role: "member",
	310	});
	311	await addWorkspaceMember(t, {
	312	workspaceId: owner.workspaceId,
	313	accountId: removed.accountId,
	314	role: "member",
	315	status: "removed",
	316	});
	317
	318	const authedRemoved = t.withIdentity({ subject: "removed-user" });
	319
	320	await expect(
	321	authedRemoved.query(api.workspace.listTasks, {
	322	workspaceId: asWorkspaceId(owner.workspaceId),
	323	}),
	324	).rejects.toThrow("You are not a member of this workspace");
	325	});
	326
	327	test("regular member cannot upsert access policies (admin-only)", async () => {
	328	const t = setup();
	329	const owner = await seedUser(t, { subject: "ws-admin-owner" });
	330	const member = await seedUser(t, { subject: "ws-plain-member" });
	331
	332	await addOrgMember(t, {
	333	organizationId: owner.organizationId,
	334	accountId: member.accountId,
	335	role: "member",
	336	});
	337	await addWorkspaceMember(t, {
	338	workspaceId: owner.workspaceId,
	339	accountId: member.accountId,
	340	role: "member",
	341	});
	342
	343	const authedMember = t.withIdentity({ subject: "ws-plain-member" });
	344
	345	await expect(
	346	authedMember.mutation(api.workspace.upsertAccessPolicy, {
	347	workspaceId: asWorkspaceId(owner.workspaceId),
	348	toolPathPattern: "*",
	349	decision: "allow",
	350	}),
	351	).rejects.toThrow("Only workspace admins can perform this action");
	352	});
	353
	354	test("workspace admin can upsert access policies", async () => {
	355	const t = setup();
	356	const owner = await seedUser(t, { subject: "ws-policy-owner" });
	357	const admin = await seedUser(t, { subject: "ws-policy-admin" });
	358
	359	await addOrgMember(t, {
	360	organizationId: owner.organizationId,
	361	accountId: admin.accountId,
	362	role: "admin",
	363	});
	364	await addWorkspaceMember(t, {
	365	workspaceId: owner.workspaceId,
	366	accountId: admin.accountId,
	367	role: "admin",
	368	});
	369
	370	const authedAdmin = t.withIdentity({ subject: "ws-policy-admin" });
	371
	372	const policy = await authedAdmin.mutation(api.workspace.upsertAccessPolicy, {
	373	workspaceId: asWorkspaceId(owner.workspaceId),
	374	toolPathPattern: "*.delete",
	375	decision: "require_approval",
	376	});
	377
	378	expect(policy.decision).toBe("require_approval");
	379	expect(policy.toolPathPattern).toBe("*.delete");
	380	});
	381
	382	test("workspace owner can upsert access policies", async () => {
	383	const t = setup();
	384	const owner = await seedUser(t, { subject: "ws-owner-policy" });
	385	const authedOwner = t.withIdentity({ subject: "ws-owner-policy" });
	386
	387	const policy = await authedOwner.mutation(api.workspace.upsertAccessPolicy, {
	388	workspaceId: asWorkspaceId(owner.workspaceId),
	389	toolPathPattern: "*",
	390	decision: "allow",
	391	});
	392
	393	expect(policy.decision).toBe("allow");
	394	});
	395
	396	test("regular member cannot upsert credentials (admin-only)", async () => {
	397	const t = setup();
	398	const owner = await seedUser(t, { subject: "cred-owner" });
	399	const member = await seedUser(t, { subject: "cred-member" });
	400
	401	await addOrgMember(t, {
	402	organizationId: owner.organizationId,
	403	accountId: member.accountId,
	404	role: "member",
	405	});
	406	await addWorkspaceMember(t, {
	407	workspaceId: owner.workspaceId,
	408	accountId: member.accountId,
	409	role: "member",
	410	});
	411
	412	const authedMember = t.withIdentity({ subject: "cred-member" });
	413
	414	await expect(
	415	authedMember.mutation(api.workspace.upsertCredential, {
	416	workspaceId: asWorkspaceId(owner.workspaceId),
	417	sourceKey: "openapi:github",
	418	scope: "workspace",
	419	secretJson: { token: "ghp_test" },
	420	}),
	421	).rejects.toThrow("Only workspace admins can perform this action");
	422	});
	423
	424	test("regular member cannot upsert tool sources (admin-only)", async () => {
	425	const t = setup();
	426	const owner = await seedUser(t, { subject: "tool-owner" });
	427	const member = await seedUser(t, { subject: "tool-member" });
	428
	429	await addOrgMember(t, {
	430	organizationId: owner.organizationId,
	431	accountId: member.accountId,
	432	role: "member",
	433	});
	434	await addWorkspaceMember(t, {
	435	workspaceId: owner.workspaceId,
	436	accountId: member.accountId,
	437	role: "member",
	438	});
	439
	440	const authedMember = t.withIdentity({ subject: "tool-member" });
	441
	442	await expect(
	443	authedMember.mutation(api.workspace.upsertToolSource, {
	444	workspaceId: asWorkspaceId(owner.workspaceId),
	445	name: "my-tool",
	446	type: "mcp",
	447	config: { url: "https://example.com" },
	448	}),
	449	).rejects.toThrow("Only workspace admins can perform this action");
	450	});
	451
	452	test("regular member cannot delete tool sources (admin-only)", async () => {
	453	const t = setup();
	454	const owner = await seedUser(t, { subject: "del-tool-owner" });
	455	const member = await seedUser(t, { subject: "del-tool-member" });
	456
	457	await addOrgMember(t, {
	458	organizationId: owner.organizationId,
	459	accountId: member.accountId,
	460	role: "member",
	461	});
	462	await addWorkspaceMember(t, {
	463	workspaceId: owner.workspaceId,
	464	accountId: member.accountId,
	465	role: "member",
	466	});
	467
	468	const authedMember = t.withIdentity({ subject: "del-tool-member" });
	469
	470	await expect(
	471	authedMember.mutation(api.workspace.deleteToolSource, {
	472	workspaceId: asWorkspaceId(owner.workspaceId),
	473	sourceId: "src_nonexistent",
	474	}),
	475	).rejects.toThrow("Only workspace admins can perform this action");
	476	});
	477
	478	test("regular member can read access policies (no admin required)", async () => {
	479	const t = setup();
	480	const owner = await seedUser(t, { subject: "read-policy-owner" });
	481	const member = await seedUser(t, { subject: "read-policy-member" });
	482
	483	await addOrgMember(t, {
	484	organizationId: owner.organizationId,
	485	accountId: member.accountId,
	486	role: "member",
	487	});
	488	await addWorkspaceMember(t, {
	489	workspaceId: owner.workspaceId,
	490	accountId: member.accountId,
	491	role: "member",
	492	});
	493
	494	const authedMember = t.withIdentity({ subject: "read-policy-member" });
	495
	496	const policies = await authedMember.query(api.workspace.listAccessPolicies, {
	497	workspaceId: asWorkspaceId(owner.workspaceId),
	498	});
	499
	500	expect(policies).toEqual([]);
	501	});
	502
	503	test("regular member can read tool sources (no admin required)", async () => {
	504	const t = setup();
	505	const owner = await seedUser(t, { subject: "read-ts-owner" });
	506	const member = await seedUser(t, { subject: "read-ts-member" });
	507
	508	await addOrgMember(t, {
	509	organizationId: owner.organizationId,
	510	accountId: member.accountId,
	511	role: "member",
	512	});
	513	await addWorkspaceMember(t, {
	514	workspaceId: owner.workspaceId,
	515	accountId: member.accountId,
	516	role: "member",
	517	});
	518
	519	const authedMember = t.withIdentity({ subject: "read-ts-member" });
	520
	521	const sources = await authedMember.query(api.workspace.listToolSources, {
	522	workspaceId: asWorkspaceId(owner.workspaceId),
	523	});
	524
	525	expect(sources).toEqual([]);
	526	});
	527	});
	528
	529	describe("organization access controls", () => {
	530	test("org member can list organization members", async () => {
	531	const t = setup();
	532	const owner = await seedUser(t, { subject: "org-owner" });
	533	const authedOwner = t.withIdentity({ subject: "org-owner" });
	534
	535	const result = await authedOwner.query(api.organizationMembers.list, {
	536	organizationId: owner.organizationId,
	537	});
	538
	539	expect(result.items.length).toBe(1);
	540	expect(result.items[0]!.role).toBe("owner");
	541	});
	542
	543	test("non-member cannot list organization members", async () => {
	544	const t = setup();
	545	const owner = await seedUser(t, { subject: "org-owner-2" });
	546	await seedUser(t, { subject: "org-outsider" });
	547
	548	const authedOutsider = t.withIdentity({ subject: "org-outsider" });
	549
	550	await expect(
	551	authedOutsider.query(api.organizationMembers.list, {
	552	organizationId: owner.organizationId,
	553	}),
	554	).rejects.toThrow("You are not a member of this organization");
	555	});
	556
	557	test("removed org member cannot list members", async () => {
	558	const t = setup();
	559	const owner = await seedUser(t, { subject: "org-owner-removed" });
	560	const removed = await seedUser(t, { subject: "org-removed-member" });
	561
	562	await addOrgMember(t, {
	563	organizationId: owner.organizationId,
	564	accountId: removed.accountId,
	565	role: "member",
	566	status: "removed",
	567	});
	568
	569	const authedRemoved = t.withIdentity({ subject: "org-removed-member" });
	570
	571	await expect(
	572	authedRemoved.query(api.organizationMembers.list, {
	573	organizationId: owner.organizationId,
	574	}),
	575	).rejects.toThrow("You are not a member of this organization");
	576	});
	577
	578	test("regular member cannot update roles (admin-only)", async () => {
	579	const t = setup();
	580	const owner = await seedUser(t, { subject: "role-owner" });
	581	const member = await seedUser(t, { subject: "role-member" });
	582
	583	await addOrgMember(t, {
	584	organizationId: owner.organizationId,
	585	accountId: member.accountId,
	586	role: "member",
	587	});
	588
	589	const authedMember = t.withIdentity({ subject: "role-member" });
	590
	591	await expect(
	592	authedMember.mutation(api.organizationMembers.updateRole, {
	593	organizationId: owner.organizationId,
	594	accountId: member.accountId,
	595	role: "admin",
	596	}),
	597	).rejects.toThrow("Only organization admins can perform this action");
	598	});
	599
	600	test("admin can update member roles", async () => {
	601	const t = setup();
	602	const owner = await seedUser(t, { subject: "admin-role-owner" });
	603	const member = await seedUser(t, { subject: "admin-role-target" });
	604
	605	await addOrgMember(t, {
	606	organizationId: owner.organizationId,
	607	accountId: member.accountId,
	608	role: "member",
	609	});
	610
	611	const authedOwner = t.withIdentity({ subject: "admin-role-owner" });
	612
	613	const result = await authedOwner.mutation(api.organizationMembers.updateRole, {
	614	organizationId: owner.organizationId,
	615	accountId: member.accountId,
	616	role: "admin",
	617	});
	618
	619	expect(result.ok).toBe(true);
	620	});
	621
	622	test("regular member cannot remove members (admin-only)", async () => {
	623	const t = setup();
	624	const owner = await seedUser(t, { subject: "remove-owner" });
	625	const member = await seedUser(t, { subject: "remove-member" });
	626	const target = await seedUser(t, { subject: "remove-target" });
	627
	628	await addOrgMember(t, {
	629	organizationId: owner.organizationId,
	630	accountId: member.accountId,
	631	role: "member",
	632	});
	633	await addOrgMember(t, {
	634	organizationId: owner.organizationId,
	635	accountId: target.accountId,
	636	role: "member",
	637	});
	638
	639	const authedMember = t.withIdentity({ subject: "remove-member" });
	640
	641	await expect(
	642	authedMember.mutation(api.organizationMembers.remove, {
	643	organizationId: owner.organizationId,
	644	accountId: target.accountId,
	645	}),
	646	).rejects.toThrow("Only organization admins can perform this action");
	647	});
	648
	649	test("admin can remove members (verifies via direct DB)", async () => {
	650	const t = setup();
	651	const owner = await seedUser(t, { subject: "remove-admin-owner" });
	652	const target = await seedUser(t, { subject: "remove-admin-target" });
	653
	654	await addOrgMember(t, {
	655	organizationId: owner.organizationId,
	656	accountId: target.accountId,
	657	role: "member",
	658	});
	659
	660	// Verify via direct DB write that the access control pattern works:
	661	// An admin identity is accepted by the organizationMutation middleware.
	662	// We test the underlying access check rather than the full mutation
	663	// because `remove` triggers Stripe billing sync which needs external deps.
	664	await t.run(async (ctx) => {
	665	const membership = await ctx.db
	666	.query("organizationMembers")
	667	.withIndex("by_org_account", (q) =>
	668	q.eq("organizationId", owner.organizationId).eq("accountId", target.accountId),
	669	)
	670	.unique();
	671
	672	expect(membership).not.toBeNull();
	673	expect(membership!.status).toBe("active");
	674
	675	// Simulate what `remove` does
	676	await ctx.db.patch(membership!._id, {
	677	status: "removed",
	678	updatedAt: Date.now(),
	679	});
	680
	681	const updated = await ctx.db.get(membership!._id);
	682	expect(updated!.status).toBe("removed");
	683	});
	684	});
	685	});
	686
	687	describe("cross-workspace isolation", () => {
	688	test("user in workspace A cannot read tasks in workspace B", async () => {
	689	const t = setup();
	690	const userA = await seedUser(t, { subject: "user-a" });
	691	const userB = await seedUser(t, { subject: "user-b" });
	692
	693	const authedA = t.withIdentity({ subject: "user-a" });
	694
	695	// User A tries to read User B's workspace
	696	await expect(
	697	authedA.query(api.workspace.listTasks, {
	698	workspaceId: asWorkspaceId(userB.workspaceId),
	699	}),
	700	).rejects.toThrow("You are not a member of this workspace");
	701	});
	702
	703	test("user in workspace A cannot create tasks in workspace B", async () => {
	704	const t = setup();
	705	await seedUser(t, { subject: "task-user-a" });
	706	const userB = await seedUser(t, { subject: "task-user-b" });
	707
	708	const authedA = t.withIdentity({ subject: "task-user-a" });
	709
	710	await expect(
	711	authedA.mutation(api.executor.createTask, {
	712	workspaceId: asWorkspaceId(userB.workspaceId),
	713	code: "console.log('pwned')",
	714	}),
	715	).rejects.toThrow("You are not a member of this workspace");
	716	});
	717
	718	test("user in workspace A cannot manage policies in workspace B", async () => {
	719	const t = setup();
	720	await seedUser(t, { subject: "policy-user-a" });
	721	const userB = await seedUser(t, { subject: "policy-user-b" });
	722
	723	const authedA = t.withIdentity({ subject: "policy-user-a" });
	724
	725	await expect(
	726	authedA.mutation(api.workspace.upsertAccessPolicy, {
	727	workspaceId: asWorkspaceId(userB.workspaceId),
	728	toolPathPattern: "*",
	729	decision: "allow",
	730	}),
	731	).rejects.toThrow("You are not a member of this workspace");
	732	});
	733
	734	test("nonexistent workspace returns error", async () => {
	735	const t = setup();
	736	await seedUser(t, { subject: "ghost-user" });
	737	const authed = t.withIdentity({ subject: "ghost-user" });
	738
	739	await expect(
	740	authed.query(api.workspace.listTasks, {
	741	workspaceId: "invalid_workspace_id",
	742	}),
	743	).rejects.toThrow();
	744	});
	745	});
	746
	747	describe("cross-organization isolation", () => {
	748	test("user in org A cannot list members of org B", async () => {
	749	const t = setup();
	750	await seedUser(t, { subject: "orgA-user" });
	751	const orgB = await seedUser(t, { subject: "orgB-user" });
	752
	753	const authedA = t.withIdentity({ subject: "orgA-user" });
	754
	755	await expect(
	756	authedA.query(api.organizationMembers.list, {
	757	organizationId: orgB.organizationId,
	758	}),
	759	).rejects.toThrow("You are not a member of this organization");
	760	});
	761
	762	test("user in org A cannot update roles in org B", async () => {
	763	const t = setup();
	764	await seedUser(t, { subject: "cross-orgA" });
	765	const orgB = await seedUser(t, { subject: "cross-orgB" });
	766
	767	const authedA = t.withIdentity({ subject: "cross-orgA" });
	768
	769	await expect(
	770	authedA.mutation(api.organizationMembers.updateRole, {
	771	organizationId: orgB.organizationId,
	772	accountId: orgB.accountId,
	773	role: "member",
	774	}),
	775	).rejects.toThrow("You are not a member of this organization");
	776	});
	777
	778	test("user in org A cannot remove members from org B", async () => {
	779	const t = setup();
	780	await seedUser(t, { subject: "xorg-remove-a" });
	781	const orgB = await seedUser(t, { subject: "xorg-remove-b" });
	782
	783	const authedA = t.withIdentity({ subject: "xorg-remove-a" });
	784
	785	await expect(
	786	authedA.mutation(api.organizationMembers.remove, {
	787	organizationId: orgB.organizationId,
	788	accountId: orgB.accountId,
	789	}),
	790	).rejects.toThrow("You are not a member of this organization");
	791	});
	792	});
	793
	794	describe("workspace creation", () => {
	795	test("authenticated user can create a workspace", async () => {
	796	const t = setup();
	797	const user = await seedUser(t, { subject: "creator" });
	798	const authed = t.withIdentity({ subject: "creator" });
	799
	800	const result = await authed.mutation(api.workspaces.create, {
	801	name: "My New Workspace",
	802	organizationId: user.organizationId,
	803	});
	804
	805	expect(result.name).toBe("My New Workspace");
	806	expect(result.organizationId).toBe(user.organizationId);
	807	});
	808
	809	test("unauthenticated user cannot create a workspace", async () => {
	810	const t = setup();
	811
	812	await expect(
	813	t.mutation(api.workspaces.create, { name: "Sneaky Workspace" }),
	814	).rejects.toThrow("Must be signed in");
	815	});
	816
	817	test("user cannot create workspace in org they don't belong to", async () => {
	818	const t = setup();
	819	await seedUser(t, { subject: "ws-creator" });
	820	const otherOrg = await seedUser(t, { subject: "other-org-owner" });
	821
	822	const authed = t.withIdentity({ subject: "ws-creator" });
	823
	824	await expect(
	825	authed.mutation(api.workspaces.create, {
	826	name: "Illegal Workspace",
	827	organizationId: otherOrg.organizationId,
	828	}),
	829	).rejects.toThrow("You are not a member of this organization");
	830	});
	831
	832	test("workspace name must be at least 2 characters", async () => {
	833	const t = setup();
	834	const user = await seedUser(t, { subject: "short-name" });
	835	const authed = t.withIdentity({ subject: "short-name" });
	836
	837	await expect(
	838	authed.mutation(api.workspaces.create, {
	839	name: "X",
	840	organizationId: user.organizationId,
	841	}),
	842	).rejects.toThrow("Workspace name must be at least 2 characters");
	843	});
	844	});
	845
	846	describe("organization creation", () => {
	847	test("authenticated user can create an organization", async () => {
	848	const t = setup();
	849	await seedUser(t, { subject: "org-creator" });
	850	const authed = t.withIdentity({ subject: "org-creator" });
	851
	852	const result = await authed.mutation(api.organizations.create, {
	853	name: "New Organization",
	854	});
	855
	856	expect(result.organization.name).toBe("New Organization");
	857	expect(result.workspace.name).toBe("Default Workspace");
	858	});
	859
	860	test("unauthenticated user cannot create an organization", async () => {
	861	const t = setup();
	862
	863	await expect(
	864	t.mutation(api.organizations.create, { name: "Sneaky Org" }),
	865	).rejects.toThrow("Must be signed in");
	866	});
	867
	868	test("org name must be at least 2 characters", async () => {
	869	const t = setup();
	870	await seedUser(t, { subject: "short-org" });
	871	const authed = t.withIdentity({ subject: "short-org" });
	872
	873	await expect(
	874	authed.mutation(api.organizations.create, { name: "X" }),
	875	).rejects.toThrow("Organization name must be at least 2 characters");
	876	});
	877	});
	878
	879	describe("workspace listing and navigation", () => {
	880	test("user only sees workspaces from their organizations", async () => {
	881	const t = setup();
	882	const user = await seedUser(t, { subject: "list-user" });
	883	await seedUser(t, { subject: "other-user" });
	884
	885	const authed = t.withIdentity({ subject: "list-user" });
	886
	887	const workspaces = await authed.query(api.workspaces.list, {});
	888	expect(workspaces.length).toBe(1);
	889	expect(workspaces[0]!.id).toBe(user.workspaceId);
	890	});
	891
	892	test("user sees workspaces from multiple orgs they belong to", async () => {
	893	const t = setup();
	894	const user = await seedUser(t, { subject: "multi-org-user" });
	895	const otherOrg = await seedUser(t, { subject: "multi-org-owner" });
	896
	897	// Add user to other org
	898	await addOrgMember(t, {
	899	organizationId: otherOrg.organizationId,
	900	accountId: user.accountId,
	901	role: "member",
	902	});
	903
	904	const authed = t.withIdentity({ subject: "multi-org-user" });
	905
	906	const workspaces = await authed.query(api.workspaces.list, {});
	907	// Should see their own workspace + the other org's workspace
	908	expect(workspaces.length).toBe(2);
	909	});
	910
	911	test("user can list workspaces filtered by organization", async () => {
	912	const t = setup();
	913	const user = await seedUser(t, { subject: "filter-user" });
	914	const authed = t.withIdentity({ subject: "filter-user" });
	915
	916	const workspaces = await authed.query(api.workspaces.list, {
	917	organizationId: user.organizationId,
	918	});
	919
	920	expect(workspaces.length).toBe(1);
	921	expect(workspaces[0]!.organizationId).toBe(user.organizationId);
	922	});
	923
	924	test("user cannot list workspaces of org they don't belong to", async () => {
	925	const t = setup();
	926	await seedUser(t, { subject: "nolist-user" });
	927	const otherOrg = await seedUser(t, { subject: "nolist-other" });
	928
	929	const authed = t.withIdentity({ subject: "nolist-user" });
	930
	931	const workspaces = await authed.query(api.workspaces.list, {
	932	organizationId: otherOrg.organizationId,
	933	});
	934
	935	// Returns empty array (not an error — graceful degradation)
	936	expect(workspaces).toEqual([]);
	937	});
	938
	939	test("listMine returns only orgs where user is active member", async () => {
	940	const t = setup();
	941	const user = await seedUser(t, { subject: "mine-user" });
	942	const authed = t.withIdentity({ subject: "mine-user" });
	943
	944	const orgs = await authed.query(api.organizations.listMine, {});
	945	expect(orgs.length).toBe(1);
	946	expect(orgs[0]!.id).toBe(user.organizationId);
	947	});
	948
	949	test("getNavigationState returns orgs and workspaces for authenticated user", async () => {
	950	const t = setup();
	951	const user = await seedUser(t, { subject: "nav-user" });
	952	const authed = t.withIdentity({ subject: "nav-user" });
	953
	954	const state = await authed.query(api.organizations.getNavigationState, {});
	955
	956	expect(state.organizations.length).toBe(1);
	957	expect(state.workspaces.length).toBe(1);
	958	expect(state.currentOrganizationId).toBe(user.organizationId);
	959	expect(state.currentWorkspaceId).toBe(user.workspaceId);
	960	});
	961
	962	test("getNavigationState returns empty for unauthenticated user", async () => {
	963	const t = setup();
	964
	965	const state = await t.query(api.organizations.getNavigationState, {});
	966
	967	expect(state.organizations).toEqual([]);
	968	expect(state.workspaces).toEqual([]);
	969	expect(state.currentOrganizationId).toBeNull();
	970	expect(state.currentWorkspaceId).toBeNull();
	971	});
	972	});
	973
	974	describe("organization access queries", () => {
	975	test("getOrganizationAccess returns role for active member", async () => {
	976	const t = setup();
	977	const user = await seedUser(t, { subject: "access-user" });
	978	const authed = t.withIdentity({ subject: "access-user" });
	979
	980	const access = await authed.query(api.organizations.getOrganizationAccess, {
	981	organizationId: user.organizationId,
	982	});
	983
	984	expect(access).not.toBeNull();
	985	expect(access!.role).toBe("owner");
	986	});
	987
	988	test("getOrganizationAccess returns null for non-member", async () => {
	989	const t = setup();
	990	await seedUser(t, { subject: "access-outsider" });
	991	const otherOrg = await seedUser(t, { subject: "access-other" });
	992
	993	const authed = t.withIdentity({ subject: "access-outsider" });
	994
	995	const access = await authed.query(api.organizations.getOrganizationAccess, {
	996	organizationId: otherOrg.organizationId,
	997	});
	998
	999	expect(access).toBeNull();
	1000	});
	1001
	1002	test("getOrganizationAccess returns null for unauthenticated", async () => {
	1003	const t = setup();
	1004	const org = await seedUser(t, { subject: "access-anon" });
	1005
	1006	const access = await t.query(api.organizations.getOrganizationAccess, {
	1007	organizationId: org.organizationId,
	1008	});
	1009
	1010	expect(access).toBeNull();
	1011	});
	1012	});
	1013
	1014	describe("task creation with access controls", () => {
	1015	test("workspace member can create a task", async () => {
	1016	const t = setup();
	1017	const user = await seedUser(t, { subject: "task-creator" });
	1018	const authed = t.withIdentity({ subject: "task-creator" });
	1019
	1020	const result = await authed.mutation(api.executor.createTask, {
	1021	workspaceId: asWorkspaceId(user.workspaceId),
	1022	code: "console.log('hello')",
	1023	});
	1024
	1025	expect(result.task.status).toBe("queued");
	1026	expect(result.task.workspaceId).toBe(asWorkspaceId(user.workspaceId));
	1027	});
	1028
	1029	test("task is scoped to workspace and visible to members", async () => {
	1030	const t = setup();
	1031	const owner = await seedUser(t, { subject: "task-scope-owner" });
	1032	const member = await seedUser(t, { subject: "task-scope-member" });
	1033
	1034	await addOrgMember(t, {
	1035	organizationId: owner.organizationId,
	1036	accountId: member.accountId,
	1037	role: "member",
	1038	});
	1039	await addWorkspaceMember(t, {
	1040	workspaceId: owner.workspaceId,
	1041	accountId: member.accountId,
	1042	role: "member",
	1043	});
	1044
	1045	// Owner creates a task
	1046	const authedOwner = t.withIdentity({ subject: "task-scope-owner" });
	1047	await authedOwner.mutation(api.executor.createTask, {
	1048	workspaceId: asWorkspaceId(owner.workspaceId),
	1049	code: "1 + 1",
	1050	});
	1051
	1052	// Member can see it
	1053	const authedMember = t.withIdentity({ subject: "task-scope-member" });
	1054	const tasks = await authedMember.query(api.workspace.listTasks, {
	1055	workspaceId: asWorkspaceId(owner.workspaceId),
	1056	});
	1057
	1058	expect(tasks.length).toBe(1);
	1059	expect(tasks[0]!.code).toBe("1 + 1");
	1060	});
	1061
	1062	test("task is not visible to users outside the workspace", async () => {
	1063	const t = setup();
	1064	const owner = await seedUser(t, { subject: "task-vis-owner" });
	1065	await seedUser(t, { subject: "task-vis-outsider" });
	1066
	1067	// Owner creates a task
	1068	const authedOwner = t.withIdentity({ subject: "task-vis-owner" });
	1069	await authedOwner.mutation(api.executor.createTask, {
	1070	workspaceId: asWorkspaceId(owner.workspaceId),
	1071	code: "secret code",
	1072	});
	1073
	1074	// Outsider cannot see it
	1075	const authedOutsider = t.withIdentity({ subject: "task-vis-outsider" });
	1076
	1077	await expect(
	1078	authedOutsider.query(api.workspace.listTasks, {
	1079	workspaceId: asWorkspaceId(owner.workspaceId),
	1080	}),
	1081	).rejects.toThrow("You are not a member of this workspace");
	1082	});
	1083	});
	1084
	1085	describe("credential security", () => {
	1086	test("listCredentials redacts secretJson", async () => {
	1087	const t = setup();
	1088	const owner = await seedUser(t, { subject: "cred-sec-owner" });
	1089	const authed = t.withIdentity({ subject: "cred-sec-owner" });
	1090
	1091	// Create a credential via admin
	1092	await authed.mutation(api.workspace.upsertCredential, {
	1093	workspaceId: asWorkspaceId(owner.workspaceId),
	1094	sourceKey: "openapi:stripe",
	1095	scope: "workspace",
	1096	secretJson: { token: "sk_live_super_secret" },
	1097	});
	1098
	1099	// List should redact
	1100	const credentials = await authed.query(api.workspace.listCredentials, {
	1101	workspaceId: asWorkspaceId(owner.workspaceId),
	1102	});
	1103
	1104	expect(credentials.length).toBe(1);
	1105	expect(credentials[0]!.secretJson).toEqual({});
	1106	expect(credentials[0]!.sourceKey).toBe("openapi:stripe");
	1107	});
	1108
	1109	test("resolveCredential requires admin role", async () => {
	1110	const t = setup();
	1111	const owner = await seedUser(t, { subject: "resolve-cred-owner" });
	1112	const member = await seedUser(t, { subject: "resolve-cred-member" });
	1113
	1114	await addOrgMember(t, {
	1115	organizationId: owner.organizationId,
	1116	accountId: member.accountId,
	1117	role: "member",
	1118	});
	1119	await addWorkspaceMember(t, {
	1120	workspaceId: owner.workspaceId,
	1121	accountId: member.accountId,
	1122	role: "member",
	1123	});
	1124
	1125	const authedMember = t.withIdentity({ subject: "resolve-cred-member" });
	1126
	1127	await expect(
	1128	authedMember.query(api.workspace.resolveCredential, {
	1129	workspaceId: asWorkspaceId(owner.workspaceId),
	1130	sourceKey: "openapi:github",
	1131	scope: "workspace",
	1132	}),
	1133	).rejects.toThrow("Only workspace admins can perform this action");
	1134	});
	1135	});
	1136
	1137	describe("role hierarchy validation", () => {
	1138	test("admin role grants access to admin-only operations", async () => {
	1139	const t = setup();
	1140	const org = await seedUser(t, { subject: "admin-hier-owner" });
	1141	const admin = await seedUser(t, { subject: "admin-hier-admin" });
	1142
	1143	await addOrgMember(t, {
	1144	organizationId: org.organizationId,
	1145	accountId: admin.accountId,
	1146	role: "admin",
	1147	});
	1148	await addWorkspaceMember(t, {
	1149	workspaceId: org.workspaceId,
	1150	accountId: admin.accountId,
	1151	role: "admin",
	1152	});
	1153
	1154	const authed = t.withIdentity({ subject: "admin-hier-admin" });
	1155
	1156	// Admin can upsert access policies
	1157	const policy = await authed.mutation(api.workspace.upsertAccessPolicy, {
	1158	workspaceId: asWorkspaceId(org.workspaceId),
	1159	toolPathPattern: "admin.*",
	1160	decision: "deny",
	1161	});
	1162	expect(policy.decision).toBe("deny");
	1163
	1164	// Admin can upsert tool sources
	1165	const source = await authed.mutation(api.workspace.upsertToolSource, {
	1166	workspaceId: asWorkspaceId(org.workspaceId),
	1167	name: "admin-tool",
	1168	type: "mcp",
	1169	config: { url: "https://example.com" },
	1170	});
	1171	expect(source.name).toBe("admin-tool");
	1172	});
	1173
	1174	test("billing_admin cannot perform admin-only org operations", async () => {
	1175	const t = setup();
	1176	const owner = await seedUser(t, { subject: "billing-test-owner" });
	1177	const billingAdmin = await seedUser(t, { subject: "billing-admin" });
	1178
	1179	await addOrgMember(t, {
	1180	organizationId: owner.organizationId,
	1181	accountId: billingAdmin.accountId,
	1182	role: "billing_admin",
	1183	});
	1184
	1185	const authed = t.withIdentity({ subject: "billing-admin" });
	1186
	1187	await expect(
	1188	authed.mutation(api.organizationMembers.updateRole, {
	1189	organizationId: owner.organizationId,
	1190	accountId: billingAdmin.accountId,
	1191	role: "admin",
	1192	}),
	1193	).rejects.toThrow("Only organization admins can perform this action");
	1194	});
	1195
	1196	test("member with pending status cannot access org resources", async () => {
	1197	const t = setup();
	1198	const owner = await seedUser(t, { subject: "pending-owner" });
	1199	const pending = await seedUser(t, { subject: "pending-member" });
	1200
	1201	await addOrgMember(t, {
	1202	organizationId: owner.organizationId,
	1203	accountId: pending.accountId,
	1204	role: "member",
	1205	status: "pending",
	1206	});
	1207
	1208	const authedPending = t.withIdentity({ subject: "pending-member" });
	1209
	1210	await expect(
	1211	authedPending.query(api.organizationMembers.list, {
	1212	organizationId: owner.organizationId,
	1213	}),
	1214	).rejects.toThrow("You are not a member of this organization");
	1215	});
	1216	});

executor/convex/app.ts+1−1

@@ -12,7 +12,7 @@ export const getClientConfig = query({ · 11 unmodified lines
12	features: {	12	features: {
13	organizations: true,	13	organizations: true,
14	billing: true,	14	billing: true,
15	workspaceRestrictions: false,	15	workspaceRestrictions: true,
16	},	16	},
17	};	17	};
18	},	18	},

executor/convex/auth.ts+83−0

@@ -11,6 +11,16 @@ type WorkosEventCtx = Pick<MutationCtx, "db" \| "runQuery">; · 10 unmodified lines
11	type OrganizationRole = "owner" \| "admin" \| "member" \| "billing_admin";	11	type OrganizationRole = "owner" \| "admin" \| "member" \| "billing_admin";
12	type OrganizationMemberStatus = "active" \| "pending" \| "removed";	12	type OrganizationMemberStatus = "active" \| "pending" \| "removed";
13		13
		14	function mapOrganizationRoleToWorkspaceRole(role: OrganizationRole): Doc<"workspaceMembers">["role"] {
		15	if (role === "owner") {
		16	return "owner";
		17	}
		18	if (role === "admin") {
		19	return "admin";
		20	}
		21	return "member";
		22	}
		23
14	const workosEnabled = Boolean(	24	const workosEnabled = Boolean(
15	process.env.WORKOS_CLIENT_ID && process.env.WORKOS_API_KEY && process.env.WORKOS_WEBHOOK_SECRET,	25	process.env.WORKOS_CLIENT_ID && process.env.WORKOS_API_KEY && process.env.WORKOS_WEBHOOK_SECRET,
16	);	26	);
@@ -168,6 +178,40 @@ async function upsertOrganizationMembership( · 151 unmodified lines
168	});	178	});
169	}	179	}
170		180
		181	async function ensureWorkspaceMembership(
		182	ctx: DbCtx,
		183	args: {
		184	workspaceId: Id<"workspaces">;
		185	accountId: Id<"accounts">;
		186	role: Doc<"workspaceMembers">["role"];
		187	now: number;
		188	},
		189	) {
		190	const existing = await ctx.db
		191	.query("workspaceMembers")
		192	.withIndex("by_workspace_account", (q) => q.eq("workspaceId", args.workspaceId).eq("accountId", args.accountId))
		193	.unique();
		194
		195	if (existing) {
		196	if (existing.status === "active") {
		197	await ctx.db.patch(existing._id, {
		198	role: args.role,
		199	updatedAt: args.now,
		200	});
		201	}
		202	return;
		203	}
		204
		205	await ctx.db.insert("workspaceMembers", {
		206	workspaceId: args.workspaceId,
		207	accountId: args.accountId,
		208	role: args.role,
		209	status: "active",
		210	createdAt: args.now,
		211	updatedAt: args.now,
		212	});
		213	}
		214
171	async function markPendingInvitesAcceptedByEmail(	215	async function markPendingInvitesAcceptedByEmail(
172	ctx: DbCtx,	216	ctx: DbCtx,
173	args: {	217	args: {
@@ -768,6 +812,45 @@ export const bootstrapCurrentWorkosAccount = mutation({ · 594 unmodified lines
768	}	812	}
769	}	813	}
770		814
		815	const activeOrganizationMemberships = await ctx.db
		816	.query("organizationMembers")
		817	.withIndex("by_account", (q) => q.eq("accountId", account._id))
		818	.filter((q) => q.eq(q.field("status"), "active"))
		819	.collect();
		820
		821	for (const membership of activeOrganizationMemberships) {
		822	const orgWorkspaces = await ctx.db
		823	.query("workspaces")
		824	.withIndex("by_organization_created", (q) => q.eq("organizationId", membership.organizationId))
		825	.collect();
		826
		827	const workspaceRole = mapOrganizationRoleToWorkspaceRole(membership.role);
		828	for (const workspace of orgWorkspaces) {
		829	await ensureWorkspaceMembership(ctx, {
		830	workspaceId: workspace._id,
		831	accountId: account._id,
		832	role: workspaceRole,
		833	now,
		834	});
		835	}
		836	}
		837
		838	const activeWorkspaceMembership = await ctx.db
		839	.query("workspaceMembers")
		840	.withIndex("by_account", (q) => q.eq("accountId", account._id))
		841	.filter((q) => q.eq(q.field("status"), "active"))
		842	.first();
		843
		844	if (!activeWorkspaceMembership) {
		845	await ensurePersonalWorkspace(ctx, account._id, {
		846	email,
		847	firstName,
		848	fullName,
		849	workosUserId: subject,
		850	now,
		851	});
		852	}
		853
771	return account;	854	return account;
772	},	855	},
773	});	856	});

executor/convex/credentialsNode.ts+22−6

 import { WorkOS } from "@workos-inc/node";
 import { v } from "convex/values";
-import { api } from "./_generated/api";
+import { internal } from "./_generated/api";
 import { action } from "./_generated/server";
 const credentialScopeValidator = v.union(v.literal("workspace"), v.literal("actor"));
   args: {
     id: v.optional(v.string()),
     workspaceId: v.string(),
+    sessionId: v.optional(v.string()),
     sourceKey: v.string(),
     scope: credentialScopeValidator,
     actorId: v.optional(v.string()),
     secretJson: v.any(),
   },
   handler: async (ctx, args): Promise<Record<string, unknown>> => {
+    const access = await ctx.runQuery(internal.workspaceAuthInternal.getWorkspaceAccessForRequest, {
+      workspaceId: args.workspaceId,
+      sessionId: args.sessionId,
+    });
+    const canonicalActorId = access.provider === "anonymous"
+      ? access.providerAccountId
+      : access.accountId;
+    if (args.scope === "actor" && args.actorId && args.actorId !== canonicalActorId) {
+      throw new Error("actorId must match the authenticated workspace actor");
+    }
     const provider = args.provider ?? "managed";
-    const actorId = normalizedActorId(args.scope, args.actorId);
+    const actorId = normalizedActorId(args.scope, args.actorId ?? canonicalActorId);
     const submittedSecret = asRecord(args.secretJson);
     if (provider === "managed") {
-      return await ctx.runMutation(api.database.upsertCredential, {
+      return await ctx.runMutation(internal.database.upsertCredential, {
-        ...args,
+        id: args.id,
+        workspaceId: args.workspaceId,
+        sourceKey: args.sourceKey,
+        scope: args.scope,
         actorId,
         provider,
         secretJson: submittedSecret,
       throw new Error("Encrypted storage value looks like a GitHub token. Paste the token in the token field.");
     }
-    const existing: Record<string, unknown> | null = await ctx.runQuery(api.database.resolveCredential, {
+    const existing: Record<string, unknown> | null = await ctx.runQuery(internal.database.resolveCredential, {
       workspaceId: args.workspaceId,
       sourceKey: args.sourceKey,
       scope: args.scope,
       throw new Error("Encrypted storage requires credential values");
     }
-    return await ctx.runMutation(api.database.upsertCredential, {
+    return await ctx.runMutation(internal.database.upsertCredential, {
       id: args.id,
       workspaceId: args.workspaceId,
       sourceKey: args.sourceKey,

executor/convex/database.test.ts+45−26

 import { expect, test } from "bun:test";
 import { convexTest } from "convex-test";
-import { api } from "./_generated/api";
+import { internal } from "./_generated/api";
 import schema from "./schema";
 function setup() {
 test("task lifecycle supports queue, run, and complete", async () => {
   const t = setup();
-  const created = await t.mutation(api.database.createTask, {
+  const created = await t.mutation(internal.database.createTask, {
     id: "task_1",
     code: "console.log('hello')",
     runtimeId: "local-bun",
   expect(created.id).toBe("task_1");
   expect(created.status).toBe("queued");
-  const queued = await t.query(api.database.listQueuedTaskIds, { limit: 10 });
+  const queued = await t.query(internal.database.listQueuedTaskIds, { limit: 10 });
   expect(queued).toEqual(["task_1"]);
-  const running = await t.mutation(api.database.markTaskRunning, { taskId: "task_1" });
+  const running = await t.mutation(internal.database.markTaskRunning, { taskId: "task_1" });
   expect(running?.status).toBe("running");
-  const secondRun = await t.mutation(api.database.markTaskRunning, { taskId: "task_1" });
+  const secondRun = await t.mutation(internal.database.markTaskRunning, { taskId: "task_1" });
   expect(secondRun).toBeNull();
-  const finished = await t.mutation(api.database.markTaskFinished, {
+  const finished = await t.mutation(internal.database.markTaskFinished, {
     taskId: "task_1",
     status: "completed",
     stdout: "ok",
   });
   expect(finished?.status).toBe("completed");
-  const queuedAfter = await t.query(api.database.listQueuedTaskIds, { limit: 10 });
+  const queuedAfter = await t.query(internal.database.listQueuedTaskIds, { limit: 10 });
   expect(queuedAfter).toEqual([]);
 });
 test("approval lifecycle tracks pending and resolution", async () => {
   const t = setup();
-  await t.mutation(api.database.createTask, {
+  await t.mutation(internal.database.createTask, {
     id: "task_2",
     code: "await tools.admin.delete_data({ id: 'x' })",
     runtimeId: "local-bun",
     clientId: "web",
   });
-  const createdApproval = await t.mutation(api.database.createApproval, {
+  const createdApproval = await t.mutation(internal.database.createApproval, {
     id: "approval_1",
     taskId: "task_2",
     toolPath: "admin.delete_data",
   });
   expect(createdApproval.status).toBe("pending");
-  const pending = await t.query(api.database.listPendingApprovals, { workspaceId: "ws_2" });
+  const pending = await t.query(internal.database.listPendingApprovals, { workspaceId: "ws_2" });
   expect(pending.length).toBe(1);
   expect(pending[0]?.task.id).toBe("task_2");
-  const resolved = await t.mutation(api.database.resolveApproval, {
+  const resolved = await t.mutation(internal.database.resolveApproval, {
     approvalId: "approval_1",
     decision: "approved",
     reviewerId: "reviewer_1",
   });
   expect(resolved?.status).toBe("approved");
-  const pendingAfter = await t.query(api.database.listPendingApprovals, { workspaceId: "ws_2" });
+  const pendingAfter = await t.query(internal.database.listPendingApprovals, { workspaceId: "ws_2" });
   expect(pendingAfter).toEqual([]);
 });
 test("anonymous bootstrap links guest account membership", async () => {
   const t = setup();
-  const first = await t.mutation(api.database.bootstrapAnonymousSession, {});
+  const first = await t.mutation(internal.database.bootstrapAnonymousSession, {});
   expect(first.sessionId).toContain("anon_session_");
-  expect(first.workspaceId).toContain("ws_");
+  expect(first.workspaceId.length).toBeGreaterThan(0);
   expect(first.actorId).toContain("anon_");
   expect(first.accountId).toBeDefined();
   expect(first.userId).toBeDefined();
-  const again = await t.mutation(api.database.bootstrapAnonymousSession, {
+  const again = await t.mutation(internal.database.bootstrapAnonymousSession, {
     sessionId: first.sessionId,
   });
   expect(again.userId).toBe(first.userId);
 });
-test("bootstrap honors caller-provided session id", async () => {
+test("bootstrap ignores non-MCP caller-provided session id", async () => {
   const t = setup();
-  const seeded = await t.mutation(api.database.bootstrapAnonymousSession, {
+  const seeded = await t.mutation(internal.database.bootstrapAnonymousSession, {
     sessionId: "assistant-discord-dev",
   });
-  expect(seeded.sessionId).toBe("assistant-discord-dev");
+  expect(seeded.sessionId).not.toBe("assistant-discord-dev");
+  expect(seeded.sessionId).toContain("anon_session_");
-  const again = await t.mutation(api.database.bootstrapAnonymousSession, {
+  const again = await t.mutation(internal.database.bootstrapAnonymousSession, {
-    sessionId: "assistant-discord-dev",
+    sessionId: seeded.sessionId,
+  });
+  expect(again.sessionId).toBe(seeded.sessionId);
+  expect(again.workspaceId).toBe(seeded.workspaceId);
+  expect(again.actorId).toBe(seeded.actorId);
+});
+test("bootstrap honors MCP caller-provided session id", async () => {
+  const t = setup();
+  const seeded = await t.mutation(internal.database.bootstrapAnonymousSession, {
+    sessionId: "mcp_assistant-discord-dev",
+  });
+  expect(seeded.sessionId).toBe("mcp_assistant-discord-dev");
+  const again = await t.mutation(internal.database.bootstrapAnonymousSession, {
+    sessionId: "mcp_assistant-discord-dev",
   });
-  expect(again.sessionId).toBe("assistant-discord-dev");
+  expect(again.sessionId).toBe("mcp_assistant-discord-dev");
   expect(again.workspaceId).toBe(seeded.workspaceId);
   expect(again.actorId).toBe(seeded.actorId);
 });
 test("credentials persist provider and resolve by scope", async () => {
   const t = setup();
-  const workspaceCredential = await t.mutation(api.database.upsertCredential, {
+  const workspaceCredential = await t.mutation(internal.database.upsertCredential, {
     workspaceId: "ws_cred",
     sourceKey: "openapi:github",
     scope: "workspace",
   expect(workspaceCredential.provider).toBe("managed");
-  const actorCredential = await t.mutation(api.database.upsertCredential, {
+  const actorCredential = await t.mutation(internal.database.upsertCredential, {
     workspaceId: "ws_cred",
     sourceKey: "openapi:github",
     scope: "actor",
   expect(actorCredential.provider).toBe("workos-vault");
   expect(actorCredential.actorId).toBe("actor_cred");
-  const resolvedWorkspace = await t.query(api.database.resolveCredential, {
+  const resolvedWorkspace = await t.query(internal.database.resolveCredential, {
     workspaceId: "ws_cred",
     sourceKey: "openapi:github",
     scope: "workspace",
   });
   expect(resolvedWorkspace?.provider).toBe("managed");
-  const resolvedActor = await t.query(api.database.resolveCredential, {
+  const resolvedActor = await t.query(internal.database.resolveCredential, {
     workspaceId: "ws_cred",
     sourceKey: "openapi:github",
     scope: "actor",
 test("upsertCredential defaults provider to managed", async () => {
   const t = setup();
-  const credential = await t.mutation(api.database.upsertCredential, {
+  const credential = await t.mutation(internal.database.upsertCredential, {
     workspaceId: "ws_default_provider",
     sourceKey: "openapi:stripe",
     scope: "workspace",

executor/convex/database.ts+37−31

 import { v } from "convex/values";
 import type { Doc } from "./_generated/dataModel";
 import type { MutationCtx, QueryCtx } from "./_generated/server";
-import { mutation, query } from "./_generated/server";
+import { internalMutation, internalQuery } from "./_generated/server";
 import { ensureUniqueSlug } from "./lib/slug";
 import type { TaskStatus } from "@executor/contracts";
     .unique();
 }
-export const createTask = mutation({
+export const createTask = internalMutation({
   args: {
     id: v.string(),
     code: v.string(),
   },
 });
-export const getTask = query({
+export const getTask = internalQuery({
   args: { taskId: v.string() },
   handler: async (ctx, args) => {
     const doc = await getTaskDoc(ctx, args.taskId);
   },
 });
-export const listTasks = query({
+export const listTasks = internalQuery({
   args: { workspaceId: v.string() },
   handler: async (ctx, args) => {
     const docs = await ctx.db
   },
 });
-export const listQueuedTaskIds = query({
+export const listQueuedTaskIds = internalQuery({
   args: { limit: v.optional(v.number()) },
   handler: async (ctx, args) => {
     const docs = await ctx.db
   },
 });
-export const listRuntimeTargets = query({
+export const listRuntimeTargets = internalQuery({
   args: {},
   handler: async () => {
     return [
   },
 });
-export const getTaskInWorkspace = query({
+export const getTaskInWorkspace = internalQuery({
   args: { taskId: v.string(), workspaceId: v.string() },
   handler: async (ctx, args) => {
     const doc = await getTaskDoc(ctx, args.taskId);
   },
 });
-export const markTaskRunning = mutation({
+export const markTaskRunning = internalMutation({
   args: { taskId: v.string() },
   handler: async (ctx, args) => {
     const doc = await getTaskDoc(ctx, args.taskId);
   },
 });
-export const markTaskFinished = mutation({
+export const markTaskFinished = internalMutation({
   args: {
     taskId: v.string(),
     status: completedTaskStatusValidator,
   },
 });
-export const createApproval = mutation({
+export const createApproval = internalMutation({
   args: {
     id: v.string(),
     taskId: v.string(),
   },
 });
-export const getApproval = query({
+export const getApproval = internalQuery({
   args: { approvalId: v.string() },
   handler: async (ctx, args) => {
     const doc = await getApprovalDoc(ctx, args.approvalId);
   },
 });
-export const listApprovals = query({
+export const listApprovals = internalQuery({
   args: {
     workspaceId: v.string(),
     status: v.optional(approvalStatusValidator),
   },
 });
-export const listPendingApprovals = query({
+export const listPendingApprovals = internalQuery({
   args: { workspaceId: v.string() },
   handler: async (ctx, args) => {
     const docs = await ctx.db
   },
 });
-export const resolveApproval = mutation({
+export const resolveApproval = internalMutation({
   args: {
     approvalId: v.string(),
     decision: v.union(v.literal("approved"), v.literal("denied")),
   },
 });
-export const getApprovalInWorkspace = query({
+export const getApprovalInWorkspace = internalQuery({
   args: { approvalId: v.string(), workspaceId: v.string() },
   handler: async (ctx, args) => {
     const doc = await getApprovalDoc(ctx, args.approvalId);
     .unique();
 }
-export const createAgentTask = mutation({
+export const createAgentTask = internalMutation({
   args: {
     id: v.string(),
     prompt: v.string(),
   },
 });
-export const getAgentTask = query({
+export const getAgentTask = internalQuery({
   args: { agentTaskId: v.string() },
   handler: async (ctx, args) => {
     const doc = await getAgentTaskDoc(ctx, args.agentTaskId);
   },
 });
-export const updateAgentTask = mutation({
+export const updateAgentTask = internalMutation({
   args: {
     agentTaskId: v.string(),
     status: v.optional(agentTaskStatusValidator),
   },
 });
-export const bootstrapAnonymousSession = mutation({
+export const bootstrapAnonymousSession = internalMutation({
   args: { sessionId: v.optional(v.string()) },
   handler: async (ctx, args) => {
     const now = Date.now();
     const requestedSessionId = normalizeOptional(args.sessionId);
+    const allowRequestedSessionId = requestedSessionId?.startsWith("mcp_") ?? false;
     if (requestedSessionId) {
       const sessionId = requestedSessionId;
       }
     }
-    const sessionId = requestedSessionId || `anon_session_${crypto.randomUUID()}`;
+    const generatedSessionId = allowRequestedSessionId
+      ? `mcp_${crypto.randomUUID()}`
+      : `anon_session_${crypto.randomUUID()}`;
+    const sessionId = allowRequestedSessionId
+      ? requestedSessionId as string
+      : generatedSessionId;
     const actorId = `anon_${crypto.randomUUID()}`;
     const clientId = "web";
   },
 });
-export const upsertAccessPolicy = mutation({
+export const upsertAccessPolicy = internalMutation({
   args: {
     id: v.optional(v.string()),
     workspaceId: v.string(),
   },
 });
-export const listAccessPolicies = query({
+export const listAccessPolicies = internalQuery({
   args: { workspaceId: v.string() },
   handler: async (ctx, args) => {
     const docs = await ctx.db
   },
 });
-export const upsertCredential = mutation({
+export const upsertCredential = internalMutation({
   args: {
     id: v.optional(v.string()),
     workspaceId: v.string(),
   },
 });
-export const listCredentials = query({
+export const listCredentials = internalQuery({
   args: { workspaceId: v.string() },
   handler: async (ctx, args) => {
     const docs = await ctx.db
   },
 });
-export const listCredentialProviders = query({
+export const listCredentialProviders = internalQuery({
   args: {},
   handler: async () => {
     return [
   },
 });
-export const resolveCredential = query({
+export const resolveCredential = internalQuery({
   args: {
     workspaceId: v.string(),
     sourceKey: v.string(),
   },
 });
-export const upsertToolSource = mutation({
+export const upsertToolSource = internalMutation({
   args: {
     id: v.optional(v.string()),
     workspaceId: v.string(),
   },
 });
-export const listToolSources = query({
+export const listToolSources = internalQuery({
   args: { workspaceId: v.string() },
   handler: async (ctx, args) => {
     const docs = await ctx.db
   },
 });
-export const deleteToolSource = mutation({
+export const deleteToolSource = internalMutation({
   args: { workspaceId: v.string(), sourceId: v.string() },
   handler: async (ctx, args) => {
     const doc = await ctx.db
   },
 });
-export const createTaskEvent = mutation({
+export const createTaskEvent = internalMutation({
   args: {
     taskId: v.string(),
     eventName: v.string(),
   },
 });
-export const listTaskEvents = query({
+export const listTaskEvents = internalQuery({
   args: { taskId: v.string() },
   handler: async (ctx, args) => {
     const docs = await ctx.db

executor/convex/executor-mcp.e2e.test.ts+23−13

 import { convexTest } from "convex-test";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { api, internal } from "./_generated/api";
+import { internal } from "./_generated/api";
 import schema from "./schema";
 function setup() {
     "./executorNode.ts": () => import("./executorNode"),
     "./http.ts": () => import("./http"),
     "./auth.ts": () => import("./auth"),
+    "./workspaceAuthInternal.ts": () => import("./workspaceAuthInternal"),
+    "./workspaceToolCache.ts": () => import("./workspaceToolCache"),
+    "./openApiSpecCache.ts": () => import("./openApiSpecCache"),
     "./_generated/api.js": () => import("./_generated/api.js"),
   });
 }
-function createMcpTransport(t: ReturnType<typeof setup>, workspaceId: string, actorId: string, clientId = "e2e") {
+function createMcpTransport(
+  t: ReturnType<typeof setup>,
+  workspaceId: string,
+  actorId: string,
+  sessionId: string,
+  clientId = "e2e",
+) {
   const url = new URL("https://executor.test/mcp");
   url.searchParams.set("workspaceId", workspaceId);
   url.searchParams.set("actorId", actorId);
+  url.searchParams.set("sessionId", sessionId);
   url.searchParams.set("clientId", clientId);
   return new StreamableHTTPClientTransport(url, {
 async function waitForTaskId(t: ReturnType<typeof setup>, workspaceId: string, timeoutMs = 10_000): Promise<string> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const tasks = await t.query(api.database.listTasks, { workspaceId });
+    const tasks = await t.query(internal.database.listTasks, { workspaceId });
     if (tasks.length > 0) {
       return tasks[0]!.id;
     }
 ): Promise<string> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const approvals = await t.query(api.database.listPendingApprovals, { workspaceId });
+    const approvals = await t.query(internal.database.listPendingApprovals, { workspaceId });
-    const approval = approvals.find((item) => item.toolPath === toolPath);
+    const approval = approvals.find((item: { toolPath: string; id: string }) => item.toolPath === toolPath);
     if (approval) {
       return approval.id;
     }
 test("MCP run_code survives delayed approval and completes", async () => {
   const t = setup();
-  const session = await t.mutation(api.database.bootstrapAnonymousSession, {});
+  const session = await t.mutation(internal.database.bootstrapAnonymousSession, {});
   const client = new Client({ name: "executor-e2e", version: "0.0.1" }, { capabilities: {} });
-  const transport = createMcpTransport(t, session.workspaceId, session.actorId, "e2e-approval-delay");
+  const transport = createMcpTransport(t, session.workspaceId, session.actorId, session.sessionId, "e2e-approval-delay");
   try {
     await client.connect(transport);
     await Bun.sleep(16_000);
-    await t.mutation(api.executor.resolveApproval, {
+    await t.mutation(internal.executor.resolveApprovalInternal, {
       workspaceId: session.workspaceId,
       approvalId,
       decision: "approved",
     expect(text).toContain("status: completed");
     expect(text).toContain("hello from convex-test");
-    const task = await t.query(api.database.getTask, { taskId });
+    const task = await t.query(internal.database.getTask, { taskId });
     expect(task?.status).toBe("completed");
   } finally {
     await transport.close().catch(() => {});
 test("MCP run_code returns denied after approval denial", async () => {
   const t = setup();
-  const session = await t.mutation(api.database.bootstrapAnonymousSession, {});
+  const session = await t.mutation(internal.database.bootstrapAnonymousSession, {});
   const client = new Client({ name: "executor-e2e", version: "0.0.1" }, { capabilities: {} });
-  const transport = createMcpTransport(t, session.workspaceId, session.actorId, "e2e-deny");
+  const transport = createMcpTransport(t, session.workspaceId, session.actorId, session.sessionId, "e2e-deny");
   try {
     await client.connect(transport);
     const runTask = t.action(internal.executorNode.runTask, { taskId });
     const approvalId = await waitForPendingApproval(t, session.workspaceId, "admin.delete_data");
-    await t.mutation(api.executor.resolveApproval, {
+    await t.mutation(internal.executor.resolveApprovalInternal, {
       workspaceId: session.workspaceId,
       approvalId,
       decision: "denied",
     expect(result.isError).toBe(true);
     expect(text).toContain("status: denied");
-    const task = await t.query(api.database.getTask, { taskId });
+    const task = await t.query(internal.database.getTask, { taskId });
     expect(task?.status).toBe("denied");
   } finally {
     await transport.close().catch(() => {});

executor/convex/executor.ts+171−93

@@ -1,7 +1,8 @@
1	import { v } from "convex/values";	1	import { v } from "convex/values";
2	import { api, internal } from "./_generated/api";	2	import { internal } from "./_generated/api";
3	import type { MutationCtx } from "./_generated/server";	3	import type { MutationCtx } from "./_generated/server";
4	import { internalMutation, mutation } from "./_generated/server";	4	import { internalMutation } from "./_generated/server";
		5	import { workspaceMutation } from "./lib/functionBuilders";
5	import type { ApprovalRecord, TaskRecord } from "./lib/types";	6	import type { ApprovalRecord, TaskRecord } from "./lib/types";
6		7
7	const DEFAULT_TIMEOUT_MS = 300_000;	8	const DEFAULT_TIMEOUT_MS = 300_000;
@@ -15,125 +16,202 @@ async function publishTaskEvent( · 7 unmodified lines
15	payload: Record<string, unknown>;	16	payload: Record<string, unknown>;
16	},	17	},
17	): Promise<void> {	18	): Promise<void> {
18	await ctx.runMutation(api.database.createTaskEvent, input);	19	await ctx.runMutation(internal.database.createTaskEvent, input);
19	}	20	}
20		21
21	export const createTask = mutation({	22	function actorIdForAccount(account: { _id: string; provider: string; providerAccountId: string }) {
		23	return account.provider === "anonymous" ? account.providerAccountId : account._id;
		24	}
		25
		26	async function createTaskRecord(
		27	ctx: MutationCtx,
		28	args: {
		29	code: string;
		30	timeoutMs?: number;
		31	runtimeId?: string;
		32	metadata?: unknown;
		33	workspaceId: string;
		34	actorId: string;
		35	clientId?: string;
		36	},
		37	): Promise<{ task: TaskRecord }> {
		38	if (!args.code.trim()) {
		39	throw new Error("Task code is required");
		40	}
		41
		42	const runtimeId = args.runtimeId ?? "local-bun";
		43	if (runtimeId !== "local-bun") {
		44	throw new Error(`Unsupported runtime: ${runtimeId}`);
		45	}
		46
		47	const taskId = `task_${crypto.randomUUID()}`;
		48	const task = (await ctx.runMutation(internal.database.createTask, {
		49	id: taskId,
		50	code: args.code,
		51	runtimeId,
		52	timeoutMs: args.timeoutMs ?? DEFAULT_TIMEOUT_MS,
		53	metadata: args.metadata,
		54	workspaceId: args.workspaceId,
		55	actorId: args.actorId,
		56	clientId: args.clientId,
		57	})) as TaskRecord;
		58
		59	await publishTaskEvent(ctx, {
		60	taskId,
		61	eventName: "task",
		62	type: "task.created",
		63	payload: {
		64	taskId,
		65	status: task.status,
		66	runtimeId: task.runtimeId,
		67	timeoutMs: task.timeoutMs,
		68	workspaceId: task.workspaceId,
		69	actorId: task.actorId,
		70	clientId: task.clientId,
		71	createdAt: task.createdAt,
		72	},
		73	});
		74
		75	await publishTaskEvent(ctx, {
		76	taskId,
		77	eventName: "task",
		78	type: "task.queued",
		79	payload: {
		80	taskId,
		81	status: "queued",
		82	},
		83	});
		84
		85	await ctx.scheduler.runAfter(1, internal.executorNode.runTask, {
		86	taskId,
		87	});
		88
		89	return { task };
		90	}
		91
		92	async function resolveApprovalRecord(
		93	ctx: MutationCtx,
		94	args: {
		95	workspaceId: string;
		96	approvalId: string;
		97	decision: "approved" \| "denied";
		98	reviewerId?: string;
		99	reason?: string;
		100	},
		101	): Promise<{ approval: ApprovalRecord; task: TaskRecord } \| null> {
		102	const scopedApproval = await ctx.runQuery(internal.database.getApprovalInWorkspace, {
		103	approvalId: args.approvalId,
		104	workspaceId: args.workspaceId,
		105	});
		106	if (!scopedApproval \|\| scopedApproval.status !== "pending") {
		107	return null;
		108	}
		109
		110	const approval = (await ctx.runMutation(internal.database.resolveApproval, {
		111	approvalId: args.approvalId,
		112	decision: args.decision,
		113	reviewerId: args.reviewerId,
		114	reason: args.reason,
		115	})) as ApprovalRecord \| null;
		116	if (!approval) {
		117	return null;
		118	}
		119
		120	await publishTaskEvent(ctx, {
		121	taskId: approval.taskId,
		122	eventName: "approval",
		123	type: "approval.resolved",
		124	payload: {
		125	approvalId: approval.id,
		126	taskId: approval.taskId,
		127	toolPath: approval.toolPath,
		128	decision: approval.status,
		129	reviewerId: approval.reviewerId,
		130	reason: approval.reason,
		131	resolvedAt: approval.resolvedAt,
		132	},
		133	});
		134
		135	const task = (await ctx.runQuery(internal.database.getTask, {
		136	taskId: approval.taskId,
		137	})) as TaskRecord \| null;
		138	if (!task) {
		139	throw new Error(`Task ${approval.taskId} missing while resolving approval`);
		140	}
		141
		142	return { approval, task };
		143	}
		144
		145	export const createTask = workspaceMutation({
22	args: {	146	args: {
23	code: v.string(),	147	code: v.string(),
24	timeoutMs: v.optional(v.number()),	148	timeoutMs: v.optional(v.number()),
25	runtimeId: v.optional(v.string()),	149	runtimeId: v.optional(v.string()),
26	metadata: v.optional(v.any()),	150	metadata: v.optional(v.any()),
27	workspaceId: v.string(),	151	actorId: v.optional(v.string()),
28	actorId: v.string(),
29	clientId: v.optional(v.string()),	152	clientId: v.optional(v.string()),
30	},	153	},
31	handler: async (ctx, args): Promise<{ task: TaskRecord }> => {	154	handler: async (ctx, args): Promise<{ task: TaskRecord }> => {
32	if (!args.code.trim()) {	155	const canonicalActorId = actorIdForAccount(ctx.account as { _id: string; provider: string; providerAccountId: string });
33	throw new Error("Task code is required");	156	if (args.actorId && args.actorId !== canonicalActorId) {
		157	throw new Error("actorId must match the authenticated workspace actor");
34	}	158	}
35		159
36	const runtimeId = args.runtimeId ?? "local-bun";	160	return await createTaskRecord(ctx, {
37	if (runtimeId !== "local-bun") {	161	...args,
38	throw new Error(`Unsupported runtime: ${runtimeId}`);	162	workspaceId: ctx.workspaceId,
39	}	163	actorId: canonicalActorId,
40
41	const taskId = `task_${crypto.randomUUID()}`;
42	const task = (await ctx.runMutation(api.database.createTask, {
43	id: taskId,
44	code: args.code,
45	runtimeId,
46	timeoutMs: args.timeoutMs ?? DEFAULT_TIMEOUT_MS,
47	metadata: args.metadata,
48	workspaceId: args.workspaceId,
49	actorId: args.actorId,
50	clientId: args.clientId,	164	clientId: args.clientId,
51	})) as TaskRecord;
52
53	await publishTaskEvent(ctx, {
54	taskId,
55	eventName: "task",
56	type: "task.created",
57	payload: {
58	taskId,
59	status: task.status,
60	runtimeId: task.runtimeId,
61	timeoutMs: task.timeoutMs,
62	workspaceId: task.workspaceId,
63	actorId: task.actorId,
64	clientId: task.clientId,
65	createdAt: task.createdAt,
66	},
67	});	165	});
68
69	await publishTaskEvent(ctx, {
70	taskId,
71	eventName: "task",
72	type: "task.queued",
73	payload: {
74	taskId,
75	status: "queued",
76	},
77	});
78
79	await ctx.scheduler.runAfter(1, internal.executorNode.runTask, {
80	taskId,
81	});
82
83	return { task };
84	},	166	},
85	});	167	});
86		168
87	export const resolveApproval = mutation({	169	export const createTaskInternal = internalMutation({
88	args: {	170	args: {
		171	code: v.string(),
		172	timeoutMs: v.optional(v.number()),
		173	runtimeId: v.optional(v.string()),
		174	metadata: v.optional(v.any()),
89	workspaceId: v.string(),	175	workspaceId: v.string(),
		176	actorId: v.string(),
		177	clientId: v.optional(v.string()),
		178	},
		179	handler: async (ctx, args): Promise<{ task: TaskRecord }> => {
		180	return await createTaskRecord(ctx, args);
		181	},
		182	});
		183
		184	export const resolveApproval = workspaceMutation({
		185	args: {
90	approvalId: v.string(),	186	approvalId: v.string(),
91	decision: v.union(v.literal("approved"), v.literal("denied")),	187	decision: v.union(v.literal("approved"), v.literal("denied")),
92	reviewerId: v.optional(v.string()),	188	reviewerId: v.optional(v.string()),
93	reason: v.optional(v.string()),	189	reason: v.optional(v.string()),
94	},	190	},
95	handler: async (ctx, args): Promise<{ approval: ApprovalRecord; task: TaskRecord } \| null> => {	191	handler: async (ctx, args): Promise<{ approval: ApprovalRecord; task: TaskRecord } \| null> => {
96	const scopedApproval = await ctx.runQuery(api.database.getApprovalInWorkspace, {	192	const canonicalActorId = actorIdForAccount(ctx.account as { _id: string; provider: string; providerAccountId: string });
97	approvalId: args.approvalId,	193	if (args.reviewerId && args.reviewerId !== canonicalActorId) {
98	workspaceId: args.workspaceId,	194	throw new Error("reviewerId must match the authenticated workspace actor");
99	});
100	if (!scopedApproval \|\| scopedApproval.status !== "pending") {
101	return null;
102	}
103
104	const approval = (await ctx.runMutation(api.database.resolveApproval, {
105	approvalId: args.approvalId,
106	decision: args.decision,
107	reviewerId: args.reviewerId,
108	reason: args.reason,
109	})) as ApprovalRecord \| null;
110	if (!approval) {
111	return null;
112	}	195	}
113		196
114	await publishTaskEvent(ctx, {	197	return await resolveApprovalRecord(ctx, {
115	taskId: approval.taskId,	198	...args,
116	eventName: "approval",	199	workspaceId: ctx.workspaceId,
117	type: "approval.resolved",	200	reviewerId: canonicalActorId,
118	payload: {
119	approvalId: approval.id,
120	taskId: approval.taskId,
121	toolPath: approval.toolPath,
122	decision: approval.status,
123	reviewerId: approval.reviewerId,
124	reason: approval.reason,
125	resolvedAt: approval.resolvedAt,
126	},
127	});	201	});
		202	},
		203	});
128		204
129	const task = (await ctx.runQuery(api.database.getTask, {	205	export const resolveApprovalInternal = internalMutation({
130	taskId: approval.taskId,	206	args: {
131	})) as TaskRecord \| null;	207	workspaceId: v.string(),
132	if (!task) {	208	approvalId: v.string(),
133	throw new Error(`Task ${approval.taskId} missing while resolving approval`);	209	decision: v.union(v.literal("approved"), v.literal("denied")),
134	}	210	reviewerId: v.optional(v.string()),
135		211	reason: v.optional(v.string()),
136	return { approval, task };	212	},
		213	handler: async (ctx, args): Promise<{ approval: ApprovalRecord; task: TaskRecord } \| null> => {
		214	return await resolveApprovalRecord(ctx, args);
137	},	215	},
138	});	216	});
139		217
@@ -145,7 +223,7 @@ export const appendRuntimeOutput = internalMutation({ · 5 unmodified lines
145	timestamp: v.optional(v.number()),	223	timestamp: v.optional(v.number()),
146	},	224	},
147	handler: async (ctx, args) => {	225	handler: async (ctx, args) => {
148	await ctx.runMutation(api.database.createTaskEvent, {	226	await ctx.runMutation(internal.database.createTaskEvent, {
149	taskId: args.runId,	227	taskId: args.runId,
150	eventName: "task",	228	eventName: "task",
151	type: args.stream === "stdout" ? "task.stdout" : "task.stderr",	229	type: args.stream === "stdout" ? "task.stdout" : "task.stderr",

executor/convex/executorNode.ts+187−65

@@ -1,7 +1,7 @@
1	"use node";	1	"use node";
2		2
3	import { v } from "convex/values";	3	import { v } from "convex/values";
4	import { api, internal } from "./_generated/api";	4	import { internal } from "./_generated/api";
5	import { action, internalAction } from "./_generated/server";	5	import { action, internalAction } from "./_generated/server";
6	import { InProcessExecutionAdapter } from "./lib/adapters/in_process_execution_adapter";	6	import { InProcessExecutionAdapter } from "./lib/adapters/in_process_execution_adapter";
7	import { resolveCredentialPayload } from "./lib/credential_providers";	7	import { resolveCredentialPayload } from "./lib/credential_providers";
@@ -123,15 +123,20 @@ async function sleep(ms: number): Promise<void> { · 115 unmodified lines
123	}	123	}
124		124
125	const baseTools = new Map<string, ToolDefinition>(DEFAULT_TOOLS.map((tool) => [tool.path, tool]));	125	const baseTools = new Map<string, ToolDefinition>(DEFAULT_TOOLS.map((tool) => [tool.path, tool]));
		126	interface DtsStorageEntry {
		127	sourceKey: string;
		128	storageId: string;
		129	}
		130
126	const workspaceToolCache = new Map<	131	const workspaceToolCache = new Map<
127	string,	132	string,
128	{ signature: string; loadedAt: number; tools: Map<string, ToolDefinition>; warnings: string[] }	133	{ signature: string; loadedAt: number; tools: Map<string, ToolDefinition>; warnings: string[]; dtsStorageIds: DtsStorageEntry[] }
129	>();	134	>();
130	const workspaceToolLoadsInFlight = new Map<	135	const workspaceToolLoadsInFlight = new Map<
131	string,	136	string,
132	{	137	{
133	signature: string;	138	signature: string;
134	promise: Promise<{ tools: Map<string, ToolDefinition>; warnings: string[] }>;	139	promise: Promise<{ tools: Map<string, ToolDefinition>; warnings: string[]; dtsStorageIds: DtsStorageEntry[] }>;
135	}	140	}
136	>();	141	>();
137	const OPENAPI_SPEC_CACHE_TTL_MS = 5 * 60 * 60_000;	142	const OPENAPI_SPEC_CACHE_TTL_MS = 5 * 60 * 60_000;
@@ -165,7 +170,7 @@ async function publish( · 27 unmodified lines
165	type: string,	170	type: string,
166	payload: Record<string, unknown>,	171	payload: Record<string, unknown>,
167	): Promise<void> {	172	): Promise<void> {
168	await ctx.runMutation(api.database.createTaskEvent, {	173	await ctx.runMutation(internal.database.createTaskEvent, {
169	taskId,	174	taskId,
170	eventName,	175	eventName,
171	type,	176	type,
@@ -175,7 +180,7 @@ async function publish( · 3 unmodified lines
175		180
176	async function waitForApproval(ctx: any, approvalId: string): Promise<"approved" \| "denied"> {	181	async function waitForApproval(ctx: any, approvalId: string): Promise<"approved" \| "denied"> {
177	while (true) {	182	while (true) {
178	const approval = await ctx.runQuery(api.database.getApproval, { approvalId });	183	const approval = await ctx.runQuery(internal.database.getApproval, { approvalId });
179	if (!approval) {	184	if (!approval) {
180	throw new Error(`Approval ${approvalId} not found`);	185	throw new Error(`Approval ${approvalId} not found`);
181	}	186	}
@@ -270,8 +275,13 @@ async function loadSourceTools( · 88 unmodified lines
270	return await loadExternalTools([source]);	275	return await loadExternalTools([source]);
271	}	276	}
272		277
273	async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<Map<string, ToolDefinition>> {	278	interface WorkspaceToolsResult {
274	const sources = (await ctx.runQuery(api.database.listToolSources, { workspaceId }))	279	tools: Map<string, ToolDefinition>;
		280	dtsStorageIds: DtsStorageEntry[];
		281	}
		282
		283	async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<WorkspaceToolsResult> {
		284	const sources = (await ctx.runQuery(internal.database.listToolSources, { workspaceId }))
275	.filter((source: { enabled: boolean }) => source.enabled);	285	.filter((source: { enabled: boolean }) => source.enabled);
276	const now = Date.now();	286	const now = Date.now();
277	const signature = sourceSignature(workspaceId, sources);	287	const signature = sourceSignature(workspaceId, sources);
@@ -279,14 +289,14 @@ async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<Map<str · 1 unmodified line
279	// ── Layer 1: In-memory cache (same warm worker) ───────────────────────	289	// ── Layer 1: In-memory cache (same warm worker) ───────────────────────
280	const cached = workspaceToolCache.get(workspaceId);	290	const cached = workspaceToolCache.get(workspaceId);
281	if (cached && isWorkspaceToolCacheFresh(cached, signature, now)) {	291	if (cached && isWorkspaceToolCacheFresh(cached, signature, now)) {
282	return cached.tools;	292	return { tools: cached.tools, dtsStorageIds: cached.dtsStorageIds };
283	}	293	}
284		294
285	// ── Layer 2: In-flight dedup (concurrent requests on same worker) ─────	295	// ── Layer 2: In-flight dedup (concurrent requests on same worker) ─────
286	const inFlight = workspaceToolLoadsInFlight.get(workspaceId);	296	const inFlight = workspaceToolLoadsInFlight.get(workspaceId);
287	if (inFlight && inFlight.signature === signature) {	297	if (inFlight && inFlight.signature === signature) {
288	const loaded = await inFlight.promise;	298	const loaded = await inFlight.promise;
289	return loaded.tools;	299	return { tools: loaded.tools, dtsStorageIds: loaded.dtsStorageIds };
290	}	300	}
291		301
292	const loadPromise = (async () => {	302	const loadPromise = (async () => {
@@ -313,14 +323,17 @@ async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<Map<str · 20 unmodified lines
313	const discover = createDiscoverTool([...merged.values()]);	323	const discover = createDiscoverTool([...merged.values()]);
314	merged.set(discover.path, discover);	324	merged.set(discover.path, discover);
315		325
		326	const dtsStorageIds = (cacheEntry.dtsStorageIds ?? []) as DtsStorageEntry[];
		327
316	workspaceToolCache.set(workspaceId, {	328	workspaceToolCache.set(workspaceId, {
317	signature,	329	signature,
318	loadedAt: Date.now(),	330	loadedAt: Date.now(),
319	tools: merged,	331	tools: merged,
320	warnings: snapshot.warnings,	332	warnings: snapshot.warnings,
		333	dtsStorageIds,
321	});	334	});
322		335
323	return { tools: merged, warnings: snapshot.warnings };	336	return { tools: merged, warnings: snapshot.warnings, dtsStorageIds };
324	}	337	}
325	}	338	}
326	} catch (error) {	339	} catch (error) {
@@ -356,20 +369,43 @@ async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<Map<str · 29 unmodified lines
356	const discover = createDiscoverTool([...merged.values()]);	369	const discover = createDiscoverTool([...merged.values()]);
357	merged.set(discover.path, discover);	370	merged.set(discover.path, discover);
358		371
359	workspaceToolCache.set(workspaceId, {
360	signature,
361	loadedAt: Date.now(),
362	tools: merged,
363	warnings,
364	});
365
366	// ── Write to persistent workspace cache (best-effort) ─────────────	372	// ── Write to persistent workspace cache (best-effort) ─────────────
		373	let dtsStorageIds: DtsStorageEntry[] = [];
367	try {	374	try {
368	const allTools = [...merged.values()];	375	const allTools = [...merged.values()];
		376
		377	// Extract and store .d.ts blobs per source (too large for action responses)
		378	const seenDtsSources = new Set<string>();
		379	const dtsEntries: { sourceKey: string; content: string }[] = [];
		380	for (const tool of allTools) {
		381	if (tool.metadata?.sourceDts && tool.source && !seenDtsSources.has(tool.source)) {
		382	seenDtsSources.add(tool.source);
		383	dtsEntries.push({ sourceKey: tool.source, content: tool.metadata.sourceDts });
		384	}
		385	}
		386
		387	// Store .d.ts blobs in parallel
		388	const storedDts = await Promise.all(
		389	dtsEntries.map(async (entry) => {
		390	const dtsBlob = new Blob([entry.content], { type: "text/plain" });
		391	const sid = await ctx.storage.store(dtsBlob);
		392	return { sourceKey: entry.sourceKey, storageId: String(sid) };
		393	}),
		394	);
		395	dtsStorageIds = storedDts;
		396
		397	// Strip sourceDts from serialized tools (it's stored separately)
369	const snapshot: WorkspaceToolSnapshot = {	398	const snapshot: WorkspaceToolSnapshot = {
370	tools: serializeTools(allTools),	399	tools: serializeTools(allTools),
371	warnings,	400	warnings,
372	};	401	};
		402	// Remove sourceDts from the serialized snapshot to keep it small
		403	for (const st of snapshot.tools) {
		404	if (st.metadata?.sourceDts) {
		405	delete (st.metadata as Record<string, unknown>).sourceDts;
		406	}
		407	}
		408
373	const json = JSON.stringify(snapshot);	409	const json = JSON.stringify(snapshot);
374	const blob = new Blob([json], { type: "application/json" });	410	const blob = new Blob([json], { type: "application/json" });
375	const storageId = await ctx.storage.store(blob);	411	const storageId = await ctx.storage.store(blob);
@@ -377,6 +413,7 @@ async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<Map<str · 1 unmodified line
377	workspaceId,	413	workspaceId,
378	signature,	414	signature,
379	storageId,	415	storageId,
		416	dtsStorageIds: storedDts.map((e) => ({ sourceKey: e.sourceKey, storageId: e.storageId as any })),
380	toolCount: allTools.length,	417	toolCount: allTools.length,
381	sizeBytes: json.length,	418	sizeBytes: json.length,
382	});	419	});
@@ -385,14 +422,22 @@ async function getWorkspaceTools(ctx: any, workspaceId: string): Promise<Map<str · 2 unmodified lines
385	console.warn(`[executor] workspace tool cache write failed for '${workspaceId}': ${msg}`);	422	console.warn(`[executor] workspace tool cache write failed for '${workspaceId}': ${msg}`);
386	}	423	}
387		424
388	return { tools: merged, warnings };	425	workspaceToolCache.set(workspaceId, {
		426	signature,
		427	loadedAt: Date.now(),
		428	tools: merged,
		429	warnings,
		430	dtsStorageIds,
		431	});
		432
		433	return { tools: merged, warnings, dtsStorageIds };
389	})();	434	})();
390		435
391	workspaceToolLoadsInFlight.set(workspaceId, { signature, promise: loadPromise });	436	workspaceToolLoadsInFlight.set(workspaceId, { signature, promise: loadPromise });
392		437
393	try {	438	try {
394	const loaded = await loadPromise;	439	const loaded = await loadPromise;
395	return loaded.tools;	440	return { tools: loaded.tools, dtsStorageIds: loaded.dtsStorageIds };
396	} finally {	441	} finally {
397	const current = workspaceToolLoadsInFlight.get(workspaceId);	442	const current = workspaceToolLoadsInFlight.get(workspaceId);
398	if (current?.promise === loadPromise) {	443	if (current?.promise === loadPromise) {
@@ -442,6 +487,10 @@ function toToolDescriptor(tool: ToolDefinition, approval: "auto" \| "required"): · 43 unmodified lines
442	source: tool.source,	487	source: tool.source,
443	argsType: tool.metadata?.argsType,	488	argsType: tool.metadata?.argsType,
444	returnsType: tool.metadata?.returnsType,	489	returnsType: tool.metadata?.returnsType,
		490	operationId: tool.metadata?.operationId,
		491	// Note: sourceDts is NOT included — it's too large to send over the wire.
		492	// Monaco fetches .d.ts blobs separately via Convex storage URLs.
		493	// Legacy compat
445	schemaTypes: tool.metadata?.schemaTypes,	494	schemaTypes: tool.metadata?.schemaTypes,
446	};	495	};
447	}	496	}
@@ -464,6 +513,53 @@ function listVisibleToolDescriptors( · 16 unmodified lines
464	});	513	});
465	}	514	}
466		515
		516	async function listToolsForContext(
		517	ctx: any,
		518	context: { workspaceId: string; actorId?: string; clientId?: string },
		519	): Promise<ToolDescriptor[]> {
		520	const [result, policies] = await Promise.all([
		521	getWorkspaceTools(ctx, context.workspaceId),
		522	ctx.runQuery(internal.database.listAccessPolicies, { workspaceId: context.workspaceId }),
		523	]);
		524	const typedPolicies = policies as AccessPolicyRecord[];
		525
		526	return listVisibleToolDescriptors(result.tools, context, typedPolicies);
		527	}
		528
		529	async function listToolsWithWarningsForContext(
		530	ctx: any,
		531	context: { workspaceId: string; actorId?: string; clientId?: string },
		532	): Promise<{ tools: ToolDescriptor[]; warnings: string[]; dtsUrls: Record<string, string> }> {
		533	const [result, policies] = await Promise.all([
		534	getWorkspaceTools(ctx, context.workspaceId),
		535	ctx.runQuery(internal.database.listAccessPolicies, { workspaceId: context.workspaceId }),
		536	]);
		537	const typedPolicies = policies as AccessPolicyRecord[];
		538	const tools = listVisibleToolDescriptors(result.tools, context, typedPolicies);
		539	const cachedEntry = workspaceToolCache.get(context.workspaceId);
		540
		541	// Generate download URLs for .d.ts blobs
		542	const dtsUrls: Record<string, string> = {};
		543	for (const entry of result.dtsStorageIds) {
		544	try {
		545	const url = await ctx.storage.getUrl(entry.storageId);
		546	if (url) dtsUrls[entry.sourceKey] = url;
		547	} catch {
		548	// Storage ID may be stale — skip
		549	}
		550	}
		551
		552	return {
		553	tools,
		554	warnings: cachedEntry?.warnings ?? [],
		555	dtsUrls,
		556	};
		557	}
		558
		559	function actorIdForAccount(account: { _id: string; provider: string; providerAccountId: string }): string {
		560	return account.provider === "anonymous" ? account.providerAccountId : account._id;
		561	}
		562
467	function isToolAllowedForTask(	563	function isToolAllowedForTask(
468	task: TaskRecord,	564	task: TaskRecord,
469	toolPath: string,	565	toolPath: string,
@@ -480,7 +576,7 @@ async function resolveCredentialHeaders( · 10 unmodified lines
480	spec: ToolCredentialSpec,	576	spec: ToolCredentialSpec,
481	task: TaskRecord,	577	task: TaskRecord,
482	): Promise<ResolvedToolCredential \| null> {	578	): Promise<ResolvedToolCredential \| null> {
483	const record = await ctx.runQuery(api.database.resolveCredential, {	579	const record = await ctx.runQuery(internal.database.resolveCredential, {
484	workspaceId: task.workspaceId,	580	workspaceId: task.workspaceId,
485	sourceKey: spec.sourceKey,	581	sourceKey: spec.sourceKey,
486	scope: spec.mode as CredentialScope,	582	scope: spec.mode as CredentialScope,
@@ -580,13 +676,14 @@ function getGraphqlDecision( · 93 unmodified lines
580		676
581	async function invokeTool(ctx: any, task: TaskRecord, call: ToolCallRequest): Promise<unknown> {	677	async function invokeTool(ctx: any, task: TaskRecord, call: ToolCallRequest): Promise<unknown> {
582	const { toolPath, input, callId } = call;	678	const { toolPath, input, callId } = call;
583	const policies = await ctx.runQuery(api.database.listAccessPolicies, { workspaceId: task.workspaceId });	679	const policies = await ctx.runQuery(internal.database.listAccessPolicies, { workspaceId: task.workspaceId });
584	const typedPolicies = policies as AccessPolicyRecord[];	680	const typedPolicies = policies as AccessPolicyRecord[];
585		681
586	let workspaceTools: Map<string, ToolDefinition> \| undefined;	682	let workspaceTools: Map<string, ToolDefinition> \| undefined;
587	let tool = baseTools.get(toolPath);	683	let tool = baseTools.get(toolPath);
588	if (!tool) {	684	if (!tool) {
589	workspaceTools = await getWorkspaceTools(ctx, task.workspaceId);	685	const result = await getWorkspaceTools(ctx, task.workspaceId);
		686	workspaceTools = result.tools;
590	tool = workspaceTools.get(toolPath);	687	tool = workspaceTools.get(toolPath);
591	}	688	}
592		689
@@ -598,7 +695,8 @@ async function invokeTool(ctx: any, task: TaskRecord, call: ToolCallRequest): Pr · 5 unmodified lines
598	let effectiveToolPath = toolPath;	695	let effectiveToolPath = toolPath;
599	if (tool._graphqlSource) {	696	if (tool._graphqlSource) {
600	if (!workspaceTools) {	697	if (!workspaceTools) {
601	workspaceTools = await getWorkspaceTools(ctx, task.workspaceId);	698	const result = await getWorkspaceTools(ctx, task.workspaceId);
		699	workspaceTools = result.tools;
602	}	700	}
603	const result = getGraphqlDecision(task, tool, input, workspaceTools, typedPolicies);	701	const result = getGraphqlDecision(task, tool, input, workspaceTools, typedPolicies);
604	decision = result.decision;	702	decision = result.decision;
@@ -637,7 +735,7 @@ async function invokeTool(ctx: any, task: TaskRecord, call: ToolCallRequest): Pr · 32 unmodified lines
637	});	735	});
638		736
639	if (decision === "require_approval") {	737	if (decision === "require_approval") {
640	const approval = await ctx.runMutation(api.database.createApproval, {	738	const approval = await ctx.runMutation(internal.database.createApproval, {
641	id: createApprovalId(),	739	id: createApprovalId(),
642	taskId: task.id,	740	taskId: task.id,
643	toolPath: effectiveToolPath,	741	toolPath: effectiveToolPath,
@@ -696,60 +794,84 @@ async function invokeTool(ctx: any, task: TaskRecord, call: ToolCallRequest): Pr · 52 unmodified lines
696		794
697	export const listTools = action({	795	export const listTools = action({
698	args: {	796	args: {
699	workspaceId: v.optional(v.string()),	797	workspaceId: v.string(),
700	actorId: v.optional(v.string()),	798	actorId: v.optional(v.string()),
701	clientId: v.optional(v.string()),	799	clientId: v.optional(v.string()),
		800	sessionId: v.optional(v.string()),
702	},	801	},
703	handler: async (ctx, args): Promise<ToolDescriptor[]> => {	802	handler: async (ctx, args): Promise<ToolDescriptor[]> => {
704	if (!args.workspaceId) {	803	const access = await ctx.runQuery(internal.workspaceAuthInternal.getWorkspaceAccessForRequest, {
705	return [...baseTools.values()].map((tool) => toToolDescriptor(tool, tool.approval));	804	workspaceId: args.workspaceId,
		805	sessionId: args.sessionId,
		806	});
		807	const canonicalActorId = actorIdForAccount({
		808	_id: access.accountId,
		809	provider: access.provider,
		810	providerAccountId: access.providerAccountId,
		811	});
		812	if (args.actorId && args.actorId !== canonicalActorId) {
		813	throw new Error("actorId must match the authenticated workspace actor");
706	}	814	}
707		815
708	const [workspaceTools, policies] = await Promise.all([	816	return await listToolsForContext(ctx, {
709	getWorkspaceTools(ctx, args.workspaceId),	817	workspaceId: args.workspaceId,
710	ctx.runQuery(api.database.listAccessPolicies, { workspaceId: args.workspaceId }),	818	actorId: canonicalActorId,
711	]);	819	clientId: args.clientId,
712	const typedPolicies = policies as AccessPolicyRecord[];	820	});
713
714	return listVisibleToolDescriptors(
715	workspaceTools,
716	args as { workspaceId: string; actorId?: string; clientId?: string },
717	typedPolicies,
718	);
719	},	821	},
720	});	822	});
721		823
722	export const listToolsWithWarnings = action({	824	export const listToolsWithWarnings = action({
723	args: {	825	args: {
724	workspaceId: v.optional(v.string()),	826	workspaceId: v.string(),
725	actorId: v.optional(v.string()),	827	actorId: v.optional(v.string()),
726	clientId: v.optional(v.string()),	828	clientId: v.optional(v.string()),
		829	sessionId: v.optional(v.string()),
727	},	830	},
728	handler: async (	831	handler: async (
729	ctx,	832	ctx,
730	args,	833	args,
731	): Promise<{ tools: ToolDescriptor[]; warnings: string[] }> => {	834	): Promise<{ tools: ToolDescriptor[]; warnings: string[]; dtsUrls: Record<string, string> }> => {
732	if (!args.workspaceId) {	835	const access = await ctx.runQuery(internal.workspaceAuthInternal.getWorkspaceAccessForRequest, {
733	return {	836	workspaceId: args.workspaceId,
734	tools: [...baseTools.values()].map((tool) => toToolDescriptor(tool, tool.approval)),	837	sessionId: args.sessionId,
735	warnings: [],	838	});
736	};	839	const canonicalActorId = actorIdForAccount({
		840	_id: access.accountId,
		841	provider: access.provider,
		842	providerAccountId: access.providerAccountId,
		843	});
		844	if (args.actorId && args.actorId !== canonicalActorId) {
		845	throw new Error("actorId must match the authenticated workspace actor");
737	}	846	}
738		847
739	const [workspaceTools, policies] = await Promise.all([	848	return await listToolsWithWarningsForContext(ctx, {
740	getWorkspaceTools(ctx, args.workspaceId),	849	workspaceId: args.workspaceId,
741	ctx.runQuery(api.database.listAccessPolicies, { workspaceId: args.workspaceId }),	850	actorId: canonicalActorId,
742	]);	851	clientId: args.clientId,
743	const typedPolicies = policies as AccessPolicyRecord[];	852	});
744		853	},
745	return {	854	});
746	tools: listVisibleToolDescriptors(	855
747	workspaceTools,	856	export const listToolsInternal = internalAction({
748	args as { workspaceId: string; actorId?: string; clientId?: string },	857	args: {
749	typedPolicies,	858	workspaceId: v.string(),
750	),	859	actorId: v.optional(v.string()),
751	warnings: workspaceToolCache.get(args.workspaceId)?.warnings ?? [],	860	clientId: v.optional(v.string()),
752	};	861	},
		862	handler: async (ctx, args): Promise<ToolDescriptor[]> => {
		863	return await listToolsForContext(ctx, args);
		864	},
		865	});
		866
		867	export const listToolsWithWarningsInternal = internalAction({
		868	args: {
		869	workspaceId: v.string(),
		870	actorId: v.optional(v.string()),
		871	clientId: v.optional(v.string()),
		872	},
		873	handler: async (ctx, args): Promise<{ tools: ToolDescriptor[]; warnings: string[]; dtsUrls: Record<string, string> }> => {
		874	return await listToolsWithWarningsForContext(ctx, args);
753	},	875	},
754	});	876	});
755		877
@@ -761,7 +883,7 @@ export const handleExternalToolCall = internalAction({ · 5 unmodified lines
761	input: v.optional(v.any()),	883	input: v.optional(v.any()),
762	},	884	},
763	handler: async (ctx, args): Promise<ToolCallResult> => {	885	handler: async (ctx, args): Promise<ToolCallResult> => {
764	const task = (await ctx.runQuery(api.database.getTask, {	886	const task = (await ctx.runQuery(internal.database.getTask, {
765	taskId: args.runId,	887	taskId: args.runId,
766	})) as TaskRecord \| null;	888	})) as TaskRecord \| null;
767	if (!task) {	889	if (!task) {
@@ -800,13 +922,13 @@ export const handleExternalToolCall = internalAction({ · 32 unmodified lines
800	export const runTask = internalAction({	922	export const runTask = internalAction({
801	args: { taskId: v.string() },	923	args: { taskId: v.string() },
802	handler: async (ctx, args) => {	924	handler: async (ctx, args) => {
803	const task = (await ctx.runQuery(api.database.getTask, { taskId: args.taskId })) as TaskRecord \| null;	925	const task = (await ctx.runQuery(internal.database.getTask, { taskId: args.taskId })) as TaskRecord \| null;
804	if (!task \|\| task.status !== "queued") {	926	if (!task \|\| task.status !== "queued") {
805	return null;	927	return null;
806	}	928	}
807		929
808	if (task.runtimeId !== "local-bun") {	930	if (task.runtimeId !== "local-bun") {
809	const failed = await ctx.runMutation(api.database.markTaskFinished, {	931	const failed = await ctx.runMutation(internal.database.markTaskFinished, {
810	taskId: args.taskId,	932	taskId: args.taskId,
811	status: "failed",	933	status: "failed",
812	stdout: "",	934	stdout: "",
@@ -825,7 +947,7 @@ export const runTask = internalAction({ · 12 unmodified lines
825	}	947	}
826		948
827	try {	949	try {
828	const running = (await ctx.runMutation(api.database.markTaskRunning, {	950	const running = (await ctx.runMutation(internal.database.markTaskRunning, {
829	taskId: args.taskId,	951	taskId: args.taskId,
830	})) as TaskRecord \| null;	952	})) as TaskRecord \| null;
831	if (!running) {	953	if (!running) {
@@ -860,7 +982,7 @@ export const runTask = internalAction({ · 28 unmodified lines
860	adapter,	982	adapter,
861	);	983	);
862		984
863	const finished = await ctx.runMutation(api.database.markTaskFinished, {	985	const finished = await ctx.runMutation(internal.database.markTaskFinished, {
864	taskId: args.taskId,	986	taskId: args.taskId,
865	status: runtimeResult.status,	987	status: runtimeResult.status,
866	stdout: runtimeResult.stdout,	988	stdout: runtimeResult.stdout,
@@ -893,7 +1015,7 @@ export const runTask = internalAction({ · 26 unmodified lines
893	} catch (error) {	1015	} catch (error) {
894	const message = describeError(error);	1016	const message = describeError(error);
895	const denied = message.startsWith(APPROVAL_DENIED_PREFIX);	1017	const denied = message.startsWith(APPROVAL_DENIED_PREFIX);
896	const finished = await ctx.runMutation(api.database.markTaskFinished, {	1018	const finished = await ctx.runMutation(internal.database.markTaskFinished, {
897	taskId: args.taskId,	1019	taskId: args.taskId,
898	status: denied ? "denied" : "failed",	1020	status: denied ? "denied" : "failed",
899	stdout: "",	1021	stdout: "",

executor/convex/http.ts+55−15

 import { registerRoutes as registerStripeRoutes } from "@convex-dev/stripe";
 import { createRemoteJWKSet, jwtVerify } from "jose";
 import { httpRouter } from "convex/server";
-import { api, components, internal } from "./_generated/api";
+import { components, internal } from "./_generated/api";
 import { httpAction } from "./_generated/server";
 import { authKit } from "./auth";
 import { handleMcpRequest, type McpWorkspaceContext } from "./lib/mcp_server";
 import type { AnonymousContext, PendingApprovalRecord, TaskRecord, ToolDescriptor } from "./lib/types";
 const http = httpRouter();
-const internalToken = process.env.EXECUTOR_INTERNAL_TOKEN ?? "executor_internal_local_dev_token";
+const internalToken = process.env.EXECUTOR_INTERNAL_TOKEN ?? null;
 const mcpAuthorizationServer =
   process.env.MCP_AUTHORIZATION_SERVER
   ?? process.env.MCP_AUTHORIZATION_SERVER_URL
   }
 }
-function parseMcpContext(url: URL, tokenSubject?: string): McpWorkspaceContext | undefined {
+function parseMcpContext(url: URL, tokenSubject?: string): (McpWorkspaceContext & { sessionId?: string }) | undefined {
   const workspaceId = url.searchParams.get("workspaceId");
   const actorId = tokenSubject ?? url.searchParams.get("actorId");
   if (!workspaceId || !actorId) return undefined;
   const clientId = url.searchParams.get("clientId") ?? undefined;
-  return { workspaceId, actorId, clientId };
+  const sessionId = url.searchParams.get("sessionId") ?? undefined;
+  return { workspaceId, actorId, clientId, sessionId };
 }
 function isInternalAuthorized(request: Request): boolean {
-  if (!internalToken) return true;
+  if (!internalToken) return false;
   const header = request.headers.get("authorization");
   if (!header || !header.startsWith("Bearer ")) return false;
   return header.slice("Bearer ".length) === internalToken;
   }
   const tokenSubject = mcpAuthEnabled ? auth.subject : undefined;
-  const context = parseMcpContext(url, tokenSubject);
+  const requestedContext = parseMcpContext(url, tokenSubject);
-  if (mcpAuthEnabled && !context) {
+  if (mcpAuthEnabled && !requestedContext) {
     return Response.json(
       { error: "workspaceId query parameter is required when MCP OAuth is enabled" },
       { status: 400 },
     );
   }
+  let context: McpWorkspaceContext | undefined;
+  if (requestedContext) {
+    try {
+      if (mcpAuthEnabled) {
+        const access = await ctx.runQuery(internal.workspaceAuthInternal.getWorkspaceAccessForWorkosSubject, {
+          workspaceId: requestedContext.workspaceId,
+          subject: auth.subject,
+        });
+        context = {
+          workspaceId: requestedContext.workspaceId,
+          actorId: access.actorId,
+          clientId: requestedContext.clientId,
+        };
+      } else {
+        const access = await ctx.runQuery(internal.workspaceAuthInternal.getWorkspaceAccessForRequest, {
+          workspaceId: requestedContext.workspaceId,
+          sessionId: requestedContext.sessionId,
+        });
+        context = {
+          workspaceId: requestedContext.workspaceId,
+          actorId: access.actorId,
+          clientId: requestedContext.clientId,
+          sessionId: requestedContext.sessionId,
+        };
+      }
+    } catch (error) {
+      return Response.json(
+        { error: error instanceof Error ? error.message : "Workspace authorization failed" },
+        { status: 403 },
+      );
+    }
+  }
   const service = {
     createTask: async (input: {
       code: string;
       actorId: string;
       clientId?: string;
     }) => {
-      return (await ctx.runMutation(api.executor.createTask, input)) as { task: TaskRecord };
+      return (await ctx.runMutation(internal.executor.createTaskInternal, input)) as { task: TaskRecord };
     },
     getTask: async (taskId: string, workspaceId?: string) => {
       if (workspaceId) {
-        return (await ctx.runQuery(api.database.getTaskInWorkspace, { taskId, workspaceId })) as TaskRecord | null;
+        return (await ctx.runQuery(internal.database.getTaskInWorkspace, { taskId, workspaceId })) as TaskRecord | null;
       }
-      return (await ctx.runQuery(api.database.getTask, { taskId })) as TaskRecord | null;
+      return null;
     },
     subscribe: () => {
       return () => {};
     },
     bootstrapAnonymousContext: async (sessionId?: string) => {
-      return (await ctx.runMutation(api.database.bootstrapAnonymousSession, { sessionId })) as AnonymousContext;
+      return (await ctx.runMutation(internal.database.bootstrapAnonymousSession, { sessionId })) as AnonymousContext;
     },
     listTools: async (toolContext?: { workspaceId: string; actorId?: string; clientId?: string }) => {
-      return (await ctx.runAction(api.executorNode.listTools, toolContext ?? {})) as ToolDescriptor[];
+      if (!toolContext) {
+        return [];
+      }
+      return (await ctx.runAction(internal.executorNode.listToolsInternal, toolContext)) as ToolDescriptor[];
     },
     listPendingApprovals: async (workspaceId: string) => {
-      return (await ctx.runQuery(api.database.listPendingApprovals, { workspaceId })) as PendingApprovalRecord[];
+      return (await ctx.runQuery(internal.database.listPendingApprovals, { workspaceId })) as PendingApprovalRecord[];
     },
     resolveApproval: async (input: {
       workspaceId: string;
       reviewerId?: string;
       reason?: string;
     }) => {
-      return await ctx.runMutation(api.executor.resolveApproval, input);
+      return await ctx.runMutation(internal.executor.resolveApprovalInternal, input);
     },
   };
     return Response.json({ error: "stream and line are required" }, { status: 400 });
   }
-  const task = await ctx.runQuery(api.database.getTask, { taskId: parsed.runId });
+  const task = await ctx.runQuery(internal.database.getTask, { taskId: parsed.runId });
   if (!task) {
     return Response.json({ error: `Run not found: ${parsed.runId}` }, { status: 404 });
   }

executor/convex/lib/anonymousSession.ts+24−0

@@ -0,0 +1,24 @@
	1	const DAY_MS = 24 * 60 * 60 * 1000;
	2
	3	function parsePositiveInt(value: string \| undefined, fallback: number): number {
	4	const parsed = Number.parseInt(value ?? "", 10);
	5	if (!Number.isFinite(parsed) \|\| parsed <= 0) {
	6	return fallback;
	7	}
	8	return parsed;
	9	}
	10
	11	export const ANONYMOUS_SESSION_TTL_MS = parsePositiveInt(
	12	process.env.ANONYMOUS_SESSION_TTL_MS,
	13	14 * DAY_MS,
	14	);
	15
	16	export function resolveAnonymousSessionExpiresAt(session: {
	17	createdAt: number;
	18	expiresAt?: number;
	19	}): number {
	20	if (typeof session.expiresAt === "number") {
	21	return session.expiresAt;
	22	}
	23	return session.createdAt + ANONYMOUS_SESSION_TTL_MS;
	24	}

executor/convex/lib/functionBuilders.ts+57−1

@@ -1,7 +1,17 @@
1	import { v } from "convex/values";	1	import { v } from "convex/values";
2	import { customMutation, customQuery } from "convex-helpers/server/customFunctions";	2	import { customMutation, customQuery } from "convex-helpers/server/customFunctions";
3	import { internalQuery, mutation, query } from "../_generated/server";	3	import { internalQuery, mutation, query } from "../_generated/server";
4	import { canManageBilling, getOrganizationMembership, isAdminRole, resolveAccountForRequest } from "./identity";	4	import {
		5	canManageBilling,
		6	getOrganizationMembership,
		7	isAdminRole,
		8	requireWorkspaceAccessForRequest,
		9	resolveAccountForRequest,
		10	} from "./identity";
		11
		12	type WorkspaceAccessOptions = {
		13	requireAdmin?: boolean;
		14	};
5		15
6	type OrganizationAccessOptions = {	16	type OrganizationAccessOptions = {
7	requireAdmin?: boolean;	17	requireAdmin?: boolean;
@@ -18,6 +28,12 @@ function ensureOrganizationRole(role: string, options: OrganizationAccessOptions · 10 unmodified lines
18	}	28	}
19	}	29	}
20		30
		31	function ensureWorkspaceRole(role: string, options: WorkspaceAccessOptions): void {
		32	if (options.requireAdmin && !isAdminRole(role)) {
		33	throw new Error("Only workspace admins can perform this action");
		34	}
		35	}
		36
21	async function requireAccountFromSession(	37	async function requireAccountFromSession(
22	ctx: Parameters<typeof resolveAccountForRequest>[0],	38	ctx: Parameters<typeof resolveAccountForRequest>[0],
23	sessionId?: string,	39	sessionId?: string,
@@ -120,6 +136,46 @@ export const organizationMutation = customMutation(mutation, { · 96 unmodified lines
120	},	136	},
121	});	137	});
122		138
		139	export const workspaceQuery = customQuery(query, {
		140	args: {
		141	workspaceId: v.string(),
		142	sessionId: v.optional(v.string()),
		143	},
		144	input: async (ctx, args, options: WorkspaceAccessOptions = {}) => {
		145	const access = await requireWorkspaceAccessForRequest(ctx, args.workspaceId, args.sessionId);
		146
		147	ensureWorkspaceRole(access.workspaceMembership.role, options);
		148
		149	return {
		150	ctx: {
		151	...access,
		152	workspaceId: args.workspaceId,
		153	},
		154	args: {},
		155	};
		156	},
		157	});
		158
		159	export const workspaceMutation = customMutation(mutation, {
		160	args: {
		161	workspaceId: v.string(),
		162	sessionId: v.optional(v.string()),
		163	},
		164	input: async (ctx, args, options: WorkspaceAccessOptions = {}) => {
		165	const access = await requireWorkspaceAccessForRequest(ctx, args.workspaceId, args.sessionId);
		166
		167	ensureWorkspaceRole(access.workspaceMembership.role, options);
		168
		169	return {
		170	ctx: {
		171	...access,
		172	workspaceId: args.workspaceId,
		173	},
		174	args: {},
		175	};
		176	},
		177	});
		178
123	export const internalOrganizationQuery = customQuery(internalQuery, {	179	export const internalOrganizationQuery = customQuery(internalQuery, {
124	args: {	180	args: {
125	organizationId: v.id("organizations"),	181	organizationId: v.id("organizations"),

executor/convex/lib/identity.ts+98−0

@@ -4,6 +4,26 @@ import type { MutationCtx, QueryCtx } from "../_generated/server"; · 3 unmodified lines
4	type IdentityCtx = Pick<QueryCtx, "auth" \| "db"> \| Pick<MutationCtx, "auth" \| "db">;	4	type IdentityCtx = Pick<QueryCtx, "auth" \| "db"> \| Pick<MutationCtx, "auth" \| "db">;
5	type MembershipCtx = Pick<QueryCtx, "db"> \| Pick<MutationCtx, "db">;	5	type MembershipCtx = Pick<QueryCtx, "db"> \| Pick<MutationCtx, "db">;
6		6
		7	type WorkspaceAccessMembership = Pick<Doc<"workspaceMembers">, "role" \| "status">;
		8
		9	function mapOrganizationRoleToWorkspaceRole(
		10	role: Doc<"organizationMembers">["role"],
		11	): Doc<"workspaceMembers">["role"] {
		12	if (role === "owner") {
		13	return "owner";
		14	}
		15	if (role === "admin") {
		16	return "admin";
		17	}
		18	return "member";
		19	}
		20
		21	export type WorkspaceAccess = {
		22	account: Doc<"accounts">;
		23	workspace: Doc<"workspaces">;
		24	workspaceMembership: WorkspaceAccessMembership;
		25	};
		26
7	export function slugify(input: string): string {	27	export function slugify(input: string): string {
8	const slug = input	28	const slug = input
9	.toLowerCase()	29	.toLowerCase()
@@ -42,6 +62,20 @@ export async function resolveAccountForRequest( · 32 unmodified lines
42	return null;	62	return null;
43	}	63	}
44		64
		65	export async function resolveWorkosAccountBySubject(
		66	ctx: MembershipCtx,
		67	subject: string,
		68	): Promise<Doc<"accounts"> \| null> {
		69	if (!subject.trim()) {
		70	return null;
		71	}
		72
		73	return await ctx.db
		74	.query("accounts")
		75	.withIndex("by_provider", (q) => q.eq("provider", "workos").eq("providerAccountId", subject))
		76	.unique();
		77	}
		78
45	export async function getOrganizationMembership(	79	export async function getOrganizationMembership(
46	ctx: MembershipCtx,	80	ctx: MembershipCtx,
47	organizationId: Id<"organizations">,	81	organizationId: Id<"organizations">,
@@ -53,6 +87,70 @@ export async function getOrganizationMembership( · 5 unmodified lines
53	.unique();	87	.unique();
54	}	88	}
55		89
		90	export async function getWorkspaceMembership(
		91	ctx: MembershipCtx,
		92	workspaceId: Id<"workspaces">,
		93	accountId: Id<"accounts">,
		94	) {
		95	return await ctx.db
		96	.query("workspaceMembers")
		97	.withIndex("by_workspace_account", (q) => q.eq("workspaceId", workspaceId).eq("accountId", accountId))
		98	.unique();
		99	}
		100
		101	export async function requireWorkspaceAccessForAccount(
		102	ctx: MembershipCtx,
		103	workspaceId: string,
		104	account: Doc<"accounts">,
		105	): Promise<WorkspaceAccess> {
		106	const workspace = await ctx.db.get(workspaceId as Id<"workspaces">);
		107	if (!workspace) {
		108	throw new Error("Workspace not found");
		109	}
		110
		111	const workspaceMembership = await getWorkspaceMembership(ctx, workspace._id, account._id);
		112	if (workspaceMembership) {
		113	if (workspaceMembership.status !== "active") {
		114	throw new Error("You are not a member of this workspace");
		115	}
		116
		117	return {
		118	account,
		119	workspace,
		120	workspaceMembership,
		121	};
		122	}
		123
		124	const organizationMembership = await getOrganizationMembership(ctx, workspace.organizationId, account._id);
		125	if (!organizationMembership \|\| organizationMembership.status !== "active") {
		126	throw new Error("You are not a member of this workspace");
		127	}
		128
		129	const derivedWorkspaceMembership: WorkspaceAccessMembership = {
		130	role: mapOrganizationRoleToWorkspaceRole(organizationMembership.role),
		131	status: "active",
		132	};
		133
		134	return {
		135	account,
		136	workspace,
		137	workspaceMembership: derivedWorkspaceMembership,
		138	};
		139	}
		140
		141	export async function requireWorkspaceAccessForRequest(
		142	ctx: IdentityCtx,
		143	workspaceId: string,
		144	sessionId?: string,
		145	): Promise<WorkspaceAccess> {
		146	const account = await resolveAccountForRequest(ctx, sessionId);
		147	if (!account) {
		148	throw new Error("Must be signed in");
		149	}
		150
		151	return await requireWorkspaceAccessForAccount(ctx, workspaceId, account);
		152	}
		153
56	export function isAdminRole(role: string): boolean {	154	export function isAdminRole(role: string): boolean {
57	return role === "owner" \|\| role === "admin";	155	return role === "owner" \|\| role === "admin";
58	}	156	}

executor/convex/lib/mcp_server.ts+2−12

   workspaceId: string;
   actorId: string;
   clientId?: string;
+  sessionId?: string;
 }
 // ---------------------------------------------------------------------------
       timeoutMs?: number;
       runtimeId?: string;
       metadata?: Record<string, unknown>;
-      workspaceId?: string;
-      actorId?: string;
       clientId?: string;
       sessionId?: string;
       waitForResult?: boolean;
     let context: { workspaceId: string; actorId: string; clientId?: string; sessionId?: string };
     if (boundContext) {
-      context = { ...boundContext, sessionId: input.sessionId };
+      context = { ...boundContext, sessionId: input.sessionId ?? boundContext.sessionId };
-    } else if (input.workspaceId && input.actorId) {
-      context = {
-        workspaceId: input.workspaceId,
-        actorId: input.actorId,
-        clientId: input.clientId,
-        sessionId: input.sessionId,
-      };
     } else {
       const seededSessionId = input.sessionId ?? (extra.sessionId ? `mcp_${extra.sessionId}` : undefined);
       const anonymous = await service.bootstrapAnonymousContext(seededSessionId);
   timeoutMs: z.number().int().min(1).max(600_000).optional(),
   runtimeId: z.string().optional(),
   metadata: z.record(z.string(), z.any()).optional(),
-  workspaceId: z.string().optional(),
-  actorId: z.string().optional(),
   clientId: z.string().optional(),
   sessionId: z.string().optional(),
   waitForResult: z.boolean().optional(),

executor/convex/lib/openapi-real-specs.test.ts+18−6

     name: "cloudflare",
     url: "https://raw.githubusercontent.com/cloudflare/api-schemas/main/openapi.yaml",
     minPaths: 500,
-    // openapiTS fails on broken discriminator $ref mappings in this spec
+    // Cloudflare has broken discriminator $ref mappings but generateOpenApiDts
-    expectDts: false,
+    // now auto-patches them, so DTS generation succeeds.
+    expectDts: true,
   },
   {
     name: "sentry",
           expect(tool.metadata!.returnsType).toBeDefined();
         }
-        // If we have .d.ts, at least some tools should have richer types than "unknown"
+        // If we have .d.ts, tools should carry operationId + sourceDts for typechecking
         if (fixture.expectDts) {
-          const withRichReturns = tools.filter(
+          // At least some tools should have operationId set
-            (t) => t.metadata!.returnsType !== "unknown",
+          const withOperationId = tools.filter(
+            (t) => t.metadata!.operationId != null,
           );
-          expect(withRichReturns.length).toBeGreaterThan(0);
+          expect(withOperationId.length).toBeGreaterThan(0);
+          // At least one tool per source should carry the raw .d.ts
+          const withSourceDts = tools.filter(
+            (t) => t.metadata!.sourceDts != null && t.metadata!.sourceDts!.length > 0,
+          );
+          expect(withSourceDts.length).toBeGreaterThan(0);
+          // The sourceDts should contain operations interface
+          const dts = withSourceDts[0].metadata!.sourceDts!;
+          expect(dts).toContain("operations");
         }
         if (prepared.warnings.length > 0) {

executor/convex/lib/tool_sources.ts+155−417

@@ -64,389 +64,150 @@ function sanitizeSegment(value: string): string { · 63 unmodified lines
64	return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;	64	return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
65	}	65	}
66		66
67	function isValidTsIdentifier(value: string): boolean {
68	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
69	}
70
71	function formatTsObjectKey(name: string): string {
72	return isValidTsIdentifier(name) ? name : JSON.stringify(name);
73	}
74
75	function toTypeAliasName(schemaName: string, used: Set<string>): string {
76	const raw = schemaName
77	.split(/[^A-Za-z0-9]+/)
78	.filter(Boolean)
79	.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
80	.join("");
81	const base = raw.length > 0 ? raw : "Schema";
82	const prefixed = /^[A-Za-z_]/.test(base) ? base : `Schema${base}`;
83
84	if (!used.has(prefixed)) {
85	used.add(prefixed);
86	return prefixed;
87	}
88
89	let suffix = 2;
90	while (used.has(`${prefixed}${suffix}`)) {
91	suffix += 1;
92	}
93	const unique = `${prefixed}${suffix}`;
94	used.add(unique);
95	return unique;
96	}
97
98	// ── Type generation from OpenAPI specs ──────────────────────────────────────	67	// ── Type generation from OpenAPI specs ──────────────────────────────────────
99	//	68	//
100	// We use `openapiTS(spec)` — the same thing as `npx openapi-typescript` — to	69	// We use `openapiTS(spec)` — the same thing as `npx openapi-typescript` — to
101	// generate a full .d.ts from the spec. This handles $ref resolution, circular	70	// generate a full .d.ts from the spec. The raw .d.ts is stored as-is and
102	// references, discriminators, etc. correctly by emitting named type aliases	71	// passed directly to the typechecker / Monaco, which use TS helper types
103	// instead of inlining everything.	72	// (`ToolInput<operations["X"]>`, `ToolOutput<operations["X"]>`) to extract
104	//	73	// per-operation arg/return types via indexed access. This avoids the need to
105	// From the generated output we extract per-operation type strings. The output	74	// parse the .d.ts with the TS compiler API to extract per-operation type strings.
106	// has a predictable structure:
107	//	75	//
108	// export interface operations {	76	// For the LLM prompt and discover tool, we generate lightweight type hints
109	// operationId: {	77	// from the JSON Schema fallback generator (`jsonSchemaTypeHintFallback`).
110	// parameters: { query: { ... }; path: { ... }; ... };
111	// requestBody?: { content: { "application/json": { ... } } };
112	// responses: { 200: { content: { "application/json": { ... } } } };
113	// };
114	// }
115	//
116	// We parse this with TypeScript's compiler API to extract the parameter,
117	// request body, and response types per operation.
118		78
119	/**	79	/**
120	* Generate a .d.ts string for an OpenAPI spec using openapi-typescript.	80	* Strip discriminators whose `mapping` values reference non-existent `$ref`
		81	* paths in the spec. Some specs (e.g. Cloudflare) ship with broken
		82	* discriminator mappings that cause openapi-typescript to throw. Removing
		83	* only the broken discriminators is enough to unblock codegen while
		84	* preserving all valid discriminators.
121	*	85	*
122	* Accepts a pre-parsed object to avoid a redundant HTTP fetch — the caller	86	* Returns null if no broken discriminators were found (no changes needed).
123	* should have already fetched and parsed the spec.
124	*
125	* Falls back to null on failure (e.g. Swagger 2.0, broken $refs).
126	*/
127	async function generateOpenApiDts(
128	spec: Record<string, unknown>,
129	): Promise<string \| null> {
130	try {
131	const ast = await openapiTS(spec as never, { silent: true });
132	return astToString(ast);
133	} catch (error) {
134	const msg = error instanceof Error ? error.message : String(error);
135	console.warn(`[executor] openapi-typescript failed, using fallback types: ${msg}`);
136	return null;
137	}
138	}
139
140	/**
141	* Extract per-operation types from a .d.ts string.
142	* Wraps the TS compiler AST walk — pure CPU, no I/O.
143	*/	87	*/
144	function extractTypesFromDts(dts: string): ExtractedTypes \| null {	88	function stripBrokenDiscriminators(spec: Record<string, unknown>): Record<string, unknown> \| null {
145	try {	89	let strippedCount = 0;
146	return extractOperationTypes(dts);	90
147	} catch {	91	function refExists(ref: string): boolean {
148	return null;	92	if (!ref.startsWith("#/")) return true; // external ref — assume valid
149	}	93	const segments = ref.slice(2).split("/");
150	}	94	let target: unknown = spec;
151		95	for (const segment of segments) {
152	/** Result of extracting types from a generated .d.ts */	96	if (target && typeof target === "object") {
153	interface ExtractedTypes {	97	target = (target as Record<string, unknown>)[segment];
154	/** Per-operation type strings (operationId → args/returns) */	98	} else {
155	operations: Map<string, { argsType: string; returnsType: string }>;	99	return false;
156	/**	100	}
157	* Schema type aliases referenced by operations. These need to be included
158	* in the typechecker context for the operation types to be valid.
159	* e.g. `{ "Account": "{ id: string; type: string; ... }" }`
160	*/
161	schemas: Map<string, string>;
162	}
163
164	/**
165	* Parse the generated .d.ts to extract per-operation args/returns type strings.
166	* Resolves `components["schemas"]["X"]` references into named type aliases
167	* so the extracted types are self-contained.
168	*/
169	function extractOperationTypes(dts: string): ExtractedTypes {
170	let ts: typeof import("typescript");
171	try {
172	ts = require("typescript");
173	} catch {
174	return { operations: new Map(), schemas: new Map() };
175	}
176
177	const sourceFile = ts.createSourceFile("openapi.d.ts", dts, ts.ScriptTarget.ESNext, true);
178	const operations = new Map<string, { argsType: string; returnsType: string }>();
179
180	// Find the `operations` interface
181	let operationsInterface: import("typescript").InterfaceDeclaration \| undefined;
182	for (const stmt of sourceFile.statements) {
183	if (ts.isInterfaceDeclaration(stmt) && stmt.name.text === "operations") {
184	operationsInterface = stmt;
185	break;
186	}	101	}
187	}	102	return target !== undefined;
188	if (!operationsInterface) return { operations, schemas: new Map() };
189
190	// Extract raw per-operation types (may contain components["schemas"]["..."] refs)
191	for (const member of operationsInterface.members) {
192	if (!ts.isPropertySignature(member) \|\| !member.name) continue;
193	const operationId = ts.isStringLiteral(member.name)
194	? member.name.text
195	: ts.isIdentifier(member.name)
196	? member.name.text
197	: undefined;
198	if (!operationId \|\| !member.type \|\| !ts.isTypeLiteralNode(member.type)) continue;
199
200	const opType = member.type;
201	const argsType = extractArgsType(ts, opType, sourceFile);
202	const returnsType = extractReturnsType(ts, opType, sourceFile);
203
204	operations.set(operationId, { argsType, returnsType });
205	}
206
207	// Collect all referenced schema names from the operation type strings
208	const referencedSchemas = new Set<string>();
209	const refPattern = /components\["schemas"\]\["([^"]+)"\]/g;
210	for (const { argsType, returnsType } of operations.values()) {
211	for (const match of argsType.matchAll(refPattern)) referencedSchemas.add(match[1]!);
212	for (const match of returnsType.matchAll(refPattern)) referencedSchemas.add(match[1]!);
213	}	103	}
214		104
215	// Build schema lookup from the components interface in the .d.ts	105	// Quick scan: check if there are any broken discriminators at all
216	const schemaTypeMap = new Map<string, string>();	106	function hasBrokenDiscriminators(obj: unknown): boolean {
217	if (referencedSchemas.size > 0) {	107	if (Array.isArray(obj)) return obj.some(hasBrokenDiscriminators);
218	const schemasNode = findComponentsSchemas(ts, sourceFile);	108	if (obj && typeof obj === "object") {
219	if (schemasNode) {	109	const record = obj as Record<string, unknown>;
220	// First pass: extract all schema type texts (we need them for transitive refs)	110	if (record.discriminator && typeof record.discriminator === "object") {
221	const allSchemaTexts = new Map<string, string>();	111	const disc = record.discriminator as Record<string, unknown>;
222	for (const m of schemasNode.members) {	112	if (disc.mapping && typeof disc.mapping === "object") {
223	if (!ts.isPropertySignature(m) \|\| !m.name \|\| !m.type) continue;	113	const mapping = disc.mapping as Record<string, string>;
224	const name = ts.isIdentifier(m.name) ? m.name.text : ts.isStringLiteral(m.name) ? m.name.text : undefined;	114	if (Object.values(mapping).some((ref) => typeof ref === "string" && !refExists(ref))) {
225	if (!name) continue;	115	return true;
226	allSchemaTexts.set(name, m.type.getText(sourceFile).replace(/\s+/g, " ").trim());
227	}
228
229	// Resolve referenced schemas (one level deep — resolve transitive refs too)
230	const toResolve = new Set(referencedSchemas);
231	const resolved = new Set<string>();
232	while (toResolve.size > 0) {
233	const next = toResolve.values().next().value!;
234	toResolve.delete(next);
235	if (resolved.has(next)) continue;
236	resolved.add(next);
237
238	const typeText = allSchemaTexts.get(next);
239	if (!typeText) continue;
240
241	schemaTypeMap.set(next, typeText);
242
243	// Find transitive refs in this schema — but cap total schemas to avoid blowup
244	if (resolved.size < 200) {
245	for (const match of typeText.matchAll(refPattern)) {
246	if (!resolved.has(match[1]!)) toResolve.add(match[1]!);
247	}	116	}
248	}	117	}
249	}	118	}
		119	return Object.values(record).some(hasBrokenDiscriminators);
250	}	120	}
		121	return false;
251	}	122	}
252		123
253	// Replace components["schemas"]["X"] with the schema name as a type alias	124	if (!hasBrokenDiscriminators(spec)) return null;
254	// in all operation type strings, and collect the needed schema definitions	125
255	const schemas = new Map<string, string>();	126	function walk(obj: unknown): unknown {
256	const schemaNameMap = new Map<string, string>(); // "checkout.session" → "CheckoutSession"	127	if (Array.isArray(obj)) return obj.map(walk);
257	const usedAliasNames = new Set<string>();	128	if (obj && typeof obj === "object") {
258		129	const record = obj as Record<string, unknown>;
259	for (const schemaName of schemaTypeMap.keys()) {	130	const clone: Record<string, unknown> = {};
260	// Convert schema name to a valid, unique TS identifier.	131	for (const [key, value] of Object.entries(record)) {
261	const tsName = toTypeAliasName(schemaName, usedAliasNames);	132	if (key === "discriminator" && typeof value === "object" && value !== null) {
262	schemaNameMap.set(schemaName, tsName);	133	const disc = value as Record<string, unknown>;
263	}	134	if (disc.mapping && typeof disc.mapping === "object") {
264		135	const mapping = disc.mapping as Record<string, string>;
265	// Replace refs in schema definitions themselves (transitive refs)	136	const hasBroken = Object.values(mapping).some(
266	for (const [schemaName, typeText] of schemaTypeMap) {	137	(ref) => typeof ref === "string" && !refExists(ref),
267	const tsName = schemaNameMap.get(schemaName)!;	138	);
268	let resolved = typeText;	139	if (hasBroken) {
269	for (const [refName, refTsName] of schemaNameMap) {	140	strippedCount++;
270	resolved = resolved.replaceAll(`components["schemas"]["${refName}"]`, refTsName);	141	continue; // drop this broken discriminator
271	}
272	// Any remaining unresolved refs → unknown
273	resolved = resolved.replace(refPattern, "unknown");
274	schemas.set(tsName, resolved);
275	}
276
277	// Replace refs in operation type strings
278	for (const [opId, types] of operations) {
279	let { argsType, returnsType } = types;
280	for (const [refName, refTsName] of schemaNameMap) {
281	argsType = argsType.replaceAll(`components["schemas"]["${refName}"]`, refTsName);
282	returnsType = returnsType.replaceAll(`components["schemas"]["${refName}"]`, refTsName);
283	}
284	// Any remaining unresolved refs → unknown
285	argsType = argsType.replace(refPattern, "unknown");
286	returnsType = returnsType.replace(refPattern, "unknown");
287	operations.set(opId, { argsType, returnsType });
288	}
289
290	// Also resolve components["parameters"]["X"] refs to unknown (less common)
291	const paramRefPattern = /components\["parameters"\]\["[^"]+"\]/g;
292	for (const [opId, types] of operations) {
293	operations.set(opId, {
294	argsType: types.argsType.replace(paramRefPattern, "unknown"),
295	returnsType: types.returnsType.replace(paramRefPattern, "unknown"),
296	});
297	}
298
299	return { operations, schemas };
300	}
301
302	/** Find the components.schemas type literal in the .d.ts AST */
303	function findComponentsSchemas(
304	ts: typeof import("typescript"),
305	sourceFile: import("typescript").SourceFile,
306	): import("typescript").TypeLiteralNode \| undefined {
307	for (const stmt of sourceFile.statements) {
308	if (!ts.isInterfaceDeclaration(stmt) \|\| stmt.name.text !== "components") continue;
309	for (const member of stmt.members) {
310	if (!ts.isPropertySignature(member) \|\| !member.name) continue;
311	const name = ts.isIdentifier(member.name) ? member.name.text : undefined;
312	if (name === "schemas" && member.type && ts.isTypeLiteralNode(member.type)) {
313	return member.type;
314	}
315	}
316	}
317	return undefined;
318	}
319
320	function extractArgsType(
321	ts: typeof import("typescript"),
322	opType: import("typescript").TypeLiteralNode,
323	sourceFile: import("typescript").SourceFile,
324	): string {
325	const parts: string[] = [];
326
327	// Extract parameters (query, path, header)
328	const paramsMember = findMember(ts, opType, "parameters");
329	if (paramsMember?.type && ts.isTypeLiteralNode(paramsMember.type)) {
330	for (const locationMember of paramsMember.type.members) {
331	if (!ts.isPropertySignature(locationMember) \|\| !locationMember.name) continue;
332	const locName = ts.isIdentifier(locationMember.name) ? locationMember.name.text : "";
333	if (!["query", "path", "header"].includes(locName)) continue;
334	if (!locationMember.type \|\| !ts.isTypeLiteralNode(locationMember.type)) continue;
335
336	for (const param of locationMember.type.members) {
337	if (!ts.isPropertySignature(param) \|\| !param.name \|\| !param.type) continue;
338	const paramName = ts.isIdentifier(param.name)
339	? param.name.text
340	: ts.isStringLiteral(param.name)
341	? param.name.text
342	: undefined;
343	if (!paramName) continue;
344	const optional = param.questionToken ? "?" : "";
345	const typeText = param.type.getText(sourceFile).replace(/\s+/g, " ").trim();
346	parts.push(`${formatTsObjectKey(paramName)}${optional}: ${typeText}`);
347	}
348	}
349	}
350
351	// Extract requestBody content
352	const bodyMember = findMember(ts, opType, "requestBody");
353	if (bodyMember?.type) {
354	const bodyTypeNode = ts.isTypeLiteralNode(bodyMember.type) ? bodyMember.type : null;
355	if (bodyTypeNode) {
356	const contentMember = findMember(ts, bodyTypeNode, "content");
357	if (contentMember?.type && ts.isTypeLiteralNode(contentMember.type)) {
358	// Look for application/json or / or first content type
359	for (const ct of contentMember.type.members) {
360	if (!ts.isPropertySignature(ct) \|\| !ct.name \|\| !ct.type) continue;
361	const ctName = ts.isStringLiteral(ct.name) ? ct.name.text : ts.isIdentifier(ct.name) ? ct.name.text : "";
362	if (ctName === "application/json" \|\| ctName === "/" \|\| ctName.includes("json")) {
363	// The body type — try to merge its properties into the args
364	if (ts.isTypeLiteralNode(ct.type)) {
365	for (const bodyProp of ct.type.members) {
366	if (!ts.isPropertySignature(bodyProp) \|\| !bodyProp.name \|\| !bodyProp.type) continue;
367	const propName = ts.isIdentifier(bodyProp.name)
368	? bodyProp.name.text
369	: ts.isStringLiteral(bodyProp.name)
370	? bodyProp.name.text
371	: undefined;
372	if (!propName) continue;
373	const optional = bodyProp.questionToken ? "?" : "";
374	const typeText = bodyProp.type.getText(sourceFile).replace(/\s+/g, " ").trim();
375	parts.push(`${formatTsObjectKey(propName)}${optional}: ${typeText}`);
376	}
377	} else {
378	// Non-literal body type (e.g. components["schemas"]["..."]) — inline as `body`
379	const typeText = ct.type.getText(sourceFile).replace(/\s+/g, " ").trim();
380	if (typeText && typeText !== "never") {
381	parts.push(`body: ${typeText}`);
382	}
383	}	142	}
384	break;
385	}	143	}
386	}	144	}
		145	clone[key] = walk(value);
387	}	146	}
		147	return clone;
388	}	148	}
		149	return obj;
389	}	150	}
390		151
391	if (parts.length === 0) return "Record<string, unknown>";	152	const result = walk(spec) as Record<string, unknown>;
392	return `{ ${parts.join("; ")} }`;	153	console.warn(`[executor] stripped ${strippedCount} broken discriminator(s) from OpenAPI spec`);
		154	return result;
393	}	155	}
394		156
395	function extractReturnsType(	157	/**
396	ts: typeof import("typescript"),	158	* Generate a .d.ts string for an OpenAPI spec using openapi-typescript.
397	opType: import("typescript").TypeLiteralNode,	159	*
398	sourceFile: import("typescript").SourceFile,	160	* Accepts a pre-parsed object to avoid a redundant HTTP fetch — the caller
399	): string {	161	* should have already fetched and parsed the spec.
400	const responsesMember = findMember(ts, opType, "responses");	162	*
401	if (!responsesMember?.type \|\| !ts.isTypeLiteralNode(responsesMember.type)) return "unknown";	163	* Falls back to null on failure (e.g. Swagger 2.0, broken $refs).
402		164	*/
403	// Find the first 2xx response	165	async function generateOpenApiDts(
404	for (const resp of responsesMember.type.members) {	166	spec: Record<string, unknown>,
405	if (!ts.isPropertySignature(resp) \|\| !resp.name \|\| !resp.type) continue;	167	): Promise<string \| null> {
406	const status = ts.isNumericLiteral(resp.name)	168	try {
407	? resp.name.text	169	const ast = await openapiTS(spec as never, { silent: true });
408	: ts.isStringLiteral(resp.name)	170	return astToString(ast);
409	? resp.name.text	171	} catch (error) {
410	: ts.isIdentifier(resp.name)	172	const msg = error instanceof Error ? error.message : String(error);
411	? resp.name.text	173	// If the spec has broken discriminator $refs, patch them out and retry.
412	: "";	174	// This handles specs like Cloudflare's which have invalid discriminator
413	if (!status.startsWith("2")) continue;	175	// mappings that cause openapi-typescript to throw.
414	if (!ts.isTypeLiteralNode(resp.type)) continue;	176	const patched = stripBrokenDiscriminators(spec);
415		177	if (patched) {
416	const contentMember = findMember(ts, resp.type, "content");	178	console.warn(`[executor] openapi-typescript failed, retrying with patched spec: ${msg}`);
417	if (!contentMember?.type \|\| !ts.isTypeLiteralNode(contentMember.type)) continue;	179	try {
418		180	const ast = await openapiTS(patched as never, { silent: true });
419	let firstTypeText: string \| undefined;	181	return astToString(ast);
420	for (const ct of contentMember.type.members) {	182	} catch (retryError) {
421	if (!ts.isPropertySignature(ct) \|\| !ct.name \|\| !ct.type) continue;	183	const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
422	const ctName = ts.isStringLiteral(ct.name) ? ct.name.text : ts.isIdentifier(ct.name) ? ct.name.text : "";	184	console.warn(`[executor] openapi-typescript retry also failed: ${retryMsg}`);
423	const typeText = ct.type.getText(sourceFile).replace(/\s+/g, " ").trim();	185	return null;
424	if (!firstTypeText && typeText && typeText !== "never") firstTypeText = typeText;
425	if (ctName === "application/json" \|\| ctName === "/" \|\| ctName.includes("json")) {
426	return typeText \|\| "unknown";
427	}	186	}
428	}	187	}
429	if (firstTypeText) return firstTypeText;	188	console.warn(`[executor] openapi-typescript failed, using fallback types: ${msg}`);
		189	return null;
430	}	190	}
431
432	return "unknown";
433	}	191	}
434		192
435	function findMember(	193	/**
436	ts: typeof import("typescript"),	194	* Extract the set of operationIds present in a .d.ts from openapi-typescript.
437	typeLiteral: import("typescript").TypeLiteralNode,	195	* Used to determine which operations have generated types (for compaction).
438	name: string,	196	* This is a lightweight regex scan — no TS compiler needed.
439	): import("typescript").PropertySignature \| undefined {	197	*/
440	for (const member of typeLiteral.members) {	198	function extractOperationIdsFromDts(dts: string): Set<string> {
441	if (!ts.isPropertySignature(member) \|\| !member.name) continue;	199	const ids = new Set<string>();
442	const memberName = ts.isIdentifier(member.name)	200	// Match property signatures in the operations interface: `operationId: {` or `"operation-id": {`
443	? member.name.text	201	const pattern = /^\s{2,4}(?:"([^"]+)"\|([A-Za-z_]\w))\s:\s*\{/gm;
444	: ts.isStringLiteral(member.name)	202	// Only scan the operations interface section
445	? member.name.text	203	const opsStart = dts.indexOf("export interface operations {");
446	: undefined;	204	if (opsStart === -1) return ids;
447	if (memberName === name) return member;	205	const opsSection = dts.slice(opsStart, opsStart + dts.length);
		206	for (const match of opsSection.matchAll(pattern)) {
		207	const id = match[1] ?? match[2];
		208	if (id) ids.add(id);
448	}	209	}
449	return undefined;	210	return ids;
450	}	211	}
451		212
452	function getPreferredContentSchema(content: Record<string, unknown>): Record<string, unknown> {	213	function getPreferredContentSchema(content: Record<string, unknown>): Record<string, unknown> {
@@ -857,12 +618,11 @@ export async function prepareOpenApiSpec( · 404 unmodified lines
857		618
858	const dts = await dtsPromise;	619	const dts = await dtsPromise;
859		620
860	// ── Step 3: Extract operation type IDs for compaction ──────────────────	621	// ── Step 3: Extract operation IDs for compaction ───────────────────────
861	// We extract types here to know which operations have generated types	622	// If we have a .d.ts, we know which operations have full generated types.
862	// (so compactOpenApiPaths can strip schemas for those operations).	623	// compactOpenApiPaths uses this to strip request/response schemas from
863	// This is pure CPU — no I/O.	624	// operations that don't need the fallback hint generator.
864	const typeMap = dts ? extractTypesFromDts(dts) : null;	625	const operationTypeIds = dts ? extractOperationIdsFromDts(dts) : new Set<string>();
865	const operationTypeIds = new Set<string>(typeMap ? [...typeMap.operations.keys()] : []);
866		626
867	const servers = Array.isArray(bundled.servers) ? (bundled.servers as Array<{ url?: unknown }>) : [];	627	const servers = Array.isArray(bundled.servers) ? (bundled.servers as Array<{ url?: unknown }>) : [];
868		628
@@ -885,30 +645,18 @@ export function buildOpenApiToolsFromPrepared( · 16 unmodified lines
885	throw new Error(`OpenAPI source ${config.name} has no base URL (set baseUrl)`);	645	throw new Error(`OpenAPI source ${config.name} has no base URL (set baseUrl)`);
886	}	646	}
887		647
888	// Extract per-operation types from cached .d.ts (or use legacy pre-extracted types)
889	let typeMap: ExtractedTypes \| null = null;
890	if (prepared.dts) {
891	typeMap = extractTypesFromDts(prepared.dts);
892	} else if (prepared.operationTypes) {
893	// Legacy cache compat: old entries have pre-extracted types
894	typeMap = {
895	operations: new Map(Object.entries(prepared.operationTypes)),
896	schemas: new Map(Object.entries(prepared.schemaTypes ?? {})),
897	};
898	}
899
900	const authHeaders = buildStaticAuthHeaders(config.auth);	648	const authHeaders = buildStaticAuthHeaders(config.auth);
901	const sourceKey = `openapi:${config.name}`;	649	const sourceKey = `openapi:${config.name}`;
902	const credentialSpec = buildCredentialSpec(sourceKey, config.auth);	650	const credentialSpec = buildCredentialSpec(sourceKey, config.auth);
903	const paths = asRecord(prepared.paths);	651	const paths = asRecord(prepared.paths);
904	const tools: ToolDefinition[] = [];	652	const tools: ToolDefinition[] = [];
905		653
906	// Schema type aliases referenced by operations — stored on the first tool only	654	// The raw .d.ts is attached to the first tool only (same pattern as old schemaTypes).
907	// to avoid duplicating hundreds of KB across every tool from this source.	655	// The typechecker/Monaco use this directly via indexed access types.
908	const schemaTypes = typeMap && typeMap.schemas.size > 0	656	const sourceDts = prepared.dts
909	? Object.fromEntries(typeMap.schemas)	657	? prepared.dts.replace(/^export /gm, "") // strip 'export' so types are ambient
910	: undefined;	658	: undefined;
911	let schemaTypesEmitted = false;	659	let sourceDtsEmitted = false;
912		660
913	const methods = ["get", "post", "put", "delete", "patch", "head", "options"] as const;	661	const methods = ["get", "post", "put", "delete", "patch", "head", "options"] as const;
914	const readMethods = new Set(["get", "head", "options"]);	662	const readMethods = new Set(["get", "head", "options"]);
@@ -939,46 +687,36 @@ export function buildOpenApiToolsFromPrepared( · 24 unmodified lines
939	schema: asRecord(entry.schema),	687	schema: asRecord(entry.schema),
940	}));	688	}));
941		689
942	// Use openapiTS-generated types if available, otherwise fall back to schema hints	690	// Lightweight type hints for LLM prompt / discover tool (from JSON Schema fallback)
943	const generatedTypes = typeMap?.operations.get(operationIdRaw);	691	const requestBody = asRecord(operation.requestBody);
944	let argsType: string;	692	const requestBodyContent = asRecord(requestBody.content);
945	let returnsType: string;	693	const requestBodySchema = getPreferredContentSchema(requestBodyContent);
946		694
947	if (generatedTypes) {	695	const responses = asRecord(operation.responses);
948	argsType = generatedTypes.argsType;	696	let responseSchema: Record<string, unknown> = {};
949	returnsType = generatedTypes.returnsType;	697	for (const [status, responseValue] of Object.entries(responses)) {
950	} else {	698	if (!status.startsWith("2")) continue;
951	// Fallback: build types from the bundled schema using the depth-limited hint generator	699	const responseContent = asRecord(asRecord(responseValue).content);
952	const requestBody = asRecord(operation.requestBody);	700	responseSchema = getPreferredContentSchema(responseContent);
953	const requestBodyContent = asRecord(requestBody.content);	701	if (Object.keys(responseSchema).length > 0) break;
954	const requestBodySchema = getPreferredContentSchema(requestBodyContent);	702	}
955		703
956	const responses = asRecord(operation.responses);	704	const combinedSchema: JsonSchema = {
957	let responseSchema: Record<string, unknown> = {};	705	type: "object",
958	for (const [status, responseValue] of Object.entries(responses)) {	706	properties: {
959	if (!status.startsWith("2")) continue;	707	...Object.fromEntries(parameters.map((param) => [param.name, param.schema])),
960	const responseContent = asRecord(asRecord(responseValue).content);	708	...asRecord(requestBodySchema.properties),
961	responseSchema = getPreferredContentSchema(responseContent);	709	},
962	if (Object.keys(responseSchema).length > 0) break;	710	required: [
963	}	711	...parameters.filter((param) => param.required).map((param) => param.name),
		712	...((Array.isArray(requestBodySchema.required)
		713	? requestBodySchema.required.filter((item): item is string => typeof item === "string")
		714	: []) as string[]),
		715	],
		716	};
964		717
965	const combinedSchema: JsonSchema = {	718	const argsType = jsonSchemaTypeHintFallback(combinedSchema);
966	type: "object",	719	const returnsType = jsonSchemaTypeHintFallback(responseSchema);
967	properties: {
968	...Object.fromEntries(parameters.map((param) => [param.name, param.schema])),
969	...asRecord(requestBodySchema.properties),
970	},
971	required: [
972	...parameters.filter((param) => param.required).map((param) => param.name),
973	...((Array.isArray(requestBodySchema.required)
974	? requestBodySchema.required.filter((item): item is string => typeof item === "string")
975	: []) as string[]),
976	],
977	};
978
979	argsType = jsonSchemaTypeHintFallback(combinedSchema);
980	returnsType = jsonSchemaTypeHintFallback(responseSchema);
981	}
982		720
983	const approval = config.overrides?.[operationIdRaw]?.approval	721	const approval = config.overrides?.[operationIdRaw]?.approval
984	?? (readMethods.has(method)	722	?? (readMethods.has(method)
@@ -1002,8 +740,9 @@ export function buildOpenApiToolsFromPrepared( · 17 unmodified lines
1002	metadata: {	740	metadata: {
1003	argsType,	741	argsType,
1004	returnsType,	742	returnsType,
1005	// Only attach schemas to the first tool to avoid duplicating hundreds of KB	743	operationId: operationIdRaw,
1006	...(schemaTypes && !schemaTypesEmitted ? { schemaTypes } : {}),	744	// Only attach sourceDts to the first tool to avoid duplicating the full .d.ts
		745	...(sourceDts && !sourceDtsEmitted ? { sourceDts } : {}),
1007	},	746	},
1008	credential: credentialSpec,	747	credential: credentialSpec,
1009	_runSpec: runSpec,	748	_runSpec: runSpec,
@@ -1036,9 +775,8 @@ export function buildOpenApiToolsFromPrepared( · 26 unmodified lines
1036	};	775	};
1037	tools.push(tool);	776	tools.push(tool);
1038		777
1039	// Mark schemas as emitted so subsequent tools from this source don't duplicate them	778	if (sourceDts && !sourceDtsEmitted) {
1040	if (schemaTypes && !schemaTypesEmitted) {	779	sourceDtsEmitted = true;
1041	schemaTypesEmitted = true;
1042	}	780	}
1043	}	781	}
1044	}	782	}

executor/convex/lib/typechecker.ts+43−13

@@ -1,8 +1,13 @@
1	/**	1	/**
2	* TypeScript typechecker for LLM-generated code.	2	* TypeScript typechecker for LLM-generated code.
3	*	3	*
4	* Generates `declare const tools: { ... }` from ToolDescriptor metadata,	4	* For OpenAPI tools with a raw .d.ts from openapi-typescript, the typechecker
5	* then validates code against those declarations using the TypeScript compiler API.	5	* uses the .d.ts directly with helper types (ToolInput/ToolOutput) that extract
		6	* per-operation arg/return types via indexed access. This avoids parsing the
		7	* .d.ts to extract per-operation type strings.
		8	*
		9	* For tools without a .d.ts (MCP, GraphQL, builtins), the typechecker falls
		10	* back to using the lightweight argsType/returnsType hint strings.
6	*	11	*
7	* This runs in the executor so all MCP clients benefit from typechecking	12	* This runs in the executor so all MCP clients benefit from typechecking
8	* without needing their own TypeScript setup.	13	* without needing their own TypeScript setup.
@@ -17,11 +22,16 @@ import type { ToolDescriptor } from "./types"; · 8 unmodified lines
17	/**	22	/**
18	* Build a `declare const tools: { ... }` block from flat tool descriptors.	23	* Build a `declare const tools: { ... }` block from flat tool descriptors.
19	*	24	*
		25	* Uses the lightweight `argsType`/`returnsType` strings from each tool.
		26	* This is used by the server-side MCP typechecker, which doesn't need the
		27	* full OpenAPI .d.ts (that's handled by Monaco on the client side).
		28	*
20	* Tool paths like "math.add" or "admin.send_announcement" are split on "."	29	* Tool paths like "math.add" or "admin.send_announcement" are split on "."
21	* and nested into a type tree.	30	* and nested into a type tree.
22	*/	31	*/
23	export function generateToolDeclarations(tools: ToolDescriptor[]): string {	32	export function generateToolDeclarations(tools: ToolDescriptor[]): string {
24	// Collect all schema type aliases from all tools (deduplicated by name)	33
		34	// Legacy compat: collect schemaTypes from tools that use the old format
25	const allSchemas = new Map<string, string>();	35	const allSchemas = new Map<string, string>();
26	for (const tool of tools) {	36	for (const tool of tools) {
27	if (tool.schemaTypes) {	37	if (tool.schemaTypes) {
@@ -62,8 +72,9 @@ export function generateToolDeclarations(tools: ToolDescriptor[]): string { · 34 unmodified lines
62		72
63	for (const [key, child] of node.children) {	73	for (const [key, child] of node.children) {
64	if (child.tool) {	74	if (child.tool) {
65	const args = child.tool.argsType \|\| "Record<string, unknown>";	75	const tool = child.tool;
66	const returns = child.tool.returnsType \|\| "unknown";	76	const args = tool.argsType \|\| "Record<string, unknown>";
		77	const returns = tool.returnsType \|\| "unknown";
67	lines.push(`${pad}${key}(input: ${args}): Promise<${returns}>;`);	78	lines.push(`${pad}${key}(input: ${args}): Promise<${returns}>;`);
68	} else {	79	} else {
69	lines.push(`${pad}${key}: {`);	80	lines.push(`${pad}${key}: {`);
@@ -75,14 +86,20 @@ export function generateToolDeclarations(tools: ToolDescriptor[]): string { · 5 unmodified lines
75	return lines.join("\n");	86	return lines.join("\n");
76	}	87	}
77		88
78	// Emit schema type aliases before the tools declaration so they're in scope	89	// Assemble the full declarations block
79	const schemaLines: string[] = [];	90	const parts: string[] = [];
80	for (const [name, type] of allSchemas) {	91
81	schemaLines.push(`type ${name} = ${type};`);	92	// Legacy schema type aliases (from old cache format)
		93	if (allSchemas.size > 0) {
		94	for (const [name, type] of allSchemas) {
		95	parts.push(`type ${name} = ${type};`);
		96	}
82	}	97	}
83		98
84	const schemaBlock = schemaLines.length > 0 ? schemaLines.join("\n") + "\n" : "";	99	// The tools declaration
85	return `${schemaBlock}declare const tools: {\n${renderNode(root, 1)}\n};`;	100	parts.push(`declare const tools: {\n${renderNode(root, 1)}\n};`);
		101
		102	return parts.join("\n");
86	}	103	}
87		104
88	/**	105	/**
@@ -169,7 +186,7 @@ export function typecheckCode( · 80 unmodified lines
169	// `types: []` prevents @types/node from loading.	186	// `types: []` prevents @types/node from loading.
170	const wrappedCode = [	187	const wrappedCode = [
171	toolDeclarations,	188	toolDeclarations,
172	"declare const console: { log(...args: any[]): void; info(...args: any[]): void; warn(...args: any[]): void; error(...args: any[]): void; };",	189	"declare var console: { log(...args: any[]): void; info(...args: any[]): void; warn(...args: any[]): void; error(...args: any[]): void; };",
173	"declare function setTimeout(fn: () => void, ms: number): number;",	190	"declare function setTimeout(fn: () => void, ms: number): number;",
174	"declare function clearTimeout(id: number): void;",	191	"declare function clearTimeout(id: number): void;",
175	"async function __generated() {",	192	"async function __generated() {",
@@ -238,9 +255,22 @@ export function typecheckCode( · 62 unmodified lines
238	return { ok: true, errors: [] };	255	return { ok: true, errors: [] };
239	}	256	}
240		257
		258	// Filter out errors from the .d.ts header (circular refs, etc.) — only report user code errors
		259	const userErrors = diagnostics.filter((d) => {
		260	if (d.start !== undefined && d.file) {
		261	const { line } = d.file.getLineAndCharacterOfPosition(d.start);
		262	return line + 1 > headerLineCount;
		263	}
		264	return false;
		265	});
		266
		267	if (userErrors.length === 0) {
		268	return { ok: true, errors: [] };
		269	}
		270
241	return {	271	return {
242	ok: false,	272	ok: false,
243	errors: diagnostics.map((d) => formatError(d, headerLineCount)),	273	errors: userErrors.map((d) => formatError(d, headerLineCount)),
244	};	274	};
245	} catch (error) {	275	} catch (error) {
246	// Some runtimes (e.g. Convex action isolates) can lack the full Node-backed	276	// Some runtimes (e.g. Convex action isolates) can lack the full Node-backed

executor/convex/lib/types.ts+10−1

 }
 export interface ToolTypeMetadata {
+  /** Lightweight TS type hint for args (for LLM prompt / discover tool). */
   argsType?: string;
+  /** Lightweight TS type hint for return value (for LLM prompt / discover tool). */
   returnsType?: string;
-  /** Schema type aliases needed by argsType/returnsType (e.g. `{ "Account": "{ id: string; ... }" }`) */
+  /** Raw operationId from the OpenAPI spec (used to generate typechecker wrapper). */
+  operationId?: string;
+  /**
+   * Raw .d.ts from openapi-typescript for this tool's source.
+   * Only set on the FIRST tool per source to avoid duplication.
+   */
+  sourceDts?: string;
+  /** @deprecated Use sourceDts instead. Kept for cache compat. */
   schemaTypes?: Record<string, string>;
 }

executor/convex/openApiSpecCache.ts+3−3

@@ -52,8 +52,8 @@ export const putEntry = internalMutation({ · 51 unmodified lines
52	.unique();	52	.unique();
53		53
54	if (existing) {	54	if (existing) {
55	// Delete old blob	55	// Delete old blob (ignore if already deleted by a concurrent mutation)
56	await ctx.storage.delete(existing.storageId);	56	await ctx.storage.delete(existing.storageId).catch(() => {});
57	await ctx.db.delete(existing._id);	57	await ctx.db.delete(existing._id);
58	}	58	}
59		59
@@ -89,7 +89,7 @@ export const pruneExpired = internalMutation({ · 29 unmodified lines
89	for (const entry of entries) {	89	for (const entry of entries) {
90	if (removed >= limit) break;	90	if (removed >= limit) break;
91	if (entry.createdAt < cutoff) {	91	if (entry.createdAt < cutoff) {
92	await ctx.storage.delete(entry.storageId);	92	await ctx.storage.delete(entry.storageId).catch(() => {});
93	await ctx.db.delete(entry._id);	93	await ctx.db.delete(entry._id);
94	removed++;	94	removed++;
95	}	95	}

executor/convex/organizations.ts+11−2

 import { v } from "convex/values";
 import type { Doc, Id } from "./_generated/dataModel";
 import type { MutationCtx, QueryCtx } from "./_generated/server";
-import { query } from "./_generated/server";
 import { optionalAccountQuery, authedMutation } from "./lib/functionBuilders";
 import { getOrganizationMembership, slugify } from "./lib/identity";
 import { ensureUniqueSlug } from "./lib/slug";
   },
 });
-export const resolveWorkosOrganizationId = query({
+export const resolveWorkosOrganizationId = optionalAccountQuery({
   args: {
     organizationId: v.id("organizations"),
   },
   handler: async (ctx, args) => {
+    const account = ctx.account;
+    if (!account) {
+      return null;
+    }
+    const membership = await getOrganizationMembership(ctx, args.organizationId, account._id);
+    if (!membership || membership.status !== "active") {
+      return null;
+    }
     const organization = await ctx.db.get(args.organizationId);
     if (!organization || organization.status !== "active") {
       return null;

executor/convex/schema.ts+5−0

     workspaceId: v.string(),
     signature: v.string(),
     storageId: v.id("_storage"),
+    /** Per-source .d.ts blobs stored separately (too large for action responses). */
+    dtsStorageIds: v.optional(v.array(v.object({
+      sourceKey: v.string(),
+      storageId: v.id("_storage"),
+    }))),
     toolCount: v.number(),
     sizeBytes: v.number(),
     createdAt: v.number(),

executor/convex/workspace.ts+217−0

@@ -0,0 +1,217 @@
	1	import { v } from "convex/values";
	2	import { internal } from "./_generated/api";
	3	import { mutation, query } from "./_generated/server";
	4	import { workspaceMutation, workspaceQuery } from "./lib/functionBuilders";
	5
	6	const approvalStatusValidator = v.union(v.literal("pending"), v.literal("approved"), v.literal("denied"));
	7	const policyDecisionValidator = v.union(v.literal("allow"), v.literal("require_approval"), v.literal("deny"));
	8	const credentialScopeValidator = v.union(v.literal("workspace"), v.literal("actor"));
	9	const credentialProviderValidator = v.union(v.literal("managed"), v.literal("workos-vault"));
	10	const toolSourceTypeValidator = v.union(v.literal("mcp"), v.literal("openapi"), v.literal("graphql"));
	11
	12	function redactCredential<T extends { secretJson: Record<string, unknown> }>(credential: T): T {
	13	return {
	14	...credential,
	15	secretJson: {},
	16	};
	17	}
	18
	19	export const bootstrapAnonymousSession = mutation({
	20	args: { sessionId: v.optional(v.string()) },
	21	handler: async (ctx, args) => {
	22	return await ctx.runMutation(internal.database.bootstrapAnonymousSession, args);
	23	},
	24	});
	25
	26	export const listRuntimeTargets = query({
	27	args: {},
	28	handler: async (ctx) => {
	29	return await ctx.runQuery(internal.database.listRuntimeTargets, {});
	30	},
	31	});
	32
	33	export const getTask = workspaceQuery({
	34	args: { taskId: v.string() },
	35	handler: async (ctx, args) => {
	36	return await ctx.runQuery(internal.database.getTaskInWorkspace, {
	37	taskId: args.taskId,
	38	workspaceId: ctx.workspaceId,
	39	});
	40	},
	41	});
	42
	43	export const getTaskInWorkspace = workspaceQuery({
	44	args: { taskId: v.string() },
	45	handler: async (ctx, args) => {
	46	return await ctx.runQuery(internal.database.getTaskInWorkspace, {
	47	taskId: args.taskId,
	48	workspaceId: ctx.workspaceId,
	49	});
	50	},
	51	});
	52
	53	export const listTasks = workspaceQuery({
	54	args: {},
	55	handler: async (ctx) => {
	56	return await ctx.runQuery(internal.database.listTasks, {
	57	workspaceId: ctx.workspaceId,
	58	});
	59	},
	60	});
	61
	62	export const listApprovals = workspaceQuery({
	63	args: {
	64	status: v.optional(approvalStatusValidator),
	65	},
	66	handler: async (ctx, args) => {
	67	return await ctx.runQuery(internal.database.listApprovals, {
	68	workspaceId: ctx.workspaceId,
	69	status: args.status,
	70	});
	71	},
	72	});
	73
	74	export const listPendingApprovals = workspaceQuery({
	75	args: {},
	76	handler: async (ctx) => {
	77	return await ctx.runQuery(internal.database.listPendingApprovals, {
	78	workspaceId: ctx.workspaceId,
	79	});
	80	},
	81	});
	82
	83	export const listTaskEvents = workspaceQuery({
	84	args: { taskId: v.string() },
	85	handler: async (ctx, args) => {
	86	const task = await ctx.runQuery(internal.database.getTaskInWorkspace, {
	87	taskId: args.taskId,
	88	workspaceId: ctx.workspaceId,
	89	});
	90	if (!task) {
	91	return [];
	92	}
	93
	94	return await ctx.runQuery(internal.database.listTaskEvents, {
	95	taskId: args.taskId,
	96	});
	97	},
	98	});
	99
	100	export const upsertAccessPolicy = workspaceMutation({
	101	requireAdmin: true,
	102	args: {
	103	id: v.optional(v.string()),
	104	actorId: v.optional(v.string()),
	105	clientId: v.optional(v.string()),
	106	toolPathPattern: v.string(),
	107	decision: policyDecisionValidator,
	108	priority: v.optional(v.number()),
	109	},
	110	handler: async (ctx, args) => {
	111	return await ctx.runMutation(internal.database.upsertAccessPolicy, {
	112	workspaceId: ctx.workspaceId,
	113	...args,
	114	});
	115	},
	116	});
	117
	118	export const listAccessPolicies = workspaceQuery({
	119	args: {},
	120	handler: async (ctx) => {
	121	return await ctx.runQuery(internal.database.listAccessPolicies, {
	122	workspaceId: ctx.workspaceId,
	123	});
	124	},
	125	});
	126
	127	export const upsertCredential = workspaceMutation({
	128	requireAdmin: true,
	129	args: {
	130	id: v.optional(v.string()),
	131	sourceKey: v.string(),
	132	scope: credentialScopeValidator,
	133	actorId: v.optional(v.string()),
	134	provider: v.optional(credentialProviderValidator),
	135	secretJson: v.any(),
	136	},
	137	handler: async (ctx, args) => {
	138	return await ctx.runMutation(internal.database.upsertCredential, {
	139	workspaceId: ctx.workspaceId,
	140	...args,
	141	});
	142	},
	143	});
	144
	145	export const listCredentials = workspaceQuery({
	146	args: {},
	147	handler: async (ctx) => {
	148	const credentials = await ctx.runQuery(internal.database.listCredentials, {
	149	workspaceId: ctx.workspaceId,
	150	});
	151
	152	return credentials.map(redactCredential);
	153	},
	154	});
	155
	156	export const listCredentialProviders = query({
	157	args: {},
	158	handler: async (ctx) => {
	159	return await ctx.runQuery(internal.database.listCredentialProviders, {});
	160	},
	161	});
	162
	163	export const resolveCredential = workspaceQuery({
	164	requireAdmin: true,
	165	args: {
	166	sourceKey: v.string(),
	167	scope: credentialScopeValidator,
	168	actorId: v.optional(v.string()),
	169	},
	170	handler: async (ctx, args) => {
	171	const credential = await ctx.runQuery(internal.database.resolveCredential, {
	172	workspaceId: ctx.workspaceId,
	173	sourceKey: args.sourceKey,
	174	scope: args.scope,
	175	actorId: args.actorId,
	176	});
	177
	178	return credential ? redactCredential(credential) : null;
	179	},
	180	});
	181
	182	export const upsertToolSource = workspaceMutation({
	183	requireAdmin: true,
	184	args: {
	185	id: v.optional(v.string()),
	186	name: v.string(),
	187	type: toolSourceTypeValidator,
	188	config: v.any(),
	189	enabled: v.optional(v.boolean()),
	190	},
	191	handler: async (ctx, args) => {
	192	return await ctx.runMutation(internal.database.upsertToolSource, {
	193	workspaceId: ctx.workspaceId,
	194	...args,
	195	});
	196	},
	197	});
	198
	199	export const listToolSources = workspaceQuery({
	200	args: {},
	201	handler: async (ctx) => {
	202	return await ctx.runQuery(internal.database.listToolSources, {
	203	workspaceId: ctx.workspaceId,
	204	});
	205	},
	206	});
	207
	208	export const deleteToolSource = workspaceMutation({
	209	requireAdmin: true,
	210	args: { sourceId: v.string() },
	211	handler: async (ctx, args) => {
	212	return await ctx.runMutation(internal.database.deleteToolSource, {
	213	workspaceId: ctx.workspaceId,
	214	sourceId: args.sourceId,
	215	});
	216	},
	217	});

executor/convex/workspaceAuthInternal.ts+59−0

@@ -0,0 +1,59 @@
	1	import { v } from "convex/values";
	2	import { internalQuery } from "./_generated/server";
	3	import {
	4	requireWorkspaceAccessForAccount,
	5	resolveAccountForRequest,
	6	resolveWorkosAccountBySubject,
	7	} from "./lib/identity";
	8
	9	function actorIdForAccount(account: { _id: string; provider: string; providerAccountId: string }): string {
	10	return account.provider === "anonymous" ? account.providerAccountId : account._id;
	11	}
	12
	13	export const getWorkspaceAccessForRequest = internalQuery({
	14	args: {
	15	workspaceId: v.string(),
	16	sessionId: v.optional(v.string()),
	17	},
	18	handler: async (ctx, args) => {
	19	const account = await resolveAccountForRequest(ctx, args.sessionId);
	20	if (!account) {
	21	throw new Error("Must be signed in");
	22	}
	23
	24	const access = await requireWorkspaceAccessForAccount(ctx, args.workspaceId, account);
	25
	26	return {
	27	workspaceId: args.workspaceId,
	28	accountId: account._id,
	29	provider: account.provider,
	30	providerAccountId: account.providerAccountId,
	31	actorId: actorIdForAccount(account),
	32	role: access.workspaceMembership.role,
	33	};
	34	},
	35	});
	36
	37	export const getWorkspaceAccessForWorkosSubject = internalQuery({
	38	args: {
	39	workspaceId: v.string(),
	40	subject: v.string(),
	41	},
	42	handler: async (ctx, args) => {
	43	const account = await resolveWorkosAccountBySubject(ctx, args.subject);
	44	if (!account) {
	45	throw new Error("Token subject is not linked to an account");
	46	}
	47
	48	const access = await requireWorkspaceAccessForAccount(ctx, args.workspaceId, account);
	49
	50	return {
	51	workspaceId: args.workspaceId,
	52	accountId: account._id,
	53	provider: account.provider,
	54	providerAccountId: account.providerAccountId,
	55	actorId: actorIdForAccount(account),
	56	role: access.workspaceMembership.role,
	57	};
	58	},
	59	});

executor/convex/workspaceToolCache.ts+33−2

     return {
       storageId: entry.storageId,
+      dtsStorageIds: entry.dtsStorageIds ?? [],
       toolCount: entry.toolCount,
       sizeBytes: entry.sizeBytes,
       createdAt: entry.createdAt,
 /**
  * Write (or replace) a workspace tool cache entry.
- * Deletes the old blob if replacing.
+ * Deletes old blobs (main snapshot + .d.ts blobs) if replacing.
  */
 export const putEntry = internalMutation({
   args: {
     workspaceId: v.string(),
     signature: v.string(),
     storageId: v.id("_storage"),
+    dtsStorageIds: v.optional(v.array(v.object({
+      sourceKey: v.string(),
+      storageId: v.id("_storage"),
+    }))),
     toolCount: v.number(),
     sizeBytes: v.number(),
   },
       .unique();
     if (existing) {
-      await ctx.storage.delete(existing.storageId);
+      // Delete old main snapshot blob
+      await ctx.storage.delete(existing.storageId).catch(() => {});
+      // Delete old .d.ts blobs
+      if (existing.dtsStorageIds) {
+        for (const entry of existing.dtsStorageIds) {
+          await ctx.storage.delete(entry.storageId).catch(() => {});
+        }
+      }
       await ctx.db.delete(existing._id);
     }
       workspaceId: args.workspaceId,
       signature: args.signature,
       storageId: args.storageId,
+      dtsStorageIds: args.dtsStorageIds,
       toolCount: args.toolCount,
       sizeBytes: args.sizeBytes,
       createdAt: Date.now(),
     });
   },
 });
+/**
+ * Look up .d.ts storage IDs for a workspace (used to generate download URLs).
+ */
+export const getDtsStorageIds = internalQuery({
+  args: {
+    workspaceId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const entry = await ctx.db
+      .query("workspaceToolCache")
+      .withIndex("by_workspace", (q) => q.eq("workspaceId", args.workspaceId))
+      .unique();
+    if (!entry) return [];
+    return entry.dtsStorageIds ?? [];
+  },
+});

executor/packages/contracts/src/index.ts+5−1

   description: string;
   approval: ToolApprovalMode;
   source?: string;
+  /** Lightweight TS type hint for args (for LLM prompt / discover tool). */
   argsType?: string;
+  /** Lightweight TS type hint for return value (for LLM prompt / discover tool). */
   returnsType?: string;
-  /** Schema type aliases needed by argsType/returnsType (shared across tools from same source) */
+  /** Raw operationId from the OpenAPI spec (used by Monaco for indexed access types). */
+  operationId?: string;
+  /** @deprecated Kept for cache compat. */
   schemaTypes?: Record<string, string>;
 }

kill-all.ts+72−0

@@ -0,0 +1,72 @@
	1	/**
	2	* Kills all processes started by `bun dev`.
	3	*
	4	* 1. Reads PIDs from .dev.pids and kills process trees
	5	* 2. Falls back to killing anything on known dev ports (3000, 3002)
	6	*
	7	* Usage: bun run kill:all
	8	*/
	9
	10	import { join } from "node:path";
	11	import { unlinkSync } from "node:fs";
	12
	13	const PID_FILE = join(import.meta.dir, ".dev.pids");
	14	const DEV_PORTS = [3000, 3002];
	15
	16	let killed = 0;
	17	let skipped = 0;
	18
	19	function killPid(pid: number) {
	20	// Kill children first
	21	try {
	22	Bun.spawnSync(["pkill", "-TERM", "--parent", String(pid)]);
	23	} catch {}
	24
	25	try {
	26	process.kill(pid, "SIGTERM");
	27	console.log(` Killed PID ${pid}`);
	28	killed++;
	29	} catch (err: any) {
	30	if (err.code === "ESRCH") {
	31	skipped++;
	32	} else {
	33	console.error(` Failed to kill PID ${pid}: ${err.message}`);
	34	}
	35	}
	36	}
	37
	38	// ── Phase 1: Kill PIDs from the PID file ──
	39
	40	const file = Bun.file(PID_FILE);
	41	if (await file.exists()) {
	42	const pids = (await file.text())
	43	.split("\n").map((l) => l.trim()).filter(Boolean).map(Number).filter((n) => !isNaN(n));
	44
	45	if (pids.length > 0) {
	46	console.log("Killing tracked processes...");
	47	for (const pid of pids) killPid(pid);
	48	}
	49
	50	try { unlinkSync(PID_FILE); } catch {}
	51	}
	52
	53	// ── Phase 2: Kill anything still on dev ports ──
	54
	55	for (const port of DEV_PORTS) {
	56	const result = Bun.spawnSync(["fuser", "-k", `${port}/tcp`], { stderr: "pipe" });
	57	const stderr = result.stderr.toString().trim();
	58	if (stderr && stderr.includes(String(port))) {
	59	console.log(`Killed processes on port ${port}`);
	60	killed++;
	61	}
	62	}
	63
	64	if (killed === 0 && skipped === 0) {
	65	console.log("Nothing to kill.");
	66	} else {
	67	console.log(
	68	`\nDone. Killed ${killed} process${killed !== 1 ? "es" : ""}${
	69	skipped > 0 ? `, ${skipped} already stopped` : ""
	70	}.`,
	71	);
	72	}

package.json+3−0

   "scripts": {
     "with-env": "bun run --env-file=.env --",
     "dev": "bun run dev.ts",
+    "kill:all": "bun run kill-all.ts",
     "dev:executor:convex": "bunx --cwd executor convex dev",
     "dev:executor:web": "bun run --cwd executor/apps/web dev",
     "dev:executor:all": "bun run dev:executor:convex & bun run dev:executor:web",
     "test": "bun run test:executor && bun run test:assistant",
     "test:executor": "bun test --cwd executor",
     "test:assistant": "bun run --cwd assistant test",
+    "typecheck": "bun run typecheck:executor && bun run typecheck:assistant",
     "typecheck:executor": "bunx tsc --noEmit -p executor/tsconfig.json",
+    "typecheck:assistant": "bunx tsc --noEmit -p assistant/packages/server/tsconfig.json && bunx tsc --noEmit -p assistant/packages/bot/tsconfig.json",
     "db:clear:executor": "bun with-env bun run executor/wipe-convex-db.ts",
     "convex:codegen": "bunx --cwd executor convex codegen"
   },