@mastra/code-sdk 1.0.3-alpha.0 → 1.1.0-alpha.2

package/dist/headless/run-mc.js

@@ -1,348 +1,346 @@
 import { GoalManager } from "../goal-manager.js";
 import { createGoalReminderSignal } from "../goal-signal.js";
 import { autoApprovePolicy } from "./policy.js";
+//#region src/headless/run-mc.ts
 function extractAssistantText(message) {
-  return message.content.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+	return message.content.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
 }
 function exitCodeForStatus(status) {
-  switch (status) {
-    case "completed":
-    case "done":
-      return 0;
-    case "timeout":
-      return 2;
-    default:
-      return 1;
-  }
+	switch (status) {
+		case "completed":
+		case "done": return 0;
+		case "timeout": return 2;
+		default: return 1;
+	}
 }
 function aggregate(event, acc) {
-  switch (event.type) {
-    case "message_end":
-      if (event.message.role === "assistant") {
-        acc.text += extractAssistantText(event.message);
-      }
-      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;
-  }
+	switch (event.type) {
+		case "message_end":
+			if (event.message.role === "assistant") acc.text += extractAssistantText(event.message);
+			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) {
-  const threads = await session.thread.list();
-  const byId = threads.find((t) => t.id === threadId);
-  if (byId) return { threadId: byId.id };
-  return { error: `No thread found with ID "${threadId}"` };
-}
-class EventQueue {
-  #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));
-      }
-    };
-  }
+	const byId = (await session.thread.list()).find((t) => t.id === threadId);
+	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 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);
-  }
-  void (async () => {
-    armTimeout();
-    try {
-      if (options.model) {
-        const available = await controller.listAvailableModels();
-        const match = available.find((m) => m.id === options.model);
-        if (!match) return fail(`Unknown model: "${options.model}"`);
-        if (!match.hasApiKey) {
-          const keyHint = match.apiKeyEnvVar ? ` Set ${match.apiKeyEnvVar} to use this model.` : "";
-          return fail(`Model "${options.model}" has no API key configured.${keyHint}`);
-        }
-        await session.model.switch({ modelId: options.model });
-      } else if (options.mode) {
-        const modelId = options.modeDefaults?.[options.mode];
-        if (modelId) {
-          const available = await controller.listAvailableModels();
-          const match = available.find((m) => m.id === modelId);
-          if (!match) return fail(`Unknown model "${modelId}" configured for mode "${options.mode}"`);
-          if (!match.hasApiKey) {
-            const keyHint = match.apiKeyEnvVar ? ` Set ${match.apiKeyEnvVar} to use this model.` : "";
-            return fail(`Model "${modelId}" (mode: ${options.mode}) has no API key configured.${keyHint}`);
-          }
-          await session.model.switch({ modelId });
-        }
-      }
-      if (options.thinkingLevel) {
-        await session.state.set({ thinkingLevel: options.thinkingLevel });
-      }
-    } catch (err) {
-      return fail(`Failed to resolve run config: ${err.message}`);
-    }
-    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;
-        }
-        void session.respondToToolSuspension({ toolCallId: event.toolCallId, resumeData: outcome.resumeData });
-        queue.push(event);
-        return;
-      }
-      aggregate(event, acc);
-      queue.push(event);
-      if (event.type === "error" && goal) {
-        finish("error");
-        return;
-      }
-      if (event.type === "message_end" && event.message.role === "assistant" && options.maxTurns !== 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");
-        }
-      }
-    });
-    try {
-      if (options.resourceId) {
-        await controller.setResourceId(session, { resourceId: options.resourceId });
-      }
-    } catch (err) {
-      return fail(`Failed to set resource id: ${err.message}`);
-    }
-    try {
-      const thread = options.thread;
-      if (thread?.id) {
-        const resolved = await resolveThread(session, thread.id);
-        if ("error" in resolved) return fail(resolved.error);
-        await session.thread.switch({ threadId: resolved.threadId });
-      } else if (thread?.continueLatest) {
-        const threads = await session.thread.list();
-        if (threads.length > 0) {
-          const sorted = [...threads].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-          await session.thread.switch({ threadId: sorted[0].id });
-        }
-      }
-    } catch (err) {
-      return fail(`Failed to select thread: ${err.message}`);
-    }
-    if (options.thread?.clone) {
-      try {
-        await session.thread.clone();
-      } catch (err) {
-        return fail(`Failed to clone thread: ${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,
-          planStartedGoalId: void 0
-        };
-        const objective = await goalManager.setGoal(state, goal.objective, goal.judgeModelId, goal.maxRuns);
-        if (!objective) return fail("Failed to set goal.");
-        const agent = controller.getCurrentAgent(session);
-        const persisted = await agent.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) {
-      return fail(`Failed to start run: ${err.message}`);
-    }
-  })();
-  return {
-    result,
-    abort,
-    [Symbol.asyncIterator]() {
-      return queue[Symbol.asyncIterator]();
-    }
-  };
+	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 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();
+		try {
+			if (options.model) {
+				const match = (await controller.listAvailableModels()).find((m) => m.id === options.model);
+				if (!match) return fail(`Unknown model: "${options.model}"`);
+				if (!match.hasApiKey) {
+					const keyHint = match.apiKeyEnvVar ? ` Set ${match.apiKeyEnvVar} to use this model.` : "";
+					return fail(`Model "${options.model}" has no API key configured.${keyHint}`);
+				}
+				await session.model.switch({ modelId: options.model });
+			} else if (options.mode) {
+				const modelId = options.modeDefaults?.[options.mode];
+				if (modelId) {
+					const match = (await controller.listAvailableModels()).find((m) => m.id === modelId);
+					if (!match) return fail(`Unknown model "${modelId}" configured for mode "${options.mode}"`);
+					if (!match.hasApiKey) {
+						const keyHint = match.apiKeyEnvVar ? ` Set ${match.apiKeyEnvVar} to use this model.` : "";
+						return fail(`Model "${modelId}" (mode: ${options.mode}) has no API key configured.${keyHint}`);
+					}
+					await session.model.switch({ modelId });
+				}
+			}
+			if (options.thinkingLevel) await session.state.set({ thinkingLevel: options.thinkingLevel });
+		} catch (err) {
+			return fail(`Failed to resolve run config: ${err.message}`);
+		}
+		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;
+			}
+			aggregate(event, acc);
+			queue.push(event);
+			if (event.type === "error" && goal) {
+				finish("error");
+				return;
+			}
+			if (event.type === "message_end" && event.message.role === "assistant" && options.maxTurns !== 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");
+			}
+		});
+		try {
+			if (options.resourceId) await controller.setResourceId(session, { resourceId: options.resourceId });
+		} catch (err) {
+			return fail(`Failed to set resource id: ${err.message}`);
+		}
+		try {
+			const thread = options.thread;
+			if (thread?.id) {
+				const resolved = await resolveThread(session, thread.id);
+				if ("error" in resolved) return fail(resolved.error);
+				await session.thread.switch({ threadId: resolved.threadId });
+			} else if (thread?.continueLatest) {
+				const threads = await session.thread.list();
+				if (threads.length > 0) {
+					const sorted = [...threads].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+					await session.thread.switch({ threadId: sorted[0].id });
+				}
+			}
+		} catch (err) {
+			return fail(`Failed to select thread: ${err.message}`);
+		}
+		if (options.thread?.clone) try {
+			await session.thread.clone();
+		} catch (err) {
+			return fail(`Failed to clone thread: ${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,
+					planStartedGoalId: void 0
+				};
+				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) {
+			return fail(`Failed to start run: ${err.message}`);
+		}
+	})();
+	return {
+		result,
+		abort,
+		[Symbol.asyncIterator]() {
+			return queue[Symbol.asyncIterator]();
+		}
+	};
 }
-export {
-  runMC
-};
+//#endregion
+export { runMC };
+
 //# sourceMappingURL=run-mc.js.map