@yolk-sdk/codemode 0.1.0-canary.96

package/dist/executor.d.mts

@@ -0,0 +1,89 @@
+import { ToolJsonSchema } from "@yolk-sdk/agent/protocol";
+import * as Schema from "effect/Schema";
+
+//#region src/executor.d.ts
+/** A JSON Schema document. Only shapes declarations; values are never validated against it. */
+type CodeModeJsonSchema = ToolJsonSchema;
+/** Store contents: small JSON values by key. */
+type CodeModeStore = Readonly<Record<string, Schema.Json>>;
+type CodeModeToolContext = {
+  /** Aborted when the script ends (unawaited calls), times out, or the execution is aborted. */readonly signal: AbortSignal;
+};
+/**
+ * A function a script can call. Tools are called as `tools.<identifier>(args)` and
+ * `tools["<name>"](args)`; the identifier replaces characters that are not valid in a JavaScript
+ * identifier with `_`. Arguments and results make a JSON round trip; a rejection surfaces in the
+ * script as an `Error` with the same message.
+ */
+type CodeModeExecutorTool = {
+  readonly name: string;
+  readonly description?: string;
+  readonly inputSchema?: CodeModeJsonSchema;
+  readonly outputSchema?: CodeModeJsonSchema;
+  readonly execute: (args: unknown, context: CodeModeToolContext) => Promise<unknown>;
+};
+/**
+ * A top-level function (`name`) or namespace member (`namespace.member`) for scripts. Globals are
+ * host helpers: they are not tools and are not recorded as nested calls.
+ */
+type CodeModeExecutorGlobal = CodeModeExecutorTool & {
+  /** `execute` receives every call argument as an array instead of the first one. */readonly spread?: boolean; /** TypeScript parameter list and return type for declarations. */
+  readonly signature?: string;
+};
+/** One item of script output, in the order the script produced it. `data` is base64. */
+type CodeModeOutputItem = {
+  readonly type: 'text';
+  readonly text: string;
+} | {
+  readonly type: 'image';
+  readonly data: string;
+  readonly mimeType: string;
+};
+/**
+ * - `script`: the script threw, failed to parse, or its TypeScript could not be stripped.
+ * - `timeout`: the deadline expired.
+ * - `aborted`: the caller's signal fired.
+ * - `sandbox`: the engine failed outside the script's control.
+ */
+type CodeModeErrorKind = 'script' | 'timeout' | 'aborted' | 'sandbox';
+type CodeModeError = {
+  readonly kind: CodeModeErrorKind;
+  readonly message: string;
+  readonly stack?: string;
+};
+/** Keys a successful script changed with `store()`; `delete` lists keys stored as `undefined`. */
+type CodeModeStoreWrites = {
+  readonly set: CodeModeStore;
+  readonly delete: ReadonlyArray<string>;
+};
+type CodeModeExecutionResult = {
+  readonly ok: boolean; /** The script's return value (JSON); absent when it returned nothing. */
+  readonly value?: unknown;
+  readonly error?: CodeModeError; /** Kept for failed executions too, up to the failure. */
+  readonly output: ReadonlyArray<CodeModeOutputItem>; /** Only successful executions report writes. */
+  readonly storeWrites?: CodeModeStoreWrites;
+};
+type CodeModeExecuteOptions = {
+  readonly tools: ReadonlyArray<CodeModeExecutorTool>;
+  readonly globals: ReadonlyArray<CodeModeExecutorGlobal>; /** Overall deadline, including time spent in tools and waiting for a free execution slot. */
+  readonly timeoutMs: number; /** Heap cap of the script's VM. */
+  readonly memoryLimitBytes: number; /** Values the script reads with `load(key)`. */
+  readonly store: CodeModeStore;
+  readonly signal: AbortSignal;
+};
+/**
+ * Runs one script. `code` is the body of an async function (top-level `await` and `return`) and
+ * may carry TypeScript annotations: executors strip them or report a `script` error. The promise
+ * resolves for every script outcome, including failures, timeouts, and aborts; a rejection is
+ * treated as a `sandbox` failure. Running tool calls must be cancelled through their signal when
+ * the script ends.
+ *
+ * `@yolk-sdk/codemode/node` provides `makePiCodeModeExecutor`; hosts on other runtimes supply their
+ * own engine behind this interface.
+ */
+type CodeModeExecutor = {
+  readonly execute: (code: string, options: CodeModeExecuteOptions) => Promise<CodeModeExecutionResult>;
+};
+//#endregion
+export { CodeModeError, CodeModeErrorKind, CodeModeExecuteOptions, CodeModeExecutionResult, CodeModeExecutor, CodeModeExecutorGlobal, CodeModeExecutorTool, CodeModeJsonSchema, CodeModeOutputItem, CodeModeStore, CodeModeStoreWrites, CodeModeToolContext };
+//# sourceMappingURL=executor.d.mts.map

package/dist/executor.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.mts","names":[],"sources":["../src/executor.ts"],"mappings":";;;;;KAIY,kBAAA,GAAqB,cAAc;AAA/C;AAAA,KAGY,aAAA,GAAgB,QAAA,CAAS,MAAA,SAAe,MAAA,CAAO,IAAA;AAAA,KAE/C,mBAAA;EALmC,uGAOpC,MAAA,EAAQ,WAAW;AAAA;;;;;;;KASlB,oBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,GAAc,kBAAA;EAAA,SACd,YAAA,GAAe,kBAAA;EAAA,SACf,OAAA,GAAU,IAAA,WAAe,OAAA,EAAS,mBAAA,KAAwB,OAAA;AAAA;AAhBrE;;;;AAAA,KAuBY,sBAAA,GAAyB,oBAAoB;EAZ7C,4FAcD,MAAA;WAEA,SAAA;AAAA;;KAIC,kBAAA;EAAA,SACG,IAAA;EAAA,SAAuB,IAAA;AAAA;EAAA,SACvB,IAAA;EAAA,SAAwB,IAAA;EAAA,SAAuB,QAAA;AAAA;;;;;;;KAQlD,iBAAA;AAAA,KAEA,aAAA;EAAA,SACD,IAAA,EAAM,iBAAiB;EAAA,SACvB,OAAA;EAAA,SACA,KAAA;AAAA;;KAIC,mBAAA;EAAA,SACD,GAAA,EAAK,aAAA;EAAA,SACL,MAAA,EAAQ,aAAa;AAAA;AAAA,KAGpB,uBAAA;EAAA,SACD,EAAA;WAEA,KAAA;EAAA,SACA,KAAA,GAAQ,aAAA,EA3BmB;EAAA,SA6B3B,MAAA,EAAQ,aAAA,CAAc,kBAAA,GA5BM;EAAA,SA8B5B,WAAA,GAAc,mBAAA;AAAA;AAAA,KAGb,sBAAA;EAAA,SACD,KAAA,EAAO,aAAA,CAAc,oBAAA;EAAA,SACrB,OAAA,EAAS,aAAA,CAAc,sBAAA;WAEvB,SAAA,UA7BkB;EAAA,SA+BlB,gBAAA,UA7Bc;EAAA,SA+Bd,KAAA,EAAO,aAAA;EAAA,SACP,MAAA,EAAQ,WAAA;AAAA;;;;;AA7BH;AAIhB;;;;;KAsCY,gBAAA;EAAA,SACD,OAAA,GACP,IAAA,UACA,OAAA,EAAS,sBAAA,KACN,OAAA,CAAQ,uBAAA;AAAA"}

package/dist/executor.mjs

@@ -0,0 +1 @@
+export {};

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { CodeModeError, CodeModeErrorKind, CodeModeExecuteOptions, CodeModeExecutionResult, CodeModeExecutor, CodeModeExecutorGlobal, CodeModeExecutorTool, CodeModeJsonSchema, CodeModeOutputItem, CodeModeStore, CodeModeStoreWrites, CodeModeToolContext } from "./executor.mjs";
+import { CodeModeCatalogTool, CodeModeDescriptionInput, CodeModeListing, CodeModeToolExposure, codeModeCatalog, defaultCodeModeInlineBudget, describeCodeModeTool, estimateCodeModeTokens, findCodeModeTool, renderCodeModeDescription, selectCodeModeListing } from "./catalog.mjs";
+import { ClassifierConcurrencyLimiter, ClassifierToolParams, MakeClassifierToolOptions, classifierToolName, defaultClassifierProcessLimiter, defaultClassifierProcessMaxConcurrency, defaultClassifierToolMaxConcurrency, makeClassifierConcurrencyLimiter, makeClassifierTool } from "./classifier-tool.mjs";
+import { CodeModeSearchHit, CodeModeSearchOptions, codeModeSearchTokens, defaultCodeModeSearchLimit, searchCodeModeTools } from "./search.mjs";
+import { CodeModeCallSummary, CodeModeResultSegment, boundCodeModeSegments, codeModeResultSegments, codeModeSegmentsContent, defaultCodeModeMaxImageBytes, defaultCodeModeMaxImages, summarizeCodeModeCalls } from "./output.mjs";
+import { CodeModeStructuredContent, CodeModeToolResultEntry, codeModeStoreFromToolResults, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars } from "./store.mjs";
+import { CodeModeLimits, MakeCodeModeToolOptions, codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeToolName, defaultCodeModeLimits, makeCodeModeTool } from "./tool.mjs";
+export { type ClassifierConcurrencyLimiter, ClassifierToolParams, type CodeModeCallSummary, type CodeModeCatalogTool, type CodeModeDescriptionInput, type CodeModeError, type CodeModeErrorKind, type CodeModeExecuteOptions, type CodeModeExecutionResult, type CodeModeExecutor, type CodeModeExecutorGlobal, type CodeModeExecutorTool, type CodeModeJsonSchema, type CodeModeLimits, type CodeModeListing, type CodeModeOutputItem, type CodeModeResultSegment, type CodeModeSearchHit, type CodeModeSearchOptions, type CodeModeStore, type CodeModeStoreWrites, type CodeModeStructuredContent, type CodeModeToolContext, type CodeModeToolExposure, type CodeModeToolResultEntry, type MakeClassifierToolOptions, type MakeCodeModeToolOptions, boundCodeModeSegments, classifierToolName, codeModeCatalog, codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeResultSegments, codeModeSearchTokens, codeModeSegmentsContent, codeModeStoreFromToolResults, codeModeToolName, defaultClassifierProcessLimiter, defaultClassifierProcessMaxConcurrency, defaultClassifierToolMaxConcurrency, defaultCodeModeInlineBudget, defaultCodeModeLimits, defaultCodeModeMaxImageBytes, defaultCodeModeMaxImages, defaultCodeModeSearchLimit, describeCodeModeTool, estimateCodeModeTokens, findCodeModeTool, makeClassifierConcurrencyLimiter, makeClassifierTool, makeCodeModeTool, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars, renderCodeModeDescription, searchCodeModeTools, selectCodeModeListing, summarizeCodeModeCalls };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { codeModeCatalog, defaultCodeModeInlineBudget, describeCodeModeTool, estimateCodeModeTokens, findCodeModeTool, renderCodeModeDescription, selectCodeModeListing } from "./catalog.mjs";
+import { ClassifierToolParams, classifierToolName, defaultClassifierProcessLimiter, defaultClassifierProcessMaxConcurrency, defaultClassifierToolMaxConcurrency, makeClassifierConcurrencyLimiter, makeClassifierTool } from "./classifier-tool.mjs";
+import { codeModeSearchTokens, defaultCodeModeSearchLimit, searchCodeModeTools } from "./search.mjs";
+import { boundCodeModeSegments, codeModeResultSegments, codeModeSegmentsContent, defaultCodeModeMaxImageBytes, defaultCodeModeMaxImages, summarizeCodeModeCalls } from "./output.mjs";
+import { codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeToolName, defaultCodeModeLimits, makeCodeModeTool } from "./tool.mjs";
+import { codeModeStoreFromToolResults, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars } from "./store.mjs";
+export { ClassifierToolParams, boundCodeModeSegments, classifierToolName, codeModeCatalog, codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeResultSegments, codeModeSearchTokens, codeModeSegmentsContent, codeModeStoreFromToolResults, codeModeToolName, defaultClassifierProcessLimiter, defaultClassifierProcessMaxConcurrency, defaultClassifierToolMaxConcurrency, defaultCodeModeInlineBudget, defaultCodeModeLimits, defaultCodeModeMaxImageBytes, defaultCodeModeMaxImages, defaultCodeModeSearchLimit, describeCodeModeTool, estimateCodeModeTokens, findCodeModeTool, makeClassifierConcurrencyLimiter, makeClassifierTool, makeCodeModeTool, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars, renderCodeModeDescription, searchCodeModeTools, selectCodeModeListing, summarizeCodeModeCalls };

package/dist/node.d.mts

@@ -0,0 +1,34 @@
+import { CodeModeExecutor } from "./executor.mjs";
+import { CodemodeWasmModule } from "@earendil-works/pi-codemode";
+
+//#region src/node.d.ts
+/** Default cap of concurrent script executions per executor. */
+declare const defaultMaxConcurrentExecutions = 4;
+type PiCodeModeExecutorOptions = {
+  /**
+   * Compiled `quickjs-wasi/quickjs.wasm` (see pi's `loadQuickJSWasm`). Default: the file of the
+   * installed `quickjs-wasi` package, compiled once per process.
+   */
+  readonly wasm?: CodemodeWasmModule | Promise<CodemodeWasmModule>;
+  /**
+   * Worker entry that imports `@earendil-works/pi-codemode/worker`. Default: pi's own worker file,
+   * which exists on disk when the package is not bundled (Next `serverExternalPackages`).
+   */
+  readonly workerUrl?: string | URL; /** Concurrent executions of this executor; more wait for a free slot. Default 4. */
+  readonly maxConcurrentExecutions?: number;
+};
+/**
+ * A `CodeModeExecutor` on `@earendil-works/pi-codemode`: every execution gets a fresh QuickJS VM
+ * (WebAssembly) in a fresh worker thread, closed when the execution ends. Applies the timeout,
+ * heap cap, abort signal, and store, strips TypeScript annotations first, and caps concurrent
+ * executions per executor; create one executor per process (module scope) so the cap is
+ * per process.
+ *
+ * Node only. The worker inherits a copy of `process.env` (scripts cannot read it: the VM has no
+ * `process`). Under Next.js, list `@yolk-sdk/codemode`, `@earendil-works/pi-codemode`, and
+ * `quickjs-wasi` in `serverExternalPackages` so the worker file and wasm stay on disk.
+ */
+declare const makePiCodeModeExecutor: (options?: PiCodeModeExecutorOptions) => CodeModeExecutor;
+//#endregion
+export { PiCodeModeExecutorOptions, defaultMaxConcurrentExecutions, makePiCodeModeExecutor };
+//# sourceMappingURL=node.d.mts.map

package/dist/node.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.mts","names":[],"sources":["../src/node.ts"],"mappings":";;;;;cAqBa,8BAAA;AAAA,KAED,yBAAA;EAF+B;;;AAAA;EAAA,SAOhC,IAAA,GAAO,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EALV;;;;EAAA,SAU1B,SAAA,YAAqB,GAAA,EAAA;EAAA,SAErB,uBAAA;AAAA;;;;;;;;;AAAuB;AA4NlC;;cAAa,sBAAA,GACX,OAAA,GAAS,yBAAA,KACR,gBA4EF"}

package/dist/node.mjs

@@ -0,0 +1,215 @@
+import * as nodeModule from "node:module";
+import { Option, Predicate } from "effect";
+import * as Schema from "effect/Schema";
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+//#region src/node.ts
+/** Default cap of concurrent script executions per executor. */
+const defaultMaxConcurrentExecutions = 4;
+/** Abort- and deadline-aware counting semaphore for executions. */
+const makeExecutionSlots = (max) => {
+	let active = 0;
+	const waiting = [];
+	const acquire = (signal, timeoutMs) => {
+		if (signal.aborted) return Promise.resolve("aborted");
+		if (active < max) {
+			active++;
+			return Promise.resolve("acquired");
+		}
+		return new Promise((resolve) => {
+			let timer;
+			const settle = (outcome) => {
+				const index = waiting.indexOf(settle);
+				if (index !== -1) waiting.splice(index, 1);
+				if (timer !== void 0) clearTimeout(timer);
+				signal.removeEventListener("abort", onAbort);
+				resolve(outcome);
+			};
+			const onAbort = () => settle("aborted");
+			waiting.push(settle);
+			signal.addEventListener("abort", onAbort, { once: true });
+			if (Number.isFinite(timeoutMs)) timer = setTimeout(() => settle("timeout"), Math.max(0, timeoutMs));
+		});
+	};
+	const release = () => {
+		const next = waiting[0];
+		if (next === void 0) active--;
+		else next("acquired");
+	};
+	return {
+		acquire,
+		release
+	};
+};
+const wrapperPrefix = "async function __yolkCodeMode() {\n";
+const wrapperSuffix = "\n}";
+const ErrorWithCode = Schema.Struct({ code: Schema.String });
+const errorCode = (error) => Option.getOrUndefined(Option.map(Schema.decodeUnknownOption(ErrorWithCode)(error), (e) => e.code));
+const syntaxLocation = (error) => {
+	const match = /^[^\n]*:(\d+)\n([^\n]*)\n([^\n]*)\n/.exec(error.stack ?? "");
+	if (match === null) return "";
+	const line = Number(match[1]) - 1;
+	return line >= 1 ? ` (line ${line})\n${match[2] ?? ""}\n${match[3] ?? ""}` : "";
+};
+const typeStripMessage = (error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	if (errorCode(error) === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX") return `${message}. Write plain JavaScript: type annotations are stripped, but enums, namespaces, and parameter properties are not supported.`;
+	return `The script could not be parsed: ${message}${error instanceof Error ? syntaxLocation(error) : ""}`;
+};
+/**
+* Strips TypeScript annotations with Node's `stripTypeScriptTypes` (Node 22.13+; whitespace
+* replacement keeps line and column numbers). The script is wrapped in an async function so
+* top-level `return` and `await` parse. On Node without the API, code passes through unchanged.
+*/
+const stripTypes = (code) => {
+	if (!Predicate.isFunction(nodeModule.stripTypeScriptTypes)) return {
+		ok: true,
+		code
+	};
+	try {
+		const stripped = nodeModule.stripTypeScriptTypes(`${wrapperPrefix}${code}${wrapperSuffix}`, { mode: "strip" });
+		if (!stripped.startsWith(wrapperPrefix) || !stripped.endsWith(wrapperSuffix)) return {
+			ok: false,
+			error: {
+				kind: "script",
+				message: "The script could not be parsed."
+			}
+		};
+		return {
+			ok: true,
+			code: stripped.slice(34, stripped.length - 2)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: {
+				kind: "script",
+				message: typeStripMessage(error)
+			}
+		};
+	}
+};
+const piTool = (tool) => {
+	const converted = {
+		name: tool.name,
+		execute: (args, context) => tool.execute(args, context)
+	};
+	if (tool.description !== void 0) converted.description = tool.description;
+	if (tool.inputSchema !== void 0) converted.inputSchema = tool.inputSchema;
+	if (tool.outputSchema !== void 0) converted.outputSchema = tool.outputSchema;
+	return converted;
+};
+const piGlobal = (global) => {
+	const converted = piTool(global);
+	if (global.spread !== void 0) converted.spread = global.spread;
+	if (global.signature !== void 0) converted.signature = global.signature;
+	return converted;
+};
+const failure = (error) => ({
+	ok: false,
+	error,
+	output: []
+});
+const StoreWrites = Schema.Struct({
+	set: Schema.Record(Schema.String, Schema.Json),
+	delete: Schema.Array(Schema.String)
+});
+const decodeStoreWrites = Schema.decodeUnknownOption(StoreWrites);
+const fromPiResult = (result) => {
+	if (result.ok) {
+		const storeWrites = decodeStoreWrites(result.storeWrites);
+		if (Option.isNone(storeWrites)) return failure({
+			kind: "sandbox",
+			message: "The script reported store writes that are not JSON."
+		});
+		const converted = {
+			ok: true,
+			output: result.output,
+			storeWrites: storeWrites.value
+		};
+		if (result.value !== void 0) converted.value = result.value;
+		return converted;
+	}
+	const { kind, name, message, stack } = result.error;
+	const error = {
+		kind,
+		message: name !== void 0 && name.length > 0 && !message.startsWith(name) ? `${name}: ${message}` : message
+	};
+	if (stack !== void 0) error.stack = stack;
+	return {
+		ok: false,
+		error,
+		output: result.output
+	};
+};
+const describeError = (error) => error instanceof Error ? error.message : String(error);
+/**
+* A `CodeModeExecutor` on `@earendil-works/pi-codemode`: every execution gets a fresh QuickJS VM
+* (WebAssembly) in a fresh worker thread, closed when the execution ends. Applies the timeout,
+* heap cap, abort signal, and store, strips TypeScript annotations first, and caps concurrent
+* executions per executor; create one executor per process (module scope) so the cap is
+* per process.
+*
+* Node only. The worker inherits a copy of `process.env` (scripts cannot read it: the VM has no
+* `process`). Under Next.js, list `@yolk-sdk/codemode`, `@earendil-works/pi-codemode`, and
+* `quickjs-wasi` in `serverExternalPackages` so the worker file and wasm stay on disk.
+*/
+const makePiCodeModeExecutor = (options = {}) => {
+	const slots = makeExecutionSlots(Math.max(1, Math.floor(options.maxConcurrentExecutions ?? 4)));
+	const run = async (code, execution, queuedAt) => {
+		const remaining = () => execution.timeoutMs - (Date.now() - queuedAt);
+		const stripped = stripTypes(code);
+		if (!stripped.ok) return failure(stripped.error);
+		const timeoutMs = remaining();
+		if (timeoutMs <= 0) return failure({
+			kind: "timeout",
+			message: `Execution timed out after ${execution.timeoutMs} ms`
+		});
+		const sandboxOptions = {
+			tools: execution.tools.map(piTool),
+			globals: execution.globals.map(piGlobal),
+			timeoutMs,
+			memoryLimitBytes: execution.memoryLimitBytes
+		};
+		if (options.wasm !== void 0) sandboxOptions.wasm = options.wasm;
+		if (options.workerUrl !== void 0) sandboxOptions.workerUrl = options.workerUrl;
+		let sandbox;
+		try {
+			sandbox = new CodemodeSandbox(sandboxOptions);
+		} catch (error) {
+			return failure({
+				kind: "sandbox",
+				message: `Could not create the sandbox: ${describeError(error)}`
+			});
+		}
+		try {
+			return fromPiResult(await sandbox.execute(stripped.code, {
+				signal: execution.signal,
+				store: execution.store,
+				timeoutMs
+			}));
+		} finally {
+			await sandbox.close();
+		}
+	};
+	return { execute: async (code, execution) => {
+		const queuedAt = Date.now();
+		const slot = await slots.acquire(execution.signal, execution.timeoutMs);
+		if (slot === "aborted") return failure({
+			kind: "aborted",
+			message: "Execution aborted"
+		});
+		if (slot === "timeout") return failure({
+			kind: "timeout",
+			message: `Execution timed out after ${execution.timeoutMs} ms while waiting for a free execution slot`
+		});
+		try {
+			return await run(code, execution, queuedAt);
+		} finally {
+			slots.release();
+		}
+	} };
+};
+//#endregion
+export { defaultMaxConcurrentExecutions, makePiCodeModeExecutor };
+
+//# sourceMappingURL=node.mjs.map

package/dist/node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.mjs","names":[],"sources":["../src/node.ts"],"sourcesContent":["import * as nodeModule from 'node:module'\nimport { Option, Predicate } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport {\n  CodemodeSandbox,\n  type CodemodeResult,\n  type CodemodeSandboxOptions,\n  type CodemodeTool,\n  type CodemodeWasmModule\n} from '@earendil-works/pi-codemode'\nimport type {\n  CodeModeError,\n  CodeModeExecuteOptions,\n  CodeModeExecutionResult,\n  CodeModeExecutor,\n  CodeModeExecutorGlobal,\n  CodeModeExecutorTool,\n  CodeModeStoreWrites\n} from './executor.ts'\n\n/** Default cap of concurrent script executions per executor. */\nexport const defaultMaxConcurrentExecutions = 4\n\nexport type PiCodeModeExecutorOptions = {\n  /**\n   * Compiled `quickjs-wasi/quickjs.wasm` (see pi's `loadQuickJSWasm`). Default: the file of the\n   * installed `quickjs-wasi` package, compiled once per process.\n   */\n  readonly wasm?: CodemodeWasmModule | Promise<CodemodeWasmModule>\n  /**\n   * Worker entry that imports `@earendil-works/pi-codemode/worker`. Default: pi's own worker file,\n   * which exists on disk when the package is not bundled (Next `serverExternalPackages`).\n   */\n  readonly workerUrl?: string | URL\n  /** Concurrent executions of this executor; more wait for a free slot. Default 4. */\n  readonly maxConcurrentExecutions?: number\n}\n\ntype SlotOutcome = 'acquired' | 'aborted' | 'timeout'\n\ntype Waiter = (outcome: SlotOutcome) => void\n\n/** Abort- and deadline-aware counting semaphore for executions. */\nconst makeExecutionSlots = (max: number) => {\n  let active = 0\n  const waiting: Array<Waiter> = []\n\n  const acquire = (signal: AbortSignal, timeoutMs: number): Promise<SlotOutcome> => {\n    if (signal.aborted) return Promise.resolve('aborted')\n\n    if (active < max) {\n      active++\n\n      return Promise.resolve('acquired')\n    }\n\n    return new Promise(resolve => {\n      let timer: ReturnType<typeof setTimeout> | undefined\n\n      const settle: Waiter = outcome => {\n        const index = waiting.indexOf(settle)\n\n        if (index !== -1) waiting.splice(index, 1)\n\n        if (timer !== undefined) clearTimeout(timer)\n        signal.removeEventListener('abort', onAbort)\n        resolve(outcome)\n      }\n\n      const onAbort = () => settle('aborted')\n\n      waiting.push(settle)\n      signal.addEventListener('abort', onAbort, { once: true })\n\n      if (Number.isFinite(timeoutMs)) {\n        timer = setTimeout(() => settle('timeout'), Math.max(0, timeoutMs))\n      }\n    })\n  }\n\n  const release = () => {\n    const next = waiting[0]\n\n    if (next === undefined) {\n      active--\n    } else {\n      // The slot passes straight to the next waiter.\n      next('acquired')\n    }\n  }\n\n  return { acquire, release }\n}\n\nconst wrapperPrefix = 'async function __yolkCodeMode() {\\n'\n\nconst wrapperSuffix = '\\n}'\n\nconst ErrorWithCode = Schema.Struct({ code: Schema.String })\n\nconst errorCode = (error: unknown) =>\n  Option.getOrUndefined(Option.map(Schema.decodeUnknownOption(ErrorWithCode)(error), e => e.code))\n\nconst syntaxLocation = (error: Error) => {\n  const match = /^[^\\n]*:(\\d+)\\n([^\\n]*)\\n([^\\n]*)\\n/.exec(error.stack ?? '')\n\n  if (match === null) return ''\n\n  const line = Number(match[1]) - 1\n\n  return line >= 1 ? ` (line ${line})\\n${match[2] ?? ''}\\n${match[3] ?? ''}` : ''\n}\n\nconst typeStripMessage = (error: unknown) => {\n  const message = error instanceof Error ? error.message : String(error)\n\n  if (errorCode(error) === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX') {\n    return `${message}. Write plain JavaScript: type annotations are stripped, but enums, namespaces, and parameter properties are not supported.`\n  }\n\n  const location = error instanceof Error ? syntaxLocation(error) : ''\n\n  return `The script could not be parsed: ${message}${location}`\n}\n\ntype Stripped =\n  | { readonly ok: true; readonly code: string }\n  | { readonly ok: false; readonly error: CodeModeError }\n\n/**\n * Strips TypeScript annotations with Node's `stripTypeScriptTypes` (Node 22.13+; whitespace\n * replacement keeps line and column numbers). The script is wrapped in an async function so\n * top-level `return` and `await` parse. On Node without the API, code passes through unchanged.\n */\nconst stripTypes = (code: string): Stripped => {\n  if (!Predicate.isFunction(nodeModule.stripTypeScriptTypes)) return { ok: true, code }\n\n  try {\n    const stripped = nodeModule.stripTypeScriptTypes(`${wrapperPrefix}${code}${wrapperSuffix}`, {\n      mode: 'strip'\n    })\n\n    if (!stripped.startsWith(wrapperPrefix) || !stripped.endsWith(wrapperSuffix)) {\n      return { ok: false, error: { kind: 'script', message: 'The script could not be parsed.' } }\n    }\n\n    return {\n      ok: true,\n      code: stripped.slice(wrapperPrefix.length, stripped.length - wrapperSuffix.length)\n    }\n  } catch (error) {\n    return { ok: false, error: { kind: 'script', message: typeStripMessage(error) } }\n  }\n}\n\nconst piTool = (tool: CodeModeExecutorTool): CodemodeTool => {\n  const converted: CodemodeTool = {\n    name: tool.name,\n    execute: (args, context) => tool.execute(args, context)\n  }\n\n  if (tool.description !== undefined) converted.description = tool.description\n\n  if (tool.inputSchema !== undefined) converted.inputSchema = tool.inputSchema\n\n  if (tool.outputSchema !== undefined) converted.outputSchema = tool.outputSchema\n\n  return converted\n}\n\nconst piGlobal = (global: CodeModeExecutorGlobal): CodemodeTool => {\n  const converted = piTool(global)\n\n  if (global.spread !== undefined) converted.spread = global.spread\n\n  if (global.signature !== undefined) converted.signature = global.signature\n\n  return converted\n}\n\nconst failure = (error: CodeModeError): CodeModeExecutionResult => ({\n  ok: false,\n  error,\n  output: []\n})\n\nconst StoreWrites = Schema.Struct({\n  set: Schema.Record(Schema.String, Schema.Json),\n  delete: Schema.Array(Schema.String)\n})\n\nconst decodeStoreWrites = Schema.decodeUnknownOption(StoreWrites)\n\ntype MutableCodeModeError = {\n  kind: CodeModeError['kind']\n  message: string\n  stack?: string\n}\n\ntype MutableExecutionResult = {\n  ok: boolean\n  value?: unknown\n  error?: CodeModeError\n  output: CodeModeExecutionResult['output']\n  storeWrites?: CodeModeStoreWrites\n}\n\nconst fromPiResult = (result: CodemodeResult): CodeModeExecutionResult => {\n  if (result.ok) {\n    const storeWrites = decodeStoreWrites(result.storeWrites)\n\n    if (Option.isNone(storeWrites)) {\n      return failure({\n        kind: 'sandbox',\n        message: 'The script reported store writes that are not JSON.'\n      })\n    }\n\n    const converted: MutableExecutionResult = {\n      ok: true,\n      output: result.output,\n      storeWrites: storeWrites.value\n    }\n\n    if (result.value !== undefined) converted.value = result.value\n\n    return converted\n  }\n\n  const { kind, name, message, stack } = result.error\n  const named = name !== undefined && name.length > 0 && !message.startsWith(name)\n\n  const error: MutableCodeModeError = {\n    kind,\n    message: named ? `${name}: ${message}` : message\n  }\n\n  if (stack !== undefined) error.stack = stack\n\n  return { ok: false, error, output: result.output }\n}\n\nconst describeError = (error: unknown) => (error instanceof Error ? error.message : String(error))\n\n/**\n * A `CodeModeExecutor` on `@earendil-works/pi-codemode`: every execution gets a fresh QuickJS VM\n * (WebAssembly) in a fresh worker thread, closed when the execution ends. Applies the timeout,\n * heap cap, abort signal, and store, strips TypeScript annotations first, and caps concurrent\n * executions per executor; create one executor per process (module scope) so the cap is\n * per process.\n *\n * Node only. The worker inherits a copy of `process.env` (scripts cannot read it: the VM has no\n * `process`). Under Next.js, list `@yolk-sdk/codemode`, `@earendil-works/pi-codemode`, and\n * `quickjs-wasi` in `serverExternalPackages` so the worker file and wasm stay on disk.\n */\nexport const makePiCodeModeExecutor = (\n  options: PiCodeModeExecutorOptions = {}\n): CodeModeExecutor => {\n  const slots = makeExecutionSlots(\n    Math.max(1, Math.floor(options.maxConcurrentExecutions ?? defaultMaxConcurrentExecutions))\n  )\n\n  const run = async (code: string, execution: CodeModeExecuteOptions, queuedAt: number) => {\n    const remaining = () => execution.timeoutMs - (Date.now() - queuedAt)\n    const stripped = stripTypes(code)\n\n    if (!stripped.ok) return failure(stripped.error)\n\n    const timeoutMs = remaining()\n\n    if (timeoutMs <= 0) {\n      return failure({\n        kind: 'timeout',\n        message: `Execution timed out after ${execution.timeoutMs} ms`\n      })\n    }\n\n    const sandboxOptions: CodemodeSandboxOptions = {\n      tools: execution.tools.map(piTool),\n      globals: execution.globals.map(piGlobal),\n      timeoutMs,\n      memoryLimitBytes: execution.memoryLimitBytes\n    }\n\n    if (options.wasm !== undefined) sandboxOptions.wasm = options.wasm\n\n    if (options.workerUrl !== undefined) sandboxOptions.workerUrl = options.workerUrl\n\n    let sandbox: CodemodeSandbox\n\n    try {\n      sandbox = new CodemodeSandbox(sandboxOptions)\n    } catch (error) {\n      return failure({\n        kind: 'sandbox',\n        message: `Could not create the sandbox: ${describeError(error)}`\n      })\n    }\n\n    try {\n      return fromPiResult(\n        await sandbox.execute(stripped.code, {\n          signal: execution.signal,\n          store: execution.store,\n          timeoutMs\n        })\n      )\n    } finally {\n      await sandbox.close()\n    }\n  }\n\n  return {\n    execute: async (code, execution) => {\n      const queuedAt = Date.now()\n      const slot = await slots.acquire(execution.signal, execution.timeoutMs)\n\n      if (slot === 'aborted') return failure({ kind: 'aborted', message: 'Execution aborted' })\n\n      if (slot === 'timeout') {\n        return failure({\n          kind: 'timeout',\n          message: `Execution timed out after ${execution.timeoutMs} ms while waiting for a free execution slot`\n        })\n      }\n\n      try {\n        return await run(code, execution, queuedAt)\n      } finally {\n        slots.release()\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/output.d.mts

@@ -0,0 +1,42 @@
+import { CodeModeExecutionResult, CodeModeOutputItem } from "./executor.mjs";
+import { Content, NestedToolCallStatus } from "@yolk-sdk/agent/protocol";
+
+//#region src/output.d.ts
+/** Text or image piece of the model-visible result, in order. */
+type CodeModeResultSegment = CodeModeOutputItem;
+/**
+ * Keeps at most about `maxChars` characters of text: the head and the tail of the segments, with an
+ * omission marker in between. Images inside the omitted middle are dropped and counted.
+ */
+declare const boundCodeModeSegments: (segments: ReadonlyArray<CodeModeResultSegment>, maxChars: number) => ReadonlyArray<CodeModeResultSegment>;
+/** Agent `Content`: a plain string without images, ordered text and image parts otherwise. */
+declare const codeModeSegmentsContent: (segments: ReadonlyArray<CodeModeResultSegment>) => Content;
+type CodeModeCallSummary = {
+  readonly name: string;
+  readonly status: NestedToolCallStatus;
+};
+/** `name: 2 ok, 1 error; other: 1 cancelled`, by first appearance. */
+declare const summarizeCodeModeCalls: (calls: ReadonlyArray<CodeModeCallSummary>) => string;
+/** Default cap of images kept in one result. */
+declare const defaultCodeModeMaxImages = 8;
+/** Default cap of base64 image data kept in one result, in characters (4 MiB). */
+declare const defaultCodeModeMaxImageBytes: number;
+/**
+ * Model-visible segments of one execution: a `Script completed` / `Script failed` header with the
+ * wall time, the output in order, the JSON return value (omitted when undefined), and for failures
+ * the error and the tool calls already made. Images are kept in order while they fit `maxImages`
+ * (default 8) and `maxImageBytes` of base64 in total (default 4 MiB); an image that would exceed
+ * either is dropped and counted in an omission note after the output. The result is then bounded
+ * by `maxChars` with a head-and-tail cut, which also drops images in the omitted middle.
+ */
+declare const codeModeResultSegments: (input: {
+  readonly result: CodeModeExecutionResult;
+  readonly wallTimeMs: number;
+  readonly calls: ReadonlyArray<CodeModeCallSummary>;
+  readonly maxChars: number;
+  readonly maxImages?: number;
+  readonly maxImageBytes?: number;
+}) => ReadonlyArray<CodeModeResultSegment>;
+//#endregion
+export { CodeModeCallSummary, CodeModeResultSegment, boundCodeModeSegments, codeModeResultSegments, codeModeSegmentsContent, defaultCodeModeMaxImageBytes, defaultCodeModeMaxImages, summarizeCodeModeCalls };
+//# sourceMappingURL=output.d.mts.map

package/dist/output.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.mts","names":[],"sources":["../src/output.ts"],"mappings":";;;;;KAUY,qBAAA,GAAwB,kBAAkB;AAAtD;;;;AAAA,cA8Ba,qBAAA,GACX,QAAA,EAAU,aAAA,CAAc,qBAAA,GACxB,QAAA,aACC,aAAA,CAAc,qBAAA;AAHjB;AAAA,cA6Fa,uBAAA,GACX,QAAA,EAAU,aAAA,CAAc,qBAAA,MACvB,OAAA;AAAA,KAiBS,mBAAA;EAAA,SACD,IAAA;EAAA,SACA,MAAA,EAAQ,oBAAoB;AAAA;;cAM1B,sBAAA,GAA0B,KAAA,EAAO,aAAa,CAAC,mBAAA;;cAwC/C,wBAAA;;cAGA,4BAAA;;;;;AAhKyB;AA0FtC;;;cAmFa,sBAAA,GAA0B,KAAA;EAAA,SAC5B,MAAA,EAAQ,uBAAA;EAAA,SACR,UAAA;EAAA,SACA,KAAA,EAAO,aAAA,CAAc,mBAAA;EAAA,SACrB,QAAA;EAAA,SACA,SAAA;EAAA,SACA,aAAA;AAAA,MACP,aAAA,CAAc,qBAAA"}

package/dist/output.mjs

@@ -0,0 +1,184 @@
+import { ImagePart, TextPart, inlineBase64AttachmentSource } from "@yolk-sdk/agent/protocol";
+//#region src/output.ts
+const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+const isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+const headCut = (text, length) => length > 0 && length < text.length && isHighSurrogate(text.charCodeAt(length - 1)) ? length - 1 : length;
+const tailCut = (text, start) => start > 0 && start < text.length && isLowSurrogate(text.charCodeAt(start)) ? start + 1 : start;
+const textLength = (segments) => segments.reduce((total, segment) => total + (segment.type === "text" ? segment.text.length : 0), 0);
+const omissionMarker = (characters, images) => `\n\n[… ${characters} characters${images > 0 ? ` and ${images} image${images === 1 ? "" : "s"}` : ""} omitted …]\n\n`;
+const markerReserve = 80;
+/**
+* Keeps at most about `maxChars` characters of text: the head and the tail of the segments, with an
+* omission marker in between. Images inside the omitted middle are dropped and counted.
+*/
+const boundCodeModeSegments = (segments, maxChars) => {
+	const total = textLength(segments);
+	if (total <= maxChars) return segments;
+	const budget = Math.max(0, maxChars - markerReserve);
+	let headBudget = Math.ceil(budget / 2);
+	let tailBudget = budget - headBudget;
+	const head = [];
+	let headIndex = 0;
+	let headPartial = 0;
+	for (; headIndex < segments.length && headBudget > 0; headIndex++) {
+		const segment = segments[headIndex];
+		if (segment === void 0) break;
+		if (segment.type === "image") {
+			head.push(segment);
+			continue;
+		}
+		if (segment.text.length <= headBudget) {
+			head.push(segment);
+			headBudget -= segment.text.length;
+			continue;
+		}
+		headPartial = headCut(segment.text, headBudget);
+		head.push({
+			type: "text",
+			text: segment.text.slice(0, headPartial)
+		});
+		headBudget = 0;
+		break;
+	}
+	const tail = [];
+	let tailIndex = segments.length - 1;
+	let tailStart;
+	for (; tailIndex >= headIndex && tailBudget > 0; tailIndex--) {
+		const segment = segments[tailIndex];
+		if (segment === void 0) break;
+		if (segment.type === "image") {
+			if (tailIndex === headIndex) break;
+			tail.unshift(segment);
+			continue;
+		}
+		const available = tailIndex === headIndex ? segment.text.length - headPartial : segment.text.length;
+		if (available <= tailBudget && tailIndex !== headIndex) {
+			tail.unshift(segment);
+			tailBudget -= available;
+			continue;
+		}
+		tailStart = tailCut(segment.text, segment.text.length - Math.min(available, tailBudget));
+		tail.unshift({
+			type: "text",
+			text: segment.text.slice(tailStart)
+		});
+		tailBudget = 0;
+		break;
+	}
+	const keptText = textLength(head) + textLength(tail);
+	const keptImages = [...head, ...tail].filter((segment) => segment.type === "image").length;
+	const allImages = segments.filter((segment) => segment.type === "image").length;
+	return [
+		...head,
+		{
+			type: "text",
+			text: omissionMarker(total - keptText, allImages - keptImages)
+		},
+		...tail
+	];
+};
+const mergeText = (segments) => segments.reduce((merged, segment) => {
+	const last = merged.at(-1);
+	if (segment.type === "text" && last?.type === "text") merged[merged.length - 1] = {
+		type: "text",
+		text: last.text + segment.text
+	};
+	else if (segment.type === "image" || segment.text.length > 0) merged.push(segment);
+	return merged;
+}, []);
+/** Agent `Content`: a plain string without images, ordered text and image parts otherwise. */
+const codeModeSegmentsContent = (segments) => {
+	const merged = mergeText(segments);
+	if (merged.every((segment) => segment.type === "text")) return merged.map((segment) => segment.type === "text" ? segment.text : "").join("");
+	return merged.map((segment) => segment.type === "text" ? TextPart.make({ text: segment.text }) : ImagePart.make({
+		source: inlineBase64AttachmentSource(segment.data),
+		mimeType: segment.mimeType
+	}));
+};
+const statusOrder = [
+	"ok",
+	"error",
+	"cancelled"
+];
+/** `name: 2 ok, 1 error; other: 1 cancelled`, by first appearance. */
+const summarizeCodeModeCalls = (calls) => {
+	if (calls.length === 0) return "none";
+	const byName = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		const counts = byName.get(call.name) ?? /* @__PURE__ */ new Map();
+		counts.set(call.status, (counts.get(call.status) ?? 0) + 1);
+		byName.set(call.name, counts);
+	}
+	return [...byName].map(([name, counts]) => `${name}: ${statusOrder.flatMap((status) => {
+		const count = counts.get(status);
+		return count === void 0 ? [] : [`${count} ${status}`];
+	}).join(", ")}`).join("; ");
+};
+const stackFrames = (stack) => stack === void 0 ? [] : stack.split("\n").filter((line) => /^\s+at\s/.test(line) || /^\s*\S+:\d+/.test(line));
+const encodeValue = (value) => {
+	try {
+		return JSON.stringify(value) ?? "undefined";
+	} catch {
+		return "[unserializable value]";
+	}
+};
+/** Default cap of images kept in one result. */
+const defaultCodeModeMaxImages = 8;
+/** Default cap of base64 image data kept in one result, in characters (4 MiB). */
+const defaultCodeModeMaxImageBytes = 4 * 1024 * 1024;
+const imageOmissionNote = (dropped, maxImages, maxImageBytes) => `\n\n[… ${dropped} image${dropped === 1 ? "" : "s"} omitted: a result keeps at most ${maxImages} images and ${maxImageBytes} characters of base64 image data …]`;
+/**
+* Model-visible segments of one execution: a `Script completed` / `Script failed` header with the
+* wall time, the output in order, the JSON return value (omitted when undefined), and for failures
+* the error and the tool calls already made. Images are kept in order while they fit `maxImages`
+* (default 8) and `maxImageBytes` of base64 in total (default 4 MiB); an image that would exceed
+* either is dropped and counted in an omission note after the output. The result is then bounded
+* by `maxChars` with a head-and-tail cut, which also drops images in the omitted middle.
+*/
+const codeModeResultSegments = (input) => {
+	const { result } = input;
+	const maxImages = Math.max(0, Math.floor(input.maxImages ?? 8));
+	const maxImageBytes = Math.max(0, Math.floor(input.maxImageBytes ?? 4194304));
+	const ms = Math.round(input.wallTimeMs);
+	const segments = [];
+	const text = (value) => {
+		segments.push({
+			type: "text",
+			text: value
+		});
+	};
+	text(result.ok ? `Script completed in ${ms} ms.` : `Script failed after ${ms} ms.`);
+	if (result.output.length > 0) {
+		text("\n\nOutput:\n");
+		let keptImages = 0;
+		let keptImageBytes = 0;
+		let droppedImages = 0;
+		result.output.forEach((item, index) => {
+			const previous = result.output[index - 1];
+			if (item.type === "text") text(previous?.type === "text" ? `\n${item.text}` : item.text);
+			else if (keptImages < maxImages && keptImageBytes + item.data.length <= maxImageBytes) {
+				keptImages++;
+				keptImageBytes += item.data.length;
+				segments.push(item);
+			} else droppedImages++;
+		});
+		if (droppedImages > 0) text(imageOmissionNote(droppedImages, maxImages, maxImageBytes));
+	}
+	if (result.ok && result.value !== void 0) text(`\n\nReturn value:\n${encodeValue(result.value)}`);
+	if (!result.ok) {
+		const error = result.error ?? {
+			kind: "sandbox",
+			message: "The script failed without an error."
+		};
+		text(`\n\nScript error: ${error.kind}: ${error.message}`);
+		const frames = stackFrames(error.stack);
+		if (frames.length > 0) text(`\n${frames.join("\n")}`);
+		text(`\n\nTool calls made before the failure (they are not undone): ${summarizeCodeModeCalls(input.calls)}.`);
+	}
+	if (result.ok && result.output.length === 0 && result.value === void 0) text(" No output and no return value.");
+	return boundCodeModeSegments(mergeText(segments), input.maxChars);
+};
+//#endregion
+export { boundCodeModeSegments, codeModeResultSegments, codeModeSegmentsContent, defaultCodeModeMaxImageBytes, defaultCodeModeMaxImages, summarizeCodeModeCalls };
+
+//# sourceMappingURL=output.mjs.map