lael-labs/executor

executor/apps/server/src/database.ts+2−2

@@ -106,7 +106,7 @@ function mapToolSourceRow(row: Record<string, unknown>): ToolSourceRecord { · 105 unmodified lines
106	id: String(row.id),	106	id: String(row.id),
107	workspaceId: String(row.workspace_id),	107	workspaceId: String(row.workspace_id),
108	name: String(row.name),	108	name: String(row.name),
109	type: String(row.type) as "mcp" \| "openapi",	109	type: String(row.type) as ToolSourceRecord["type"],
110	config: parseMetadata(row.config_json),	110	config: parseMetadata(row.config_json),
111	enabled: Number(row.enabled) === 1,	111	enabled: Number(row.enabled) === 1,
112	createdAt: Number(row.created_at),	112	createdAt: Number(row.created_at),
@@ -700,7 +700,7 @@ export class ExecutorDatabase { · 587 unmodified lines
700	id?: string;	700	id?: string;
701	workspaceId: string;	701	workspaceId: string;
702	name: string;	702	name: string;
703	type: "mcp" \| "openapi";	703	type: ToolSourceRecord["type"];
704	config: Record<string, unknown>;	704	config: Record<string, unknown>;
705	enabled?: boolean;	705	enabled?: boolean;
706	}): ToolSourceRecord {	706	}): ToolSourceRecord {

executor/apps/server/src/index.ts+3−3

@@ -213,7 +213,7 @@ const server = Bun.serve({ · 212 unmodified lines
213	id?: string;	213	id?: string;
214	workspaceId?: string;	214	workspaceId?: string;
215	name?: string;	215	name?: string;
216	type?: "mcp" \| "openapi";	216	type?: "mcp" \| "openapi" \| "graphql";
217	config?: Record<string, unknown>;	217	config?: Record<string, unknown>;
218	enabled?: boolean;	218	enabled?: boolean;
219	}>(request);	219	}>(request);
@@ -222,8 +222,8 @@ const server = Bun.serve({ · 2 unmodified lines
222	return error(400, "workspaceId, name, type, and config are required");	222	return error(400, "workspaceId, name, type, and config are required");
223	}	223	}
224		224
225	if (body.type !== "mcp" && body.type !== "openapi") {	225	if (body.type !== "mcp" && body.type !== "openapi" && body.type !== "graphql") {
226	return error(400, "type must be 'mcp' or 'openapi'");	226	return error(400, "type must be 'mcp', 'openapi', or 'graphql'");
227	}	227	}
228		228
229	try {	229	try {

executor/apps/server/src/service.ts+101−34

 import { APPROVAL_DENIED_PREFIX } from "./execution-constants";
 import { createDiscoverTool } from "./tool-discovery";
 import type { ExternalToolSourceConfig } from "./tool-sources";
-import { loadExternalTools } from "./tool-sources";
+import { loadExternalTools, parseGraphqlOperationPaths } from "./tool-sources";
 import type {
   AccessPolicyRecord,
   AnonymousContext,
   ToolCallRequest,
   ToolDefinition,
   ToolDescriptor,
+  ToolSourceRecord,
   RuntimeOutputEvent,
   PolicyDecision,
   ResolvedToolCredential,
 }
 function normalizeExternalToolSource(raw: {
-  type: "mcp" | "openapi";
+  type: ToolSourceRecord["type"];
   name: string;
   config: Record<string, unknown>;
 }): ExternalToolSourceConfig {
     return merged as unknown as ExternalToolSourceConfig;
   }
+  if (raw.type === "graphql") {
+    if (typeof merged.endpoint !== "string" || merged.endpoint.trim().length === 0) {
+      throw new Error(`GraphQL source '${raw.name}' missing endpoint`);
+    }
+    return merged as unknown as ExternalToolSourceConfig;
+  }
   const spec = merged.spec;
   if (typeof spec !== "string" && typeof spec !== "object") {
     throw new Error(`OpenAPI source '${raw.name}' missing spec`);
     }));
   }
-  listToolSources(workspaceId: string): Array<{
+  listToolSources(workspaceId: string): ToolSourceRecord[] {
-    id: string;
-    workspaceId: string;
-    name: string;
-    type: "mcp" | "openapi";
-    enabled: boolean;
-    config: Record<string, unknown>;
-    createdAt: number;
-    updatedAt: number;
-  }> {
     return this.db.listToolSources(workspaceId);
   }
     id?: string;
     workspaceId: string;
     name: string;
-    type: "mcp" | "openapi";
+    type: ToolSourceRecord["type"];
     config: Record<string, unknown>;
     enabled?: boolean;
-  }): Promise<{
+  }): Promise<ToolSourceRecord & { warnings?: string[] }> {
-    id: string;
-    workspaceId: string;
-    name: string;
-    type: "mcp" | "openapi";
-    enabled: boolean;
-    config: Record<string, unknown>;
-    createdAt: number;
-    updatedAt: number;
-  }> {
     const source = this.db.upsertToolSource(input);
     this.workspaceToolCache.delete(source.workspaceId);
     await this.getWorkspaceTools(source.workspaceId);
     };
   }
+  /**
+   * For GraphQL tools with _graphqlSource, resolve the approval decision
+   * by parsing the query and checking policies against each virtual field path
+   * (e.g. linear.mutation.issueCreate, linear.query.issues).
+   *
+   * Returns the most restrictive decision across all field paths.
+   */
+  private getGraphqlDecision(
+    task: TaskRecord,
+    tool: ToolDefinition,
+    input: unknown,
+    workspaceTools: Map<string, ToolDefinition>,
+  ): { decision: PolicyDecision; effectivePaths: string[] } {
+    const sourceName = tool._graphqlSource!;
+    const payload = input && typeof input === "object" ? (input as Record<string, unknown>) : {};
+    const queryString = typeof payload.query === "string" ? payload.query : "";
+    if (!queryString.trim()) {
+      // No query to parse — fall back to tool's own approval
+      return { decision: this.getToolDecision(task, tool), effectivePaths: [tool.path] };
+    }
+    const { fieldPaths } = parseGraphqlOperationPaths(sourceName, queryString);
+    if (fieldPaths.length === 0) {
+      return { decision: this.getToolDecision(task, tool), effectivePaths: [tool.path] };
+    }
+    const policies = this.db.listAccessPolicies(task.workspaceId);
+    let worstDecision: PolicyDecision = "allow";
+    for (const fieldPath of fieldPaths) {
+      // Look up the pseudo-tool for this field path to get its default approval
+      const pseudoTool = workspaceTools.get(fieldPath);
+      const fieldDecision = pseudoTool
+        ? this.getDecisionForContext(pseudoTool, {
+            workspaceId: task.workspaceId,
+            actorId: task.actorId,
+            clientId: task.clientId,
+          }, policies)
+        : // Unknown field — check if any policies match, otherwise default to mutation=required
+          this.getDecisionForContext(
+            { ...tool, path: fieldPath, approval: fieldPath.includes(".mutation.") ? "required" : "auto" },
+            {
+              workspaceId: task.workspaceId,
+              actorId: task.actorId,
+              clientId: task.clientId,
+            },
+            policies,
+          );
+      // Escalate: deny > require_approval > allow
+      if (fieldDecision === "deny") {
+        worstDecision = "deny";
+        break; // Can't get worse
+      }
+      if (fieldDecision === "require_approval") {
+        worstDecision = "require_approval";
+      }
+    }
+    return { decision: worstDecision, effectivePaths: fieldPaths };
+  }
   private async invokeTool(task: TaskRecord, call: ToolCallRequest): Promise<unknown> {
     const { toolPath, input, callId } = call;
     const workspaceTools = await this.getWorkspaceTools(task.workspaceId);
       throw new Error(`Unknown tool: ${toolPath}`);
     }
-    const decision = this.getToolDecision(task, tool);
+    // Determine approval decision — for GraphQL tools, parse the query for granular paths
+    let decision: PolicyDecision;
+    let effectiveToolPath = toolPath;
+    if (tool._graphqlSource) {
+      const result = this.getGraphqlDecision(task, tool, input, workspaceTools);
+      decision = result.decision;
+      // Use the field paths for event reporting so approvals show what's actually being called
+      if (result.effectivePaths.length > 0) {
+        effectiveToolPath = result.effectivePaths.join(", ");
+      }
+    } else {
+      decision = this.getToolDecision(task, tool);
+    }
     if (decision === "deny") {
       this.publish(task.id, "task", "tool.call.denied", {
         taskId: task.id,
         callId,
-        toolPath,
+        toolPath: effectiveToolPath,
         reason: "policy_deny",
       });
-      throw new Error(`${APPROVAL_DENIED_PREFIX}${toolPath} (policy denied)`);
+      throw new Error(`${APPROVAL_DENIED_PREFIX}${effectiveToolPath} (policy denied)`);
     }
     let credential: ResolvedToolCredential | undefined;
     this.publish(task.id, "task", "tool.call.started", {
       taskId: task.id,
       callId,
-      toolPath,
+      toolPath: effectiveToolPath,
       approval: decision === "require_approval" ? "required" : "auto",
       input: asPayload(input),
     });
       const approval = this.db.createApproval({
         id: createApprovalId(),
         taskId: task.id,
-        toolPath,
+        toolPath: effectiveToolPath,
         input,
       });
         createdAt: approval.createdAt,
       });
-      const decision = await this.waitForApproval(approval.id);
+      const approvalDecision = await this.waitForApproval(approval.id);
-      if (decision === "denied") {
+      if (approvalDecision === "denied") {
         this.publish(task.id, "task", "tool.call.denied", {
           taskId: task.id,
           callId,
-          toolPath,
+          toolPath: effectiveToolPath,
           approvalId: approval.id,
         });
-        throw new Error(`${APPROVAL_DENIED_PREFIX}${toolPath} (${approval.id})`);
+        throw new Error(`${APPROVAL_DENIED_PREFIX}${effectiveToolPath} (${approval.id})`);
       }
     }
       this.publish(task.id, "task", "tool.call.completed", {
         taskId: task.id,
         callId,
-        toolPath,
+        toolPath: effectiveToolPath,
         output: asPayload(value),
       });
       return value;
       this.publish(task.id, "task", "tool.call.failed", {
         taskId: task.id,
         callId,
-        toolPath,
+        toolPath: effectiveToolPath,
         error: message,
       });
       throw error;

executor/apps/server/src/tool-sources.ts+404−2

@@ -32,7 +32,22 @@ export interface OpenApiToolSourceConfig { · 31 unmodified lines
32	overrides?: Record<string, { approval?: ToolApprovalMode }>;	32	overrides?: Record<string, { approval?: ToolApprovalMode }>;
33	}	33	}
34		34
35	export type ExternalToolSourceConfig = McpToolSourceConfig \| OpenApiToolSourceConfig;	35	export interface GraphqlToolSourceConfig {
		36	type: "graphql";
		37	name: string;
		38	endpoint: string;
		39	/** Optional static introspection result — if omitted, we introspect at load time */
		40	schema?: Record<string, unknown>;
		41	auth?: OpenApiAuth;
		42	defaultQueryApproval?: ToolApprovalMode;
		43	defaultMutationApproval?: ToolApprovalMode;
		44	overrides?: Record<string, { approval?: ToolApprovalMode }>;
		45	}
		46
		47	export type ExternalToolSourceConfig =
		48	\| McpToolSourceConfig
		49	\| OpenApiToolSourceConfig
		50	\| GraphqlToolSourceConfig;
36		51
37	function toObject(value: unknown): Record<string, unknown> {	52	function toObject(value: unknown): Record<string, unknown> {
38	return value && typeof value === "object" && !Array.isArray(value)	53	return value && typeof value === "object" && !Array.isArray(value)
@@ -398,6 +413,391 @@ async function loadOpenApiTools(config: OpenApiToolSourceConfig): Promise<ToolDe · 359 unmodified lines
398	return tools;	413	return tools;
399	}	414	}
400		415
		416	// ── GraphQL introspection ──
		417
		418	const INTROSPECTION_QUERY = `
		419	query IntrospectionQuery {
		420	__schema {
		421	queryType { name }
		422	mutationType { name }
		423	types {
		424	kind name
		425	fields {
		426	name description
		427	args { name description type { ...TypeRef } defaultValue }
		428	type { ...TypeRef }
		429	}
		430	inputFields {
		431	name description
		432	type { ...TypeRef }
		433	defaultValue
		434	}
		435	enumValues { name description }
		436	}
		437	}
		438	}
		439	fragment TypeRef on __Type {
		440	kind name
		441	ofType {
		442	kind name
		443	ofType {
		444	kind name
		445	ofType {
		446	kind name
		447	ofType { kind name }
		448	}
		449	}
		450	}
		451	}
		452	`;
		453
		454	interface GqlTypeRef {
		455	kind: string;
		456	name: string \| null;
		457	ofType?: GqlTypeRef \| null;
		458	}
		459
		460	interface GqlField {
		461	name: string;
		462	description: string \| null;
		463	args: Array<{
		464	name: string;
		465	description: string \| null;
		466	type: GqlTypeRef;
		467	defaultValue: string \| null;
		468	}>;
		469	type: GqlTypeRef;
		470	}
		471
		472	interface GqlInputField {
		473	name: string;
		474	description: string \| null;
		475	type: GqlTypeRef;
		476	defaultValue: string \| null;
		477	}
		478
		479	interface GqlEnumValue {
		480	name: string;
		481	description: string \| null;
		482	}
		483
		484	interface GqlType {
		485	kind: string;
		486	name: string;
		487	fields: GqlField[] \| null;
		488	inputFields: GqlInputField[] \| null;
		489	enumValues: GqlEnumValue[] \| null;
		490	}
		491
		492	interface GqlSchema {
		493	queryType: { name: string } \| null;
		494	mutationType: { name: string } \| null;
		495	types: GqlType[];
		496	}
		497
		498	/** Resolve a GqlTypeRef to the underlying named type (unwrapping NON_NULL/LIST wrappers) */
		499	function unwrapType(ref: GqlTypeRef): string \| null {
		500	if (ref.kind === "NON_NULL" && ref.ofType) return unwrapType(ref.ofType);
		501	if (ref.kind === "LIST" && ref.ofType) return unwrapType(ref.ofType);
		502	return ref.name;
		503	}
		504
		505	/**
		506	* Convert a GraphQL type reference to a TypeScript-like type hint,
		507	* recursively expanding INPUT_OBJECT types so the model sees actual fields.
		508	*/
		509	function gqlTypeToHint(ref: GqlTypeRef, typeMap?: Map<string, GqlType>, depth = 0): string {
		510	if (ref.kind === "NON_NULL" && ref.ofType) return gqlTypeToHint(ref.ofType, typeMap, depth);
		511	if (ref.kind === "LIST" && ref.ofType) return `${gqlTypeToHint(ref.ofType, typeMap, depth)}[]`;
		512
		513	if (ref.name && typeMap && depth < 3) {
		514	const resolved = typeMap.get(ref.name);
		515	if (resolved?.kind === "INPUT_OBJECT" && resolved.inputFields) {
		516	return expandInputObject(resolved, typeMap, depth);
		517	}
		518	if (resolved?.kind === "ENUM" && resolved.enumValues && resolved.enumValues.length > 0) {
		519	const values = resolved.enumValues.slice(0, 8).map((v) => `"${v.name}"`);
		520	const suffix = resolved.enumValues.length > 8 ? " \| ..." : "";
		521	return values.join(" \| ") + suffix;
		522	}
		523	}
		524
		525	// Map common GraphQL scalars to TS primitives
		526	if (ref.name) {
		527	switch (ref.name) {
		528	case "String":
		529	case "ID":
		530	case "DateTime":
		531	case "Date":
		532	case "UUID":
		533	case "JSONString":
		534	case "TimelessDate":
		535	return "string";
		536	case "Int":
		537	case "Float":
		538	return "number";
		539	case "Boolean":
		540	return "boolean";
		541	case "JSON":
		542	case "JSONObject":
		543	return "Record<string, unknown>";
		544	default:
		545	return ref.name;
		546	}
		547	}
		548	return "unknown";
		549	}
		550
		551	function expandInputObject(type: GqlType, typeMap: Map<string, GqlType>, depth: number): string {
		552	const fields = type.inputFields;
		553	if (!fields \|\| fields.length === 0) return "Record<string, unknown>";
		554	const entries = fields.slice(0, 16).map((f) => {
		555	const required = f.type.kind === "NON_NULL";
		556	return `${f.name}${required ? "" : "?"}: ${gqlTypeToHint(f.type, typeMap, depth + 1)}`;
		557	});
		558	const suffix = fields.length > 16 ? "; ..." : "";
		559	return `{ ${entries.join("; ")}${suffix} }`;
		560	}
		561
		562	function gqlFieldArgsTypeHint(args: GqlField["args"], typeMap?: Map<string, GqlType>): string {
		563	if (args.length === 0) return "{}";
		564	const entries = args.slice(0, 12).map((a) => {
		565	const required = a.type.kind === "NON_NULL";
		566	return `${a.name}${required ? "" : "?"}: ${gqlTypeToHint(a.type, typeMap)}`;
		567	});
		568	return `{ ${entries.join("; ")} }`;
		569	}
		570
		571	function isRequired(ref: GqlTypeRef): boolean {
		572	return ref.kind === "NON_NULL";
		573	}
		574
		575	/** Build a minimal GraphQL document for a single root field with its arguments */
		576	function buildFieldQuery(
		577	operationType: "query" \| "mutation",
		578	fieldName: string,
		579	args: GqlField["args"],
		580	): string {
		581	if (args.length === 0) {
		582	return `${operationType} { ${fieldName} }`;
		583	}
		584	const varDefs = args.map((a) => `$${a.name}: ${printGqlType(a.type)}`).join(", ");
		585	const fieldArgs = args.map((a) => `${a.name}: $${a.name}`).join(", ");
		586	return `${operationType}(${varDefs}) { ${fieldName}(${fieldArgs}) }`;
		587	}
		588
		589	function printGqlType(ref: GqlTypeRef): string {
		590	if (ref.kind === "NON_NULL" && ref.ofType) return `${printGqlType(ref.ofType)}!`;
		591	if (ref.kind === "LIST" && ref.ofType) return `[${printGqlType(ref.ofType)}]`;
		592	return ref.name ?? "String";
		593	}
		594
		595	/**
		596	* Parse a GraphQL query string to extract the operation type and root field names.
		597	* This is intentionally simple — no full parser needed, just enough for policy routing.
		598	*/
		599	export function parseGraphqlOperationPaths(
		600	sourceName: string,
		601	queryString: string,
		602	): { operationType: "query" \| "mutation" \| "subscription"; fieldPaths: string[] } {
		603	const trimmed = queryString.trim();
		604
		605	// Determine operation type
		606	let operationType: "query" \| "mutation" \| "subscription" = "query";
		607	if (/^mutation\b/i.test(trimmed)) operationType = "mutation";
		608	else if (/^subscription\b/i.test(trimmed)) operationType = "subscription";
		609
		610	// Find the first { ... } block and extract top-level field names
		611	const braceStart = trimmed.indexOf("{");
		612	if (braceStart === -1) return { operationType, fieldPaths: [] };
		613
		614	// Walk the content inside the first braces, extract field names at depth 0
		615	const content = trimmed.slice(braceStart + 1);
		616	const fieldPaths: string[] = [];
		617	let depth = 0;
		618	let current = "";
		619
		620	for (const char of content) {
		621	if (char === "{") {
		622	if (depth === 0 && current.trim()) {
		623	// Grab the field name (before any args in parens)
		624	const fieldName = current.trim().split(/[\s(]/)[0];
		625	if (fieldName && !fieldName.startsWith("__")) {
		626	fieldPaths.push(`${sanitizeSegment(sourceName)}.${operationType}.${sanitizeSegment(fieldName)}`);
		627	}
		628	}
		629	depth++;
		630	current = "";
		631	} else if (char === "}") {
		632	if (depth === 0) {
		633	// End of top-level block — grab last field if any
		634	const fieldName = current.trim().split(/[\s(]/)[0];
		635	if (fieldName && !fieldName.startsWith("__")) {
		636	fieldPaths.push(`${sanitizeSegment(sourceName)}.${operationType}.${sanitizeSegment(fieldName)}`);
		637	}
		638	break;
		639	}
		640	depth--;
		641	current = "";
		642	} else if (depth === 0) {
		643	if (char === "\n" \|\| char === ",") {
		644	const fieldName = current.trim().split(/[\s(]/)[0];
		645	if (fieldName && !fieldName.startsWith("__")) {
		646	fieldPaths.push(`${sanitizeSegment(sourceName)}.${operationType}.${sanitizeSegment(fieldName)}`);
		647	}
		648	current = "";
		649	} else {
		650	current += char;
		651	}
		652	}
		653	}
		654
		655	return { operationType, fieldPaths };
		656	}
		657
		658	async function loadGraphqlTools(config: GraphqlToolSourceConfig): Promise<ToolDefinition[]> {
		659	const authHeaders = buildStaticAuthHeaders(config.auth);
		660	const sourceKey = `graphql:${config.name}`;
		661	const credentialSpec = buildCredentialSpec(sourceKey, config.auth);
		662	const sourceName = sanitizeSegment(config.name);
		663
		664	// Introspect the schema
		665	const introspectionResult = await fetch(config.endpoint, {
		666	method: "POST",
		667	headers: {
		668	"content-type": "application/json",
		669	...authHeaders,
		670	},
		671	body: JSON.stringify({ query: INTROSPECTION_QUERY }),
		672	});
		673
		674	if (!introspectionResult.ok) {
		675	const text = await introspectionResult.text().catch(() => "");
		676	throw new Error(`GraphQL introspection failed: HTTP ${introspectionResult.status}: ${text.slice(0, 300)}`);
		677	}
		678
		679	const introspectionJson = (await introspectionResult.json()) as { data?: { __schema?: GqlSchema }; errors?: unknown[] };
		680	if (introspectionJson.errors) {
		681	throw new Error(`GraphQL introspection errors: ${JSON.stringify(introspectionJson.errors).slice(0, 500)}`);
		682	}
		683	const schema = introspectionJson.data?.__schema;
		684	if (!schema) {
		685	throw new Error("GraphQL introspection returned no schema");
		686	}
		687
		688	// Index types by name
		689	const typeMap = new Map<string, GqlType>();
		690	for (const t of schema.types) {
		691	typeMap.set(t.name, t);
		692	}
		693
		694	const tools: ToolDefinition[] = [];
		695
		696	// Create the main graphql tool — this is the one that actually executes queries
		697	const mainToolPath = `${sourceName}.graphql`;
		698	tools.push({
		699	path: mainToolPath,
		700	source: sourceKey,
		701	description: `Execute a GraphQL query or mutation against ${config.name}. Use the ${sourceName}.query.* and ${sourceName}.mutation.* tool descriptions to see available operations.`,
		702	approval: "auto", // Actual approval is determined dynamically per-invocation
		703	metadata: {
		704	argsType: "{ query: string; variables?: Record<string, unknown> }",
		705	returnsType: "unknown",
		706	},
		707	credential: credentialSpec,
		708	// Tag as graphql source so invokeTool knows to do dynamic path extraction
		709	_graphqlSource: config.name,
		710	run: async (input: unknown, context) => {
		711	const payload = toObject(input);
		712	const query = String(payload.query ?? "");
		713	const variables = payload.variables ?? undefined;
		714
		715	if (!query.trim()) {
		716	throw new Error("GraphQL query string is required");
		717	}
		718
		719	const response = await fetch(config.endpoint, {
		720	method: "POST",
		721	headers: {
		722	"content-type": "application/json",
		723	...authHeaders,
		724	...(context.credential?.headers ?? {}),
		725	},
		726	body: JSON.stringify({ query, variables }),
		727	});
		728
		729	if (!response.ok) {
		730	const text = await response.text().catch(() => "");
		731	throw new Error(`HTTP ${response.status} ${response.statusText}: ${text.slice(0, 500)}`);
		732	}
		733
		734	const result = await response.json() as { data?: unknown; errors?: unknown[] };
		735	if (result.errors && (!result.data \|\| Object.keys(result.data as object).length === 0)) {
		736	throw new Error(`GraphQL errors: ${JSON.stringify(result.errors).slice(0, 1000)}`);
		737	}
		738	// Return both data and errors if partial
		739	if (result.errors) return result;
		740	return result.data;
		741	},
		742	} as ToolDefinition & { _graphqlSource: string });
		743
		744	// Create pseudo-tools for each query/mutation field — these are for discovery/intellisense
		745	// but they all route through the main .graphql tool
		746	const rootTypes: Array<{ typeName: string \| null; operationType: "query" \| "mutation" }> = [
		747	{ typeName: schema.queryType?.name ?? null, operationType: "query" },
		748	{ typeName: schema.mutationType?.name ?? null, operationType: "mutation" },
		749	];
		750
		751	for (const { typeName, operationType } of rootTypes) {
		752	if (!typeName) continue;
		753	const rootType = typeMap.get(typeName);
		754	if (!rootType?.fields) continue;
		755
		756	const defaultApproval = operationType === "query"
		757	? (config.defaultQueryApproval ?? "auto")
		758	: (config.defaultMutationApproval ?? "required");
		759
		760	for (const field of rootType.fields) {
		761	if (field.name.startsWith("__")) continue;
		762
		763	const fieldPath = `${sourceName}.${operationType}.${sanitizeSegment(field.name)}`;
		764	const approval = config.overrides?.[field.name]?.approval ?? defaultApproval;
		765
		766	// Build the example query for the description
		767	const exampleQuery = buildFieldQuery(operationType, field.name, field.args);
		768
		769	tools.push({
		770	path: fieldPath,
		771	source: sourceKey,
		772	description: field.description
		773	? `${field.description}\n\nExample: ${sourceName}.graphql({ query: \`${exampleQuery}\`, variables: {...} })`
		774	: `GraphQL ${operationType}: ${field.name}\n\nExample: ${sourceName}.graphql({ query: \`${exampleQuery}\`, variables: {...} })`,
		775	approval,
		776	metadata: {
		777	argsType: gqlFieldArgsTypeHint(field.args, typeMap),
		778	returnsType: gqlTypeToHint(field.type, typeMap),
		779	},
		780	// Pseudo-tools don't have a run — they exist for discovery and policy matching only
		781	_pseudoTool: true,
		782	run: async (input: unknown, context) => {
		783	// If someone calls this directly, delegate to the main graphql tool
		784	const payload = toObject(input);
		785	if (!payload.query) {
		786	// Auto-build the query from the variables
		787	payload.query = buildFieldQuery(operationType, field.name, field.args);
		788	}
		789	// Find and invoke the main tool
		790	const mainTool = tools.find((t) => t.path === mainToolPath);
		791	if (!mainTool) throw new Error(`Main GraphQL tool not found`);
		792	return mainTool.run(payload, context);
		793	},
		794	} as ToolDefinition & { _pseudoTool: boolean });
		795	}
		796	}
		797
		798	return tools;
		799	}
		800
401	export function parseToolSourcesFromEnv(raw: string \| undefined): ExternalToolSourceConfig[] {	801	export function parseToolSourcesFromEnv(raw: string \| undefined): ExternalToolSourceConfig[] {
402	if (!raw \|\| raw.trim().length === 0) {	802	if (!raw \|\| raw.trim().length === 0) {
403	return [];	803	return [];
@@ -411,7 +811,7 @@ export function parseToolSourcesFromEnv(raw: string \| undefined): ExternalToolSo · 7 unmodified lines
411	return parsed as ExternalToolSourceConfig[];	811	return parsed as ExternalToolSourceConfig[];
412	}	812	}
413		813
414	export async function loadExternalTools(sources: ExternalToolSourceConfig[]): Promise<ToolDefinition[]> {	814	export async function loadExternalTools(sources: ExternalToolSourceConfig[]): Promise<{ tools: ToolDefinition[]; warnings: string[] }> {
415	const loaded: ToolDefinition[] = [];	815	const loaded: ToolDefinition[] = [];
416	const warnings: string[] = [];	816	const warnings: string[] = [];
417		817
@@ -421,6 +821,8 @@ export async function loadExternalTools(sources: ExternalToolSourceConfig[]): Pr · 3 unmodified lines
421	loaded.push(...(await loadMcpTools(source)));	821	loaded.push(...(await loadMcpTools(source)));
422	} else if (source.type === "openapi") {	822	} else if (source.type === "openapi") {
423	loaded.push(...(await loadOpenApiTools(source)));	823	loaded.push(...(await loadOpenApiTools(source)));
		824	} else if (source.type === "graphql") {
		825	loaded.push(...(await loadGraphqlTools(source)));
424	}	826	}
425	} catch (error) {	827	} catch (error) {
426	const message = error instanceof Error ? error.message : String(error);	828	const message = error instanceof Error ? error.message : String(error);

executor/apps/server/src/types.ts+7−1

   source?: string;
   metadata?: ToolTypeMetadata;
   credential?: ToolCredentialSpec;
+  /** For GraphQL sources: the source name used for dynamic path extraction */
+  _graphqlSource?: string;
+  /** For GraphQL pseudo-tools: marks tools that exist only for discovery/policy */
+  _pseudoTool?: boolean;
   run(input: unknown, context: ToolRunContext): Promise<unknown>;
 }
   returnsType?: string;
 }
+export type ToolSourceType = "mcp" | "openapi" | "graphql";
 export interface ToolSourceRecord {
   id: string;
   workspaceId: string;
   name: string;
-  type: "mcp" | "openapi";
+  type: ToolSourceType;
   config: Record<string, unknown>;
   enabled: boolean;
   createdAt: number;

executor/apps/web/src/components/tools-view.tsx+35−13

   name: string;
   label: string;
   description: string;
-  type: "openapi" | "mcp";
+  type: "openapi" | "mcp" | "graphql";
   spec?: string;
   url?: string;
+  endpoint?: string;
   baseUrl?: string;
   authNote?: string;
 }
     spec: "https://raw.githubusercontent.com/resend/resend-openapi/main/resend.yaml",
     baseUrl: "https://api.resend.com",
   },
+  {
+    name: "linear",
+    label: "Linear",
+    description: "Issues, projects, teams, cycles, labels",
+    type: "graphql",
+    endpoint: "https://api.linear.app/graphql",
+    authNote: "Requires API key as bearer credential",
+  },
 ];
 /** Derive a favicon URL from any URL string via Google's favicon service. */
 }
 function getFaviconUrl(preset: ApiPreset): string | null {
-  return faviconForUrl(preset.baseUrl ?? preset.url);
+  return faviconForUrl(preset.baseUrl ?? preset.endpoint ?? preset.url);
 }
 function getSourceFavicon(source: ToolSourceRecord): string | null {
   const url =
     source.type === "mcp"
       ? (source.config.url as string)
-      : (source.config.baseUrl as string) ?? (source.config.spec as string);
+      : source.type === "graphql"
+        ? (source.config.endpoint as string)
+        : (source.config.baseUrl as string) ?? (source.config.spec as string);
   return faviconForUrl(url);
 }
   const { context } = useSession();
   const [open, setOpen] = useState(false);
   const [presetsOpen, setPresetsOpen] = useState(false);
-  const [type, setType] = useState<"mcp" | "openapi">("mcp");
+  const [type, setType] = useState<"mcp" | "openapi" | "graphql">("mcp");
   const [name, setName] = useState("");
   const [nameManuallyEdited, setNameManuallyEdited] = useState(false);
   const [endpoint, setEndpoint] = useState("");
   const addSource = async (
     sourceName: string,
-    sourceType: "mcp" | "openapi",
+    sourceType: "mcp" | "openapi" | "graphql",
     config: Record<string, unknown>,
   ) => {
     if (!context) return;
       const config: Record<string, unknown> =
         preset.type === "mcp"
           ? { url: preset.url }
-          : {
+          : preset.type === "graphql"
-              spec: preset.spec,
+            ? { endpoint: preset.endpoint }
-              ...(preset.baseUrl ? { baseUrl: preset.baseUrl } : {}),
+            : {
-            };
+                spec: preset.spec,
+                ...(preset.baseUrl ? { baseUrl: preset.baseUrl } : {}),
+              };
       await addSource(preset.name, preset.type, config);
       if (preset.authNote) {
         toast.info(preset.authNote, { duration: 6000 });
       const config: Record<string, unknown> =
         type === "mcp"
           ? { url: endpoint }
-          : { spec: endpoint, ...(baseUrl ? { baseUrl } : {}) };
+          : type === "graphql"
+            ? { endpoint: endpoint }
+            : { spec: endpoint, ...(baseUrl ? { baseUrl } : {}) };
       await addSource(name.trim(), type, config);
       resetForm();
       setOpen(false);
                   <SelectItem value="openapi" className="text-xs">
                     OpenAPI Spec
                   </SelectItem>
+                  <SelectItem value="graphql" className="text-xs">
+                    GraphQL
+                  </SelectItem>
                 </SelectContent>
               </Select>
             </div>
             <div className="space-y-1.5">
               <Label className="text-xs text-muted-foreground">
-                {type === "mcp" ? "Endpoint URL" : "Spec URL"}
+                {type === "mcp" ? "Endpoint URL" : type === "graphql" ? "GraphQL Endpoint" : "Spec URL"}
               </Label>
               <Input
                 value={endpoint}
                 placeholder={
                   type === "mcp"
                     ? "https://mcp-server.example.com/sse"
-                    : "https://api.example.com/openapi.json"
+                    : type === "graphql"
+                      ? "https://api.example.com/graphql"
+                      : "https://api.example.com/openapi.json"
                 }
                 className="h-8 text-xs font-mono bg-background"
               />
         <span className="text-[11px] text-muted-foreground font-mono truncate block">
           {source.type === "mcp"
             ? (source.config.url as string)
-            : (source.config.spec as string)}
+            : source.type === "graphql"
+              ? (source.config.endpoint as string)
+              : (source.config.spec as string)}
         </span>
       </div>
       <Button

executor/apps/web/src/lib/api.ts+1−1

@@ -143,7 +143,7 @@ export async function upsertToolSource(request: { · 142 unmodified lines
143	id?: string;	143	id?: string;
144	workspaceId: string;	144	workspaceId: string;
145	name: string;	145	name: string;
146	type: "mcp" \| "openapi";	146	type: "mcp" \| "openapi" \| "graphql";
147	config: Record<string, unknown>;	147	config: Record<string, unknown>;
148	enabled?: boolean;	148	enabled?: boolean;
149	}): Promise<ToolSourceRecord> {	149	}): Promise<ToolSourceRecord> {

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

   hasSecret: boolean;
 }
+export type ToolSourceType = "mcp" | "openapi" | "graphql";
 export interface ToolSourceRecord {
   id: string;
   workspaceId: string;
   name: string;
-  type: "mcp" | "openapi";
+  type: ToolSourceType;
   config: Record<string, unknown>;
   enabled: boolean;
   createdAt: number;

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

   hasSecret: boolean;
 }
+export type ToolSourceType = "mcp" | "openapi" | "graphql";
 export interface ToolSourceRecord {
   id: string;
   workspaceId: string;
   name: string;
-  type: "mcp" | "openapi";
+  type: ToolSourceType;
   config: Record<string, unknown>;
   enabled: boolean;
   createdAt: number;