@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/headless/format.js

@@ -0,0 +1,85 @@
+//#region src/headless/format.ts
+/** Truncate a string to `max` characters, appending "..." if truncated. */
+function truncate(s, max) {
+	return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function createHumanFormatState() {
+	return { lastTextLength: 0 };
+}
+/**
+* Human-readable streaming formatter (the historical default). Assistant text
+* streams to stdout; tool/subagent/shell/error activity goes to stderr. The
+* `state` cursor is mutated so repeated `message_update` events only emit the
+* newly-appended text.
+*/
+function formatHuman(event, state) {
+	switch (event.type) {
+		case "agent_start":
+			state.lastTextLength = 0;
+			return {};
+		case "message_start":
+			if (event.message.role === "assistant") {
+				state.activeAssistantMessageId = event.message.id;
+				state.lastTextLength = 0;
+			}
+			return {};
+		case "message_update":
+			if (event.event.type !== "text-delta" || event.id !== state.activeAssistantMessageId || !event.event.delta) return {};
+			state.lastTextLength += event.event.delta.length;
+			return { stdout: event.event.delta };
+		case "message_end":
+			if (event.id !== state.activeAssistantMessageId) return {};
+			state.activeAssistantMessageId = void 0;
+			if (state.lastTextLength === 0) return {};
+			state.lastTextLength = 0;
+			return { stdout: "\n" };
+		case "tool_start": return { stderr: `[tool] ${event.toolName}\n` };
+		case "tool_end": return event.isError ? { stderr: `[tool error] ${truncate(String(event.result), 200)}\n` } : {};
+		case "shell_output": return { stderr: event.output };
+		case "subagent_start": return { stderr: `[subagent:${event.forked ? "forked:" : ""}${event.agentType}] ${truncate(event.task, 100)}\n` };
+		case "subagent_end": return event.isError ? { stderr: `[subagent error] ${truncate(event.result, 200)}\n` } : {};
+		case "error": return { stderr: `[error] ${event.error.message}\n` };
+		default: return {};
+	}
+}
+/** Convert an `Error` instance into a JSON-serializable plain object. */
+function serializeError(err) {
+	return {
+		name: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+}
+/**
+* JSONL (stream-json) formatter — returns a plain object to be `JSON.stringify`'d
+* as one line per event by the sink. `Error` instances are normalized so their
+* `name`/`message`/`stack` survive serialization (`JSON.stringify` turns a raw
+* `Error` into `{}`).
+*/
+function formatJsonl(event) {
+	const out = { ...event };
+	if ("error" in event && event.error instanceof Error) out.error = serializeError(event.error);
+	return out;
+}
+/** Render the final result for `--output text`: assistant text, newline-terminated. */
+function renderTextResult(result) {
+	return result.text.endsWith("\n") ? result.text : result.text + "\n";
+}
+/** Render the final result for `--output json`: one JSON object. */
+function renderJsonResult(result) {
+	return JSON.stringify({
+		status: result.status,
+		text: result.text,
+		finishReason: result.finishReason,
+		usage: result.usage,
+		toolCalls: result.toolCalls,
+		toolResults: result.toolResults,
+		error: result.error,
+		threadId: result.threadId,
+		exitCode: result.exitCode
+	}) + "\n";
+}
+//#endregion
+export { createHumanFormatState, formatHuman, formatJsonl, renderJsonResult, renderTextResult, truncate };
+
+//# sourceMappingURL=format.js.map

package/dist/headless/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","names":[],"sources":["../../src/headless/format.ts"],"sourcesContent":["/**\n * Output formatters for headless runs. All functions here are pure — they take\n * an event (or a final result) and return strings / plain objects. They never\n * touch `process.*`; the CLI adapter owns the sinks.\n */\nimport type { AgentControllerEvent } from '@mastra/core/agent-controller';\n\nimport type { RunMCResult } from './types.js';\n\n/** Truncate a string to `max` characters, appending \"...\" if truncated. */\nexport function truncate(s: string, max: number): string {\n  return s.length > max ? s.slice(0, max) + '...' : s;\n}\n\n/** Mutable per-stream cursor used by {@link formatHuman} to stream assistant text. */\nexport interface HumanFormatState {\n  activeAssistantMessageId?: string;\n  lastTextLength: number;\n}\n\nexport function createHumanFormatState(): HumanFormatState {\n  return { lastTextLength: 0 };\n}\n\n/** A chunk of formatted output destined for stdout and/or stderr. */\nexport interface FormattedOutput {\n  stdout?: string;\n  stderr?: string;\n}\n\n/**\n * Human-readable streaming formatter (the historical default). Assistant text\n * streams to stdout; tool/subagent/shell/error activity goes to stderr. The\n * `state` cursor is mutated so repeated `message_update` events only emit the\n * newly-appended text.\n */\nexport function formatHuman(event: AgentControllerEvent, state: HumanFormatState): FormattedOutput {\n  switch (event.type) {\n    case 'agent_start':\n      state.lastTextLength = 0;\n      return {};\n    case 'message_start':\n      if (event.message.role === 'assistant') {\n        state.activeAssistantMessageId = event.message.id;\n        state.lastTextLength = 0;\n      }\n      return {};\n    case 'message_update':\n      if (event.event.type !== 'text-delta' || event.id !== state.activeAssistantMessageId || !event.event.delta)\n        return {};\n      state.lastTextLength += event.event.delta.length;\n      return { stdout: event.event.delta };\n    case 'message_end':\n      if (event.id !== state.activeAssistantMessageId) return {};\n      state.activeAssistantMessageId = undefined;\n      if (state.lastTextLength === 0) return {};\n      state.lastTextLength = 0;\n      return { stdout: '\\n' };\n    case 'tool_start':\n      return { stderr: `[tool] ${event.toolName}\\n` };\n    case 'tool_end':\n      return event.isError ? { stderr: `[tool error] ${truncate(String(event.result), 200)}\\n` } : {};\n    case 'shell_output':\n      return { stderr: event.output };\n    case 'subagent_start':\n      return {\n        stderr: `[subagent:${event.forked ? 'forked:' : ''}${event.agentType}] ${truncate(event.task, 100)}\\n`,\n      };\n    case 'subagent_end':\n      return event.isError ? { stderr: `[subagent error] ${truncate(event.result, 200)}\\n` } : {};\n    case 'error':\n      return { stderr: `[error] ${event.error.message}\\n` };\n    default:\n      return {};\n  }\n}\n\n/** Convert an `Error` instance into a JSON-serializable plain object. */\nfunction serializeError(err: Error): { name: string; message: string; stack?: string } {\n  return { name: err.name, message: err.message, stack: err.stack };\n}\n\n/**\n * JSONL (stream-json) formatter — returns a plain object to be `JSON.stringify`'d\n * as one line per event by the sink. `Error` instances are normalized so their\n * `name`/`message`/`stack` survive serialization (`JSON.stringify` turns a raw\n * `Error` into `{}`).\n */\nexport function formatJsonl(event: AgentControllerEvent): Record<string, unknown> {\n  const out: Record<string, unknown> = { ...event };\n  if ('error' in event && event.error instanceof Error) {\n    out.error = serializeError(event.error);\n  }\n  return out;\n}\n\n/** Render the final result for `--output text`: assistant text, newline-terminated. */\nexport function renderTextResult(result: RunMCResult): string {\n  return result.text.endsWith('\\n') ? result.text : result.text + '\\n';\n}\n\n/** Render the final result for `--output json`: one JSON object. */\nexport function renderJsonResult(result: RunMCResult): string {\n  return (\n    JSON.stringify({\n      status: result.status,\n      text: result.text,\n      finishReason: result.finishReason,\n      usage: result.usage,\n      toolCalls: result.toolCalls,\n      toolResults: result.toolResults,\n      error: result.error,\n      threadId: result.threadId,\n      exitCode: result.exitCode,\n    }) + '\\n'\n  );\n}\n"],"mappings":";;AAUA,SAAgB,SAAS,GAAW,KAAqB;CACvD,OAAO,EAAE,SAAS,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,QAAQ;AACpD;AAQA,SAAgB,yBAA2C;CACzD,OAAO,EAAE,gBAAgB,EAAE;AAC7B;;;;;;;AAcA,SAAgB,YAAY,OAA6B,OAA0C;CACjG,QAAQ,MAAM,MAAd;EACE,KAAK;GACH,MAAM,iBAAiB;GACvB,OAAO,CAAC;EACV,KAAK;GACH,IAAI,MAAM,QAAQ,SAAS,aAAa;IACtC,MAAM,2BAA2B,MAAM,QAAQ;IAC/C,MAAM,iBAAiB;GACzB;GACA,OAAO,CAAC;EACV,KAAK;GACH,IAAI,MAAM,MAAM,SAAS,gBAAgB,MAAM,OAAO,MAAM,4BAA4B,CAAC,MAAM,MAAM,OACnG,OAAO,CAAC;GACV,MAAM,kBAAkB,MAAM,MAAM,MAAM;GAC1C,OAAO,EAAE,QAAQ,MAAM,MAAM,MAAM;EACrC,KAAK;GACH,IAAI,MAAM,OAAO,MAAM,0BAA0B,OAAO,CAAC;GACzD,MAAM,2BAA2B,KAAA;GACjC,IAAI,MAAM,mBAAmB,GAAG,OAAO,CAAC;GACxC,MAAM,iBAAiB;GACvB,OAAO,EAAE,QAAQ,KAAK;EACxB,KAAK,cACH,OAAO,EAAE,QAAQ,UAAU,MAAM,SAAS,IAAI;EAChD,KAAK,YACH,OAAO,MAAM,UAAU,EAAE,QAAQ,gBAAgB,SAAS,OAAO,MAAM,MAAM,GAAG,GAAG,EAAE,IAAI,IAAI,CAAC;EAChG,KAAK,gBACH,OAAO,EAAE,QAAQ,MAAM,OAAO;EAChC,KAAK,kBACH,OAAO,EACL,QAAQ,aAAa,MAAM,SAAS,YAAY,KAAK,MAAM,UAAU,IAAI,SAAS,MAAM,MAAM,GAAG,EAAE,IACrG;EACF,KAAK,gBACH,OAAO,MAAM,UAAU,EAAE,QAAQ,oBAAoB,SAAS,MAAM,QAAQ,GAAG,EAAE,IAAI,IAAI,CAAC;EAC5F,KAAK,SACH,OAAO,EAAE,QAAQ,WAAW,MAAM,MAAM,QAAQ,IAAI;EACtD,SACE,OAAO,CAAC;CACZ;AACF;;AAGA,SAAS,eAAe,KAA+D;CACrF,OAAO;EAAE,MAAM,IAAI;EAAM,SAAS,IAAI;EAAS,OAAO,IAAI;CAAM;AAClE;;;;;;;AAQA,SAAgB,YAAY,OAAsD;CAChF,MAAM,MAA+B,EAAE,GAAG,MAAM;CAChD,IAAI,WAAW,SAAS,MAAM,iBAAiB,OAC7C,IAAI,QAAQ,eAAe,MAAM,KAAK;CAExC,OAAO;AACT;;AAGA,SAAgB,iBAAiB,QAA6B;CAC5D,OAAO,OAAO,KAAK,SAAS,IAAI,IAAI,OAAO,OAAO,OAAO,OAAO;AAClE;;AAGA,SAAgB,iBAAiB,QAA6B;CAC5D,OACE,KAAK,UAAU;EACb,QAAQ,OAAO;EACf,MAAM,OAAO;EACb,cAAc,OAAO;EACrB,OAAO,OAAO;EACd,WAAW,OAAO;EAClB,aAAa,OAAO;EACpB,OAAO,OAAO;EACd,UAAU,OAAO;EACjB,UAAU,OAAO;CACnB,CAAC,IAAI;AAET"}

package/dist/headless/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Public headless / programmatic API for MastraCode.
+ *
+ * Programmatic (CI / Node) usage:
+ * ```ts
+ * import { createMastraCode } from 'mastracode';
+ * import { runMC } from 'mastracode/headless';
+ *
+ * const { controller, session } = await createMastraCode({ settingsPath });
+ * const run = runMC({ controller, session, prompt: 'Fix the bug' });
+ * for await (const event of run) { ... } // optional live events
+ * const result = await run.result;        // typed RunMCResult
+ * ```
+ *
+ * The CLI adapter (`runMCCli`) wraps the same `createMastraCode` → `runMC` flow.
+ */
+export { runMC } from './run-mc.js';
+export { autoApprovePolicy, denyPolicy, permissionModeToPolicy } from './policy.js';
+export { formatHuman, formatJsonl, renderTextResult, renderJsonResult, createHumanFormatState, truncate, } from './format.js';
+export type { FormattedOutput, HumanFormatState } from './format.js';
+export { runMCCli, hasHeadlessFlag, parseHeadlessArgs, printHeadlessUsage } from './cli.js';
+export type { HeadlessArgs, OutputMode } from './cli.js';
+export type { RunMCOptions, RunMCResult, RunMCStatus, RunMCUsage, RunMCToolCall, RunMCToolResult, RunMCError, RunMCThreadOptions, MCRun, RunMCGoalOptions, ResolutionPolicy, RunMode, ThinkingLevel, PermissionMode, } from './types.js';
+export { VALID_MODES, VALID_THINKING_LEVELS, VALID_PERMISSION_MODES } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/headless/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/headless/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAGpF,OAAO,EACL,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGrE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC5F,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGzD,YAAY,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,KAAK,EACL,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC"}

package/dist/headless/index.js

@@ -0,0 +1,6 @@
+import { autoApprovePolicy, denyPolicy, permissionModeToPolicy } from "./policy.js";
+import { runMC } from "./run-mc.js";
+import { createHumanFormatState, formatHuman, formatJsonl, renderJsonResult, renderTextResult, truncate } from "./format.js";
+import { VALID_MODES, VALID_PERMISSION_MODES, VALID_THINKING_LEVELS } from "./types.js";
+import { hasHeadlessFlag, parseHeadlessArgs, printHeadlessUsage, runMCCli } from "./cli.js";
+export { VALID_MODES, VALID_PERMISSION_MODES, VALID_THINKING_LEVELS, autoApprovePolicy, createHumanFormatState, denyPolicy, formatHuman, formatJsonl, hasHeadlessFlag, parseHeadlessArgs, permissionModeToPolicy, printHeadlessUsage, renderJsonResult, renderTextResult, runMC, runMCCli, truncate };

package/dist/headless/policy.d.ts

@@ -0,0 +1,17 @@
+import type { PermissionMode, ResolutionPolicy } from './types.js';
+/**
+ * Default policy — reproduces the historical headless behavior:
+ *  - approve every tool approval request,
+ *  - auto-approve `request_access` / sandbox access suspensions ("Yes"),
+ *  - auto-approve `submit_plan` suspensions (`{ action: 'approved' }`),
+ *  - answer any other suspension with a "use your best judgment" instruction.
+ */
+export declare const autoApprovePolicy: ResolutionPolicy;
+/**
+ * Strict policy — refuses every tool approval and aborts on any suspension.
+ * Useful for CI gating where unattended tool execution must not happen.
+ */
+export declare const denyPolicy: ResolutionPolicy;
+/** Resolve a named {@link PermissionMode} to its built-in {@link ResolutionPolicy}. */
+export declare function permissionModeToPolicy(mode: PermissionMode): ResolutionPolicy;
+//# sourceMappingURL=policy.d.ts.map

package/dist/headless/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/headless/policy.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBAoB/B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,gBAUxB,CAAC;AAEF,uFAAuF;AACvF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB,CAQ7E"}

package/dist/headless/policy.js

@@ -0,0 +1,42 @@
+//#region src/headless/policy.ts
+/**
+* Default policy — reproduces the historical headless behavior:
+*  - approve every tool approval request,
+*  - auto-approve `request_access` / sandbox access suspensions ("Yes"),
+*  - auto-approve `submit_plan` suspensions (`{ action: 'approved' }`),
+*  - answer any other suspension with a "use your best judgment" instruction.
+*/
+const autoApprovePolicy = {
+	onToolApproval(_event) {
+		return "approve";
+	},
+	onSuspension(event) {
+		const payload = event.suspendPayload ?? {};
+		if (event.toolName === "request_access" || payload.kind === "sandbox_access_request") return { resumeData: "Yes" };
+		if (event.toolName === "submit_plan") return { resumeData: { action: "approved" } };
+		return { resumeData: "Proceed with your best judgment. Do not ask further questions." };
+	}
+};
+/**
+* Strict policy — refuses every tool approval and aborts on any suspension.
+* Useful for CI gating where unattended tool execution must not happen.
+*/
+const denyPolicy = {
+	onToolApproval(_event) {
+		return "deny";
+	},
+	onSuspension(_event) {
+		return { abort: true };
+	}
+};
+/** Resolve a named {@link PermissionMode} to its built-in {@link ResolutionPolicy}. */
+function permissionModeToPolicy(mode) {
+	switch (mode) {
+		case "deny": return denyPolicy;
+		default: return autoApprovePolicy;
+	}
+}
+//#endregion
+export { autoApprovePolicy, denyPolicy, permissionModeToPolicy };
+
+//# sourceMappingURL=policy.js.map

package/dist/headless/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","names":[],"sources":["../../src/headless/policy.ts"],"sourcesContent":["/**\n * Resolution policies decide how `runMC` resumes interactive events\n * (`tool_approval_required`, `tool_suspended`) without a human in the loop.\n *\n * Policies are pure decision objects: they inspect the event and return a\n * decision. The runner is responsible for applying the decision to the session\n * and for any side effects (emitting labels, etc.). This keeps policies testable\n * and lets CI swap in stricter behavior without touching the runner.\n */\nimport type { AgentControllerEvent } from '@mastra/core/agent-controller';\n\nimport type { PermissionMode, ResolutionPolicy } from './types.js';\n\n/**\n * Default policy — reproduces the historical headless behavior:\n *  - approve every tool approval request,\n *  - auto-approve `request_access` / sandbox access suspensions (\"Yes\"),\n *  - auto-approve `submit_plan` suspensions (`{ action: 'approved' }`),\n *  - answer any other suspension with a \"use your best judgment\" instruction.\n */\nexport const autoApprovePolicy: ResolutionPolicy = {\n  onToolApproval(_event: Extract<AgentControllerEvent, { type: 'tool_approval_required' }>): 'approve' | 'deny' {\n    return 'approve';\n  },\n\n  onSuspension(\n    event: Extract<AgentControllerEvent, { type: 'tool_suspended' }>,\n  ): { resumeData: unknown } | { abort: true } {\n    const payload = (event.suspendPayload ?? {}) as Record<string, unknown>;\n\n    if (event.toolName === 'request_access' || payload.kind === 'sandbox_access_request') {\n      return { resumeData: 'Yes' };\n    }\n\n    if (event.toolName === 'submit_plan') {\n      return { resumeData: { action: 'approved' } };\n    }\n\n    return { resumeData: 'Proceed with your best judgment. Do not ask further questions.' };\n  },\n};\n\n/**\n * Strict policy — refuses every tool approval and aborts on any suspension.\n * Useful for CI gating where unattended tool execution must not happen.\n */\nexport const denyPolicy: ResolutionPolicy = {\n  onToolApproval(_event: Extract<AgentControllerEvent, { type: 'tool_approval_required' }>): 'approve' | 'deny' {\n    return 'deny';\n  },\n\n  onSuspension(\n    _event: Extract<AgentControllerEvent, { type: 'tool_suspended' }>,\n  ): { resumeData: unknown } | { abort: true } {\n    return { abort: true };\n  },\n};\n\n/** Resolve a named {@link PermissionMode} to its built-in {@link ResolutionPolicy}. */\nexport function permissionModeToPolicy(mode: PermissionMode): ResolutionPolicy {\n  switch (mode) {\n    case 'deny':\n      return denyPolicy;\n    case 'auto':\n    default:\n      return autoApprovePolicy;\n  }\n}\n"],"mappings":";;;;;;;;AAoBA,MAAa,oBAAsC;CACjD,eAAe,QAA+F;EAC5G,OAAO;CACT;CAEA,aACE,OAC2C;EAC3C,MAAM,UAAW,MAAM,kBAAkB,CAAC;EAE1C,IAAI,MAAM,aAAa,oBAAoB,QAAQ,SAAS,0BAC1D,OAAO,EAAE,YAAY,MAAM;EAG7B,IAAI,MAAM,aAAa,eACrB,OAAO,EAAE,YAAY,EAAE,QAAQ,WAAW,EAAE;EAG9C,OAAO,EAAE,YAAY,iEAAiE;CACxF;AACF;;;;;AAMA,MAAa,aAA+B;CAC1C,eAAe,QAA+F;EAC5G,OAAO;CACT;CAEA,aACE,QAC2C;EAC3C,OAAO,EAAE,OAAO,KAAK;CACvB;AACF;;AAGA,SAAgB,uBAAuB,MAAwC;CAC7E,QAAQ,MAAR;EACE,KAAK,QACH,OAAO;EAET,SACE,OAAO;CACX;AACF"}

package/dist/headless/run-mc.d.ts

@@ -0,0 +1,7 @@
+import type { MCRun, RunMCOptions } from './types.js';
+/**
+ * Run a headless MastraCode turn. Returns an {@link MCRun} handle that is
+ * async-iterable over controller events and resolves to a {@link RunMCResult}.
+ */
+export declare function runMC<TState extends Record<string, unknown>>(options: RunMCOptions<TState>): MCRun;
+//# sourceMappingURL=run-mc.d.ts.map

package/dist/headless/run-mc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-mc.d.ts","sourceRoot":"","sources":["../../src/headless/run-mc.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,KAAK,EAAoB,YAAY,EAA4B,MAAM,YAAY,CAAC;AA2IlG;;;GAGG;AACH,wBAAgB,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,KAAK,CA+WlG"}

package/dist/headless/run-mc.js

@@ -0,0 +1,408 @@
+import { THREAD_ACTIVE_MODEL_PACK_ID_KEY } from "../onboarding/settings.js";
+import { GoalManager } from "../goal-manager.js";
+import { createGoalReminderSignal } from "../goal-signal.js";
+import { MODEL_FALLBACK_STATE_KEY } from "../auth/account-rotation-processor.js";
+import { autoApprovePolicy } from "./policy.js";
+import { isSessionStartupCancelledError } from "@mastra/core/agent-controller";
+//#region src/headless/run-mc.ts
+/**
+* Core programmatic runner for MastraCode headless runs.
+*
+* `runMC` is a pure async runner: it takes an already-built `controller` +
+* `session` (from `createMastraCode(...)`), resolves run config, subscribes to
+* the session, applies a {@link ResolutionPolicy} for approvals/suspensions,
+* sends the prompt, and aggregates events into a {@link RunMCResult}.
+*
+* It never touches `process.*` and never calls `process.exit`. The returned
+* {@link MCRun} is async-iterable over controller events and also resolves to a
+* final result via `result`.
+*/
+function exitCodeForStatus(status) {
+	switch (status) {
+		case "completed":
+		case "done": return 0;
+		case "timeout": return 2;
+		default: return 1;
+	}
+}
+function aggregate(event, acc) {
+	switch (event.type) {
+		case "message_start":
+			if (event.message.role === "assistant") acc.activeAssistantMessageId = event.message.id;
+			break;
+		case "message_update":
+			if (event.event.type === "text-delta" && event.id === acc.activeAssistantMessageId) acc.text += event.event.delta;
+			break;
+		case "message_end":
+			if (event.id === acc.activeAssistantMessageId) acc.activeAssistantMessageId = void 0;
+			break;
+		case "tool_start":
+			acc.toolCalls.push({
+				id: event.toolCallId,
+				name: event.toolName,
+				args: event.args
+			});
+			break;
+		case "tool_end": {
+			const matching = acc.toolCalls.find((c) => c.id === event.toolCallId);
+			acc.toolResults.push({
+				id: event.toolCallId,
+				name: matching?.name ?? "",
+				result: event.result,
+				isError: event.isError
+			});
+			break;
+		}
+		case "usage_update":
+			acc.usage = {
+				inputTokens: event.usage.promptTokens,
+				outputTokens: event.usage.completionTokens,
+				totalTokens: event.usage.totalTokens
+			};
+			break;
+		case "error":
+			acc.error = {
+				name: event.error.name,
+				message: event.error.message,
+				stack: event.error.stack
+			};
+			break;
+	}
+}
+/** Resolve a thread by its exact ID. Titles are not unique, so we don't match on them. */
+async function resolveThread(session, threadId, resourceId) {
+	const byId = (await session.thread.list(resourceId ? { allResources: true } : void 0)).find((thread) => thread.id === threadId && (!resourceId || thread.resourceId === resourceId));
+	if (byId) return { threadId: byId.id };
+	return { error: `No thread found with ID "${threadId}"` };
+}
+/**
+* A simple back-pressured async queue. Events are pushed in; consumers pull via
+* the async iterator. `close()` ends iteration after draining buffered events.
+*
+* Buffered events are bounded by `maxBuffer`: if a consumer never iterates (the
+* result-only path, `await run.result` without `for await (...)`) — or simply
+* falls far behind — the oldest buffered events are dropped instead of growing
+* without limit. The aggregated {@link RunMCResult} is built independently of
+* this queue, so dropping buffered events never affects the final result.
+*/
+var EventQueue = class {
+	#buffer = [];
+	#resolvers = [];
+	#closed = false;
+	#maxBuffer;
+	constructor(maxBuffer = 1e4) {
+		this.#maxBuffer = maxBuffer;
+	}
+	push(value) {
+		if (this.#closed) return;
+		const resolve = this.#resolvers.shift();
+		if (resolve) {
+			resolve({
+				value,
+				done: false
+			});
+			return;
+		}
+		this.#buffer.push(value);
+		if (this.#buffer.length > this.#maxBuffer) this.#buffer.shift();
+	}
+	close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const resolve of this.#resolvers.splice(0)) resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	[Symbol.asyncIterator]() {
+		return { next: () => {
+			if (this.#buffer.length > 0) return Promise.resolve({
+				value: this.#buffer.shift(),
+				done: false
+			});
+			if (this.#closed) return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+			return new Promise((resolve) => this.#resolvers.push(resolve));
+		} };
+	}
+};
+/**
+* Run a headless MastraCode turn. Returns an {@link MCRun} handle that is
+* async-iterable over controller events and resolves to a {@link RunMCResult}.
+*/
+function runMC(options) {
+	const { controller, session } = options;
+	const goal = options.goal;
+	const policy = options.policy ?? autoApprovePolicy;
+	const queue = new EventQueue();
+	const acc = {
+		text: "",
+		toolCalls: [],
+		toolResults: []
+	};
+	let timeoutId;
+	let timedOut = false;
+	let aborted = false;
+	let maxTurnsExceeded = false;
+	let assistantTurns = 0;
+	let activeAssistantMessageId;
+	let settled = false;
+	let unsubscribe;
+	let resolveResult;
+	const result = new Promise((resolve) => {
+		resolveResult = resolve;
+	});
+	function finish(status, data = {}) {
+		if (settled) return;
+		settled = true;
+		if (timeoutId) clearTimeout(timeoutId);
+		unsubscribe?.();
+		queue.close();
+		resolveResult({
+			status,
+			text: acc.text,
+			finishReason: acc.finishReason,
+			usage: acc.usage,
+			toolCalls: acc.toolCalls,
+			toolResults: acc.toolResults,
+			threadId: acc.threadId ?? session.thread.getId() ?? void 0,
+			error: acc.error,
+			exitCode: exitCodeForStatus(status),
+			...data
+		});
+	}
+	function fail(message, name = "Error") {
+		if (!acc.error) acc.error = {
+			name,
+			message
+		};
+		finish("error");
+	}
+	function abort() {
+		if (settled) return;
+		aborted = true;
+		session.abort();
+	}
+	if (options.signal) if (options.signal.aborted) queueMicrotask(() => abort());
+	else options.signal.addEventListener("abort", () => abort(), { once: true });
+	function armTimeout() {
+		if (!options.timeoutMs || settled) return;
+		if (timeoutId) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			timedOut = true;
+			session.abort();
+			if (goal) finish("timeout");
+		}, options.timeoutMs);
+	}
+	(async () => {
+		armTimeout();
+		unsubscribe = session.subscribe((event) => {
+			if (settled) return;
+			if (goal) armTimeout();
+			if (event.type === "tool_approval_required") {
+				let decision;
+				try {
+					decision = policy.onToolApproval(event);
+				} catch (err) {
+					fail(`Resolution policy failed: ${err.message}`);
+					return;
+				}
+				session.respondToToolApproval({
+					decision: decision === "approve" ? "approve" : "decline",
+					toolCallId: event.toolCallId
+				});
+				queue.push(event);
+				return;
+			}
+			if (event.type === "tool_suspended") {
+				let outcome;
+				try {
+					outcome = policy.onSuspension(event);
+				} catch (err) {
+					fail(`Resolution policy failed: ${err.message}`);
+					return;
+				}
+				if ("abort" in outcome) {
+					queue.push(event);
+					abort();
+					return;
+				}
+				session.respondToToolSuspension({
+					toolCallId: event.toolCallId,
+					resumeData: outcome.resumeData
+				});
+				queue.push(event);
+				return;
+			}
+			if (event.type === "message_start" && event.message.role === "assistant") activeAssistantMessageId = event.message.id;
+			aggregate(event, acc);
+			queue.push(event);
+			if (event.type === "error" && goal) {
+				finish("error");
+				return;
+			}
+			if (event.type === "message_end" && event.id === activeAssistantMessageId && options.maxTurns !== void 0) {
+				activeAssistantMessageId = void 0;
+				assistantTurns += 1;
+				if (assistantTurns >= options.maxTurns && !maxTurnsExceeded) {
+					maxTurnsExceeded = true;
+					abort();
+				}
+			}
+			if (event.type === "goal_evaluation" && goal && !event.payload.pending) {
+				if (event.payload.status === "done" || event.payload.status === "paused") finish(event.payload.status, {
+					objective: goal.objective,
+					goalEvent: event,
+					reason: event.payload.reason ?? event.payload.results?.[0]?.reason,
+					iterations: event.payload.iteration,
+					maxRuns: event.payload.maxRuns
+				});
+				return;
+			}
+			if (event.type === "agent_end") {
+				acc.finishReason = event.reason;
+				if (goal) return;
+				if (timedOut) finish("timeout");
+				else if (event.reason === "error") finish("error");
+				else if (maxTurnsExceeded && event.reason !== "complete") finish("max_turns");
+				else if ((event.reason === "aborted" || aborted) && !maxTurnsExceeded) finish("aborted");
+				else finish("completed");
+			}
+		});
+		const thread = options.thread;
+		const targetResourceId = options.resourceId ?? session.identity.getResourceId();
+		let restoredThreadId;
+		try {
+			if (thread?.id) {
+				const resolved = await resolveThread(session, thread.id, targetResourceId);
+				if ("error" in resolved) return fail(resolved.error);
+				restoredThreadId = resolved.threadId;
+			} else if (thread?.continueLatest) {
+				const threads = await session.thread.list(targetResourceId ? { allResources: true } : void 0);
+				const resourceThreads = targetResourceId ? threads.filter((candidate) => candidate.resourceId === targetResourceId) : threads;
+				if (resourceThreads.length > 0) restoredThreadId = [...resourceThreads].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())[0].id;
+			}
+		} catch (err) {
+			return fail(`Failed to resolve thread: ${err.message}`);
+		}
+		const restoredThreadSelection = Boolean(restoredThreadId || thread?.clone);
+		const modeIdForModel = options.mode ?? (options.modeDefaults ? session.mode.get() : void 0);
+		const configuredDefaultModelId = modeIdForModel ? options.modeDefaults?.[modeIdForModel] : void 0;
+		const modelIdToApply = options.pack ? options.model : options.model ?? (options.mode || !restoredThreadSelection ? configuredDefaultModelId : void 0);
+		const modelSource = options.model ? "flag" : "mode";
+		try {
+			if (options.mode && !controller.listModes().some((mode) => mode.id === options.mode)) return fail(`Unknown mode: "${options.mode}"`);
+			if (modelIdToApply) {
+				const match = (await controller.listAvailableModels()).find((model) => model.id === modelIdToApply);
+				if (!match) {
+					if (modelSource === "flag") return fail(`Unknown model: "${modelIdToApply}"`);
+					return fail(`Unknown model "${modelIdToApply}" configured for mode "${modeIdForModel}"`);
+				}
+				if (!match.hasApiKey) {
+					const keyHint = match.apiKeyEnvVar ? ` Set ${match.apiKeyEnvVar} to use this model.` : "";
+					if (modelSource === "flag") return fail(`Model "${modelIdToApply}" has no API key configured.${keyHint}`);
+					return fail(`Model "${modelIdToApply}" (mode: ${modeIdForModel}) has no API key configured.${keyHint}`);
+				}
+			}
+		} catch (err) {
+			return fail(`Failed to resolve run config: ${err.message}`);
+		}
+		try {
+			if (options.resourceId) await controller.setResourceId(session, { resourceId: options.resourceId });
+		} catch (err) {
+			return fail(`Failed to set resource id: ${err.message}`);
+		}
+		try {
+			if (restoredThreadId) await session.thread.switch({ threadId: restoredThreadId });
+			else if (!thread?.clone) await session.thread.create();
+		} catch (err) {
+			return fail(`Failed to select thread: ${err.message}`);
+		}
+		if (thread?.clone) try {
+			await session.thread.clone();
+		} catch (err) {
+			return fail(`Failed to clone thread: ${err.message}`);
+		}
+		try {
+			if (options.mode) await session.mode.switch({ modeId: options.mode });
+			let packModelId;
+			if (options.pack) {
+				const packModeId = options.mode ?? session.mode.get();
+				const packSelection = options.pack.resolve(packModeId);
+				if (!packSelection) return fail(`Model pack "${options.pack.id}" has no model for ${packModeId} mode`);
+				const match = (await controller.listAvailableModels()).find((model) => model.id === packSelection.modelId);
+				if (!match) return fail(`Unknown model "${packSelection.modelId}" from pack "${options.pack.id}"`);
+				if (!match.hasApiKey) {
+					const keyHint = match.apiKeyEnvVar ? ` Set ${match.apiKeyEnvVar} to use this model.` : "";
+					return fail(`Model "${packSelection.modelId}" (pack: ${options.pack.id}) has no API key configured.${keyHint}`);
+				}
+				packModelId = packSelection.modelId;
+				await session.thread.setSetting({
+					key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
+					value: options.pack.id
+				});
+				await session.thread.setSetting({
+					key: MODEL_FALLBACK_STATE_KEY,
+					value: void 0
+				});
+				for (const [agentType, modelId] of Object.entries(packSelection.subagentModels ?? {})) await session.subagents.model.set({
+					modelId,
+					agentType
+				});
+				await session.state.set({
+					modelRoute: packSelection.modelRoute,
+					[MODEL_FALLBACK_STATE_KEY]: null
+				});
+			}
+			const sessionModelId = modelIdToApply ?? packModelId;
+			if (sessionModelId) await session.model.switch(sessionModelId);
+			options.pack?.onApplied?.();
+			if (options.thinkingLevel) await session.state.set({ thinkingLevel: options.thinkingLevel });
+		} catch (err) {
+			return fail(`Failed to apply run config: ${err.message}`);
+		}
+		if (options.title) try {
+			await session.thread.rename({ title: options.title });
+		} catch (err) {
+			return fail(`Failed to set thread title: ${err.message}`);
+		}
+		try {
+			if (goal) {
+				const threadId = session.thread.getId();
+				if (!threadId || !await session.thread.getById({ threadId })) await session.thread.create();
+				const goalManager = goal.goalManager ?? new GoalManager();
+				const state = {
+					controller,
+					session,
+					goalManager,
+					pendingNewThread: false
+				};
+				const objective = await goalManager.setGoal(state, goal.objective, goal.judgeModelId, goal.maxRuns);
+				if (!objective) return fail("Failed to set goal.");
+				const persisted = await controller.getCurrentAgent(session).getObjective({ threadId: session.thread.getId() });
+				if (!persisted || persisted.id !== objective.id) return fail("Failed to persist goal objective before sending goal signal.");
+				await goalManager.saveToThread(state);
+				if (!settled) await session.sendSignal(createGoalReminderSignal(objective)).accepted;
+			} else {
+				if (!options.prompt) return fail("A prompt or goal is required.");
+				await session.sendMessage({ content: options.prompt });
+			}
+		} catch (err) {
+			if (isSessionStartupCancelledError(err) || err instanceof Error && err.name === "AbortError" && (aborted || timedOut || options.signal?.aborted)) return finish(timedOut ? "timeout" : maxTurnsExceeded ? "max_turns" : "aborted");
+			return fail(`Failed to start run: ${err.message}`);
+		}
+	})();
+	return {
+		result,
+		abort,
+		[Symbol.asyncIterator]() {
+			return queue[Symbol.asyncIterator]();
+		}
+	};
+}
+//#endregion
+export { runMC };
+
+//# sourceMappingURL=run-mc.js.map