@yolk-sdk/codemode 0.1.0-canary.100

package/dist/tool.mjs

@@ -0,0 +1,392 @@
+import { codeModeCatalog, describeCodeModeTool, findCodeModeTool, renderCodeModeDescription } from "./catalog.mjs";
+import { searchCodeModeTools } from "./search.mjs";
+import { boundCodeModeSegments, codeModeResultSegments, codeModeSegmentsContent, defaultCodeModeMaxImageBytes } from "./output.mjs";
+import { Cause, Clock, Data, Duration, Effect, Exit, Fiber, FiberSet, Option, Predicate, Scope } from "effect";
+import { ToolCall, ToolResult, boundNestedToolCallArgs, contentPartText, makeNestedToolCallRecorder, nestedToolCallMaxErrorChars, nestedToolCallRecordLimit, nestedToolCallResultFields, recordNestedToolCall, truncateCodePoints } from "@yolk-sdk/agent/protocol";
+import * as Schema from "effect/Schema";
+import { makeTool } from "@yolk-sdk/agent/tools";
+import { ToolError } from "@yolk-sdk/agent/loop";
+//#region src/tool.ts
+/** Default name of the code mode tool. */
+const codeModeToolName = "codemode";
+const defaultCodeModeLimits = {
+	timeoutMs: 12e4,
+	memoryLimitBytes: 64 * 1024 * 1024,
+	maxNestedCalls: 256,
+	maxOutputChars: 4e4,
+	maxImages: 8,
+	maxImageBytes: defaultCodeModeMaxImageBytes
+};
+/** Kept between a host deadline and the script deadline, for result handling. */
+const codeModeDeadlineMarginMs = 5e3;
+/** A deadline never clamps a script below this timeout. */
+const codeModeMinimumTimeoutMs = 1e3;
+const CodeModeParams = Schema.Struct({ code: Schema.String.annotate({ description: "Raw JavaScript: the body of an async function. Top-level await and return work. Not a function declaration and not a module." }) });
+var CodeModeExecutorRejected = class extends Data.TaggedError("CodeModeExecutorRejected") {};
+const errorMessage = (error) => error instanceof Error ? error.message : Predicate.isString(error) ? error : "unknown error";
+const nestedText = (content) => Predicate.isString(content) ? content : content.map(contentPartText).filter((text) => text.length > 0).join("\n");
+/** What a nested call resolves to: `structuredContent` for tools with an output schema (when
+* present), text content otherwise; error results reject with their text. A tool that declares an
+* output schema but returns no `structuredContent` resolves to its text: that is a tool bug, kept
+* readable rather than turned into a failure.
+*/
+const resolveNestedResult = (tool, result) => {
+	const text = nestedText(result.content);
+	if (result.isError === true) return {
+		ok: false,
+		message: text.length > 0 ? text : `Tool ${tool.name} failed.`
+	};
+	return tool.structured && result.structuredContent !== void 0 ? {
+		ok: true,
+		value: result.structuredContent
+	} : {
+		ok: true,
+		value: text
+	};
+};
+const recordedOutcome = (exit, durationMs) => {
+	if (Exit.isFailure(exit)) return Cause.hasInterruptsOnly(exit.cause) ? {
+		status: "cancelled",
+		durationMs
+	} : {
+		status: "error",
+		durationMs,
+		error: "The tool call failed unexpectedly."
+	};
+	const result = exit.value;
+	const outcome = result.isError === true ? {
+		status: "error",
+		durationMs,
+		error: nestedText(result.content)
+	} : {
+		status: "ok",
+		durationMs
+	};
+	if (result.usage !== void 0) outcome.usage = result.usage;
+	return outcome;
+};
+const hookOutcome = (exit) => Exit.isSuccess(exit) ? exit.value.isError === true ? "failure" : "success" : Cause.hasInterruptsOnly(exit.cause) ? "interrupted" : "failure";
+const SearchOptions = Schema.Struct({
+	limit: Schema.optionalKey(Schema.Finite),
+	namespace: Schema.optionalKey(Schema.String)
+});
+const decodeSearchOptions = Schema.decodeUnknownOption(SearchOptions);
+/** `searchTools`, `describeTool`, and `describeNamespace` over every nested tool. */
+const discoveryGlobals = (catalog) => [
+	{
+		name: "searchTools",
+		spread: true,
+		execute: (args) => {
+			const [query, options] = Array.isArray(args) ? args : [];
+			return Promise.resolve(searchCodeModeTools(catalog, Predicate.isString(query) ? query : "", Option.getOrElse(decodeSearchOptions(options ?? {}), () => ({}))));
+		}
+	},
+	{
+		name: "describeTool",
+		execute: (name) => {
+			const tool = Predicate.isString(name) ? findCodeModeTool(catalog, name) : void 0;
+			return Promise.resolve(tool === void 0 ? void 0 : describeCodeModeTool(tool));
+		}
+	},
+	{
+		name: "describeNamespace",
+		execute: (name) => {
+			const tools = catalog.filter((tool) => tool.namespace === name);
+			if (!Predicate.isString(name) || tools.length === 0) return Promise.resolve(void 0);
+			const description = tools.find((tool) => tool.namespaceDescription !== void 0)?.namespaceDescription;
+			const namespace = {
+				name,
+				tools: tools.map((tool) => ({
+					name: tool.identifier,
+					description: tool.description
+				}))
+			};
+			if (description !== void 0) namespace.description = description;
+			return Promise.resolve(namespace);
+		}
+	}
+];
+const hasStoreWrites = (result) => result.storeWrites !== void 0 && (Object.keys(result.storeWrites.set).length > 0 || result.storeWrites.delete.length > 0);
+const timeoutFor = (limit, deadline, now) => deadline === void 0 ? limit : Math.max(codeModeMinimumTimeoutMs, Math.min(limit, deadline - now - codeModeDeadlineMarginMs));
+/**
+* Waits at most `codeModeDeadlineMarginMs` for an effect (interrupting nested fibers) to finish; it
+* keeps running detached when a nested call does not respond to interruption in time.
+*/
+const boundedWait = (effect) => Effect.forkDetach(effect).pipe(Effect.flatMap((fiber) => Fiber.await(fiber).pipe(Effect.timeoutOption(Duration.millis(codeModeDeadlineMarginMs)), Effect.interruptible)), Effect.asVoid);
+const runScript = (input) => Effect.gen(function* () {
+	const { call, limits, nested, options } = input;
+	const store = options.loadStore === void 0 ? {} : yield* options.loadStore(input.context);
+	const startedAt = yield* Clock.currentTimeMillis;
+	const timeoutMs = timeoutFor(limits.timeoutMs, options.deadline?.(input.context), startedAt);
+	const catalog = codeModeCatalog(nested.tools);
+	return yield* Effect.acquireUseRelease(Scope.make(), (scope) => Effect.gen(function* () {
+		const fibers = yield* FiberSet.make().pipe(Scope.provide(scope));
+		const runFork = yield* FiberSet.runtime(fibers)();
+		const records = [];
+		const callTool = (tool) => (args, { signal }) => {
+			if (signal.aborted) return Promise.reject(/* @__PURE__ */ new Error(`${tool.callLabel} was cancelled.`));
+			if (records.length >= limits.maxNestedCalls) return Promise.reject(/* @__PURE__ */ new Error(`${tool.callLabel}: Nested call limit reached: a script may make at most ${limits.maxNestedCalls} tool calls. Batch the work or return partial results.`));
+			const params = args === void 0 ? {} : args;
+			const record = {
+				id: `${call.id}/${records.length + 1}`,
+				name: tool.name,
+				args: params
+			};
+			records.push(record);
+			const nestedCall = ToolCall.make({
+				id: record.id,
+				name: tool.name,
+				params
+			});
+			const afterNestedCall = options.afterNestedCall;
+			const run = afterNestedCall === void 0 ? nested.execute(nestedCall) : Effect.gen(function* () {
+				const started = yield* Clock.currentTimeMillis;
+				const afterNestedCallSafely = (hookInput) => Effect.suspend(() => afterNestedCall(hookInput)).pipe(Effect.exit, Effect.flatMap((hookExit) => Exit.isSuccess(hookExit) ? Effect.void : Effect.logWarning(`Code mode afterNestedCall failed for ${nestedCall.id}; ignored: ${Cause.pretty(hookExit.cause)}`)));
+				return yield* nested.execute(nestedCall).pipe(Effect.onExit((exit) => Effect.flatMap(Clock.currentTimeMillis, (finished) => afterNestedCallSafely(Exit.isSuccess(exit) ? {
+					call: nestedCall,
+					outcome: hookOutcome(exit),
+					durationMs: finished - started,
+					context: input.context,
+					result: exit.value
+				} : {
+					call: nestedCall,
+					outcome: hookOutcome(exit),
+					durationMs: finished - started,
+					context: input.context
+				}))));
+			});
+			const admitted = options.beforeNestedCall === void 0 ? run : options.beforeNestedCall({
+				call: nestedCall,
+				context: input.context
+			}).pipe(Effect.matchEffect({
+				onFailure: (message) => Effect.succeed(ToolResult.make({
+					toolCallId: nestedCall.id,
+					content: message,
+					isError: true
+				})),
+				onSuccess: () => run
+			}));
+			const execution = Effect.gen(function* () {
+				const started = yield* Clock.currentTimeMillis;
+				return yield* admitted.pipe(Effect.onExit((exit) => Effect.map(Clock.currentTimeMillis, (finished) => {
+					record.outcome = recordedOutcome(exit, finished - started);
+				})));
+			});
+			return new Promise((resolve, reject) => {
+				runFork(execution, { signal }).addObserver((exit) => {
+					if (Exit.isFailure(exit)) {
+						reject(/* @__PURE__ */ new Error(Cause.hasInterruptsOnly(exit.cause) ? `${tool.callLabel} was cancelled.` : `${tool.callLabel} failed unexpectedly.`));
+						return;
+					}
+					const resolution = resolveNestedResult(tool, exit.value);
+					if (resolution.ok) resolve(resolution.value);
+					else reject(/* @__PURE__ */ new Error(`${tool.callLabel}: ${resolution.message}`));
+				});
+			});
+		};
+		const tools = catalog.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: tool.inputSchema,
+			outputSchema: tool.outputSchema,
+			callLabel: tool.callLabel,
+			execute: callTool(tool)
+		}));
+		const result = yield* Effect.tryPromise({
+			try: (signal) => options.executor.execute(input.code, {
+				tools,
+				globals: discoveryGlobals(catalog),
+				timeoutMs,
+				memoryLimitBytes: limits.memoryLimitBytes,
+				store,
+				signal
+			}),
+			catch: (error) => new CodeModeExecutorRejected({ message: errorMessage(error) })
+		}).pipe(Effect.catch((error) => Effect.succeed({
+			ok: false,
+			error: {
+				kind: "sandbox",
+				message: `The code mode executor failed: ${error.message}`
+			},
+			output: []
+		})), Effect.timeoutOption(Duration.millis(timeoutMs + codeModeDeadlineMarginMs)), Effect.map(Option.getOrElse(() => ({
+			ok: false,
+			error: {
+				kind: "timeout",
+				message: `Execution timed out after ${timeoutMs} ms (the executor did not stop in time)`
+			},
+			output: []
+		}))));
+		yield* boundedWait(FiberSet.clear(fibers));
+		const finishedAt = yield* Clock.currentTimeMillis;
+		const recorded = records.map((record) => ({
+			id: record.id,
+			name: record.name,
+			args: record.args,
+			...record.outcome ?? { status: "cancelled" }
+		}));
+		const { nestedCalls, usage } = nestedToolCallResultFields(recorded.reduce(recordNestedToolCall, makeNestedToolCallRecorder({ maxCalls: limits.maxNestedCalls })));
+		const content = codeModeSegmentsContent(codeModeResultSegments({
+			result,
+			wallTimeMs: finishedAt - startedAt,
+			calls: recorded,
+			maxChars: limits.maxOutputChars,
+			maxImages: limits.maxImages,
+			maxImageBytes: limits.maxImageBytes
+		}));
+		const structuredContent = { codemode: result.ok && result.storeWrites !== void 0 && hasStoreWrites(result) ? {
+			ok: true,
+			storeWrites: result.storeWrites
+		} : { ok: result.ok } };
+		const fields = {
+			toolCallId: call.id,
+			content,
+			structuredContent,
+			nestedCalls
+		};
+		if (!result.ok) fields.isError = true;
+		if (usage !== void 0) fields.usage = usage;
+		return ToolResult.make(fields);
+	}), (scope, exit) => boundedWait(Scope.close(scope, exit)));
+});
+const argsPreviewChars = 200;
+const interruptedCallStatus = (entry) => {
+	const outcome = entry.outcome;
+	if (outcome === void 0) return "unknown";
+	if (Predicate.isTagged(outcome, "Failed")) return "failed";
+	return outcome.result.isError === true ? "failed" : "applied";
+};
+const nestedEntryState = (entry) => {
+	const outcome = entry.outcome;
+	if (outcome === void 0) return "unknown: it started but never recorded a result, so it may have been applied";
+	if (Predicate.isTagged(outcome, "Failed")) return `completed with an error: ${truncateCodePoints(outcome.error.message, nestedToolCallMaxErrorChars)}`;
+	return outcome.result.isError === true ? "completed with an error result" : "applied";
+};
+/** The bounded, wire-safe `interruptedCalls` of an abandoned execution's nested ledger entries:
+* the `nestedCalls` record bounds (`maxCalls`, 8 KiB of arguments per call, 32 KiB in total).
+*/
+const interruptedCalls = (nested, maxCalls) => {
+	const counts = {
+		applied: 0,
+		failed: 0,
+		unknown: 0
+	};
+	const calls = [];
+	let argsBytes = 0;
+	let complete = true;
+	for (const entry of nested) {
+		const status = interruptedCallStatus(entry);
+		counts[status]++;
+		if (calls.length >= maxCalls) {
+			complete = false;
+			continue;
+		}
+		const { args, bytes, truncated } = boundNestedToolCallArgs(entry.args, argsBytes);
+		if (truncated || entry.argsTruncated) complete = false;
+		argsBytes += bytes;
+		calls.push({
+			key: entry.key,
+			toolName: entry.toolName,
+			args,
+			status
+		});
+	}
+	return {
+		calls,
+		complete,
+		counts
+	};
+};
+/**
+* The result of a code mode call whose earlier execution was abandoned (claimed, lease expired,
+* no result recorded). The script never runs again: the result lists that execution's ledgered
+* nested calls as applied, failed, or unknown, and says they were not undone. The text is bounded
+* by `maxOutputChars`; `structuredContent.codemode.interruptedCalls` carries the same entries for
+* hosts, bounded like `nestedCalls`. When the ledger cannot list them, the result stays
+* interrupted, says they may have been applied, and sets `interruptedCallsUnavailable` instead.
+*/
+const abandonedScriptResult = (limits) => ({ call, nested }) => {
+	const maxChars = limits.maxOutputChars;
+	const listing = nested === void 0 ? "Its ledgered nested tool calls could not be listed (the tool ledger is unavailable), so any of them may already have been applied." : nested.length === 0 ? "No ledgered nested tool calls were recorded for that execution." : [`Ledgered nested tool calls of that execution (they were not undone):`, ...nested.map((entry) => `- ${entry.key} ${entry.toolName} ${truncateCodePoints(entry.args, argsPreviewChars)}: ${nestedEntryState(entry)}`)].join("\n");
+	const text = [
+		`Script interrupted: an earlier execution of this ${call.name} call (${call.id}) started but never recorded a result. The script was not run again.`,
+		listing,
+		"Calls the ledger policy skips (by default read-only calls) are not listed. Verify the state these calls affect before repeating any work."
+	].join("\n\n");
+	const structuredContent = { codemode: nested === void 0 ? {
+		ok: false,
+		interrupted: true,
+		interruptedCallsUnavailable: true
+	} : {
+		ok: false,
+		interrupted: true,
+		interruptedCalls: interruptedCalls(nested, nestedToolCallRecordLimit(limits.maxNestedCalls))
+	} };
+	return ToolResult.make({
+		toolCallId: call.id,
+		content: codeModeSegmentsContent(boundCodeModeSegments([{
+			type: "text",
+			text
+		}], maxChars)),
+		isError: true,
+		structuredContent
+	});
+};
+/**
+* The code mode tool: one registration (default name `codemode`, input `{ code }`) whose scripts
+* call the other code-mode-callable tools of the same `resolveTools` resolution. Nested calls run
+* through the resolved execute path with the same host context (input decoding, enablement,
+* registration wrappers), get ids `<toolCallId>/<seq>`, and are recorded on the result's
+* `nestedCalls`. The resolved description lists the callable tools (see
+* `renderCodeModeDescription`).
+*
+* Access is `write`: scripts can call any write tool the resolution exposes to code mode; each
+* nested call keeps its own access metadata and host wrappers.
+*
+* With a tool ledger (`resolveTools(..., { ledger })`) the code mode call itself is ledgered, so a
+* re-executed call never runs its script again: a completed call returns its stored result, an
+* in-flight one is awaited, and an abandoned one returns an interrupted result listing its
+* ledgered nested calls. Nested write calls are ledgered under `<toolCallId>/<seq>`.
+*/
+const makeCodeModeTool = (options) => {
+	const name = options.name ?? "codemode";
+	const limits = {
+		...defaultCodeModeLimits,
+		...options.limits
+	};
+	const inlineBudget = options.inlineBudget ?? 3e3;
+	const store = options.loadStore !== void 0;
+	return makeTool({
+		name,
+		description: renderCodeModeDescription({
+			tools: [],
+			inlineBudget,
+			store
+		}),
+		parameters: CodeModeParams,
+		access: "write",
+		nestedToolAccess: true,
+		describe: ({ tools }) => renderCodeModeDescription({
+			tools,
+			inlineBudget,
+			store
+		}),
+		abandonedResult: abandonedScriptResult(limits),
+		execute: ({ call, context, params, nested }) => nested === void 0 ? Effect.fail(new ToolError({
+			tool: name,
+			cause: "unavailable",
+			message: `${name} requires nested tool access; resolve it with resolveTools.`
+		})) : runScript({
+			options,
+			limits,
+			call,
+			context,
+			code: params.code,
+			nested
+		})
+	});
+};
+//#endregion
+export { codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeToolName, defaultCodeModeLimits, makeCodeModeTool };
+
+//# sourceMappingURL=tool.mjs.map

package/dist/tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.mjs","names":[],"sources":["../src/tool.ts"],"sourcesContent":["import {\n  Cause,\n  Clock,\n  Data,\n  Duration,\n  Effect,\n  Exit,\n  Fiber,\n  FiberSet,\n  Option,\n  Predicate,\n  Scope\n} from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { ToolError } from '@yolk-sdk/agent/loop'\nimport {\n  boundNestedToolCallArgs,\n  makeNestedToolCallRecorder,\n  nestedToolCallMaxErrorChars,\n  nestedToolCallRecordLimit,\n  nestedToolCallResultFields,\n  recordNestedToolCall,\n  truncateCodePoints,\n  contentPartText,\n  ToolCall,\n  ToolResult,\n  type AgentUsage,\n  type Content,\n  type NestedToolCallInput,\n  type NestedToolCallStatus\n} from '@yolk-sdk/agent/protocol'\nimport {\n  makeTool,\n  type NestedToolExecutor,\n  type ToolExecutionInput,\n  type ToolLedgerAbandonedInput,\n  type ToolLedgerEntry,\n  type ToolRegistration\n} from '@yolk-sdk/agent/tools'\nimport {\n  codeModeCatalog,\n  defaultCodeModeInlineBudget,\n  describeCodeModeTool,\n  findCodeModeTool,\n  renderCodeModeDescription,\n  type CodeModeCatalogTool\n} from './catalog.ts'\nimport type {\n  CodeModeExecutionResult,\n  CodeModeExecutor,\n  CodeModeExecutorGlobal,\n  CodeModeExecutorTool,\n  CodeModeStore\n} from './executor.ts'\nimport {\n  boundCodeModeSegments,\n  codeModeResultSegments,\n  codeModeSegmentsContent,\n  defaultCodeModeMaxImageBytes,\n  defaultCodeModeMaxImages\n} from './output.ts'\nimport { searchCodeModeTools } from './search.ts'\nimport type {\n  CodeModeInterruptedCall,\n  CodeModeInterruptedCalls,\n  CodeModeInterruptedCallStatus,\n  CodeModeStructuredContent\n} from './store.ts'\n\n/** Default name of the code mode tool. */\nexport const codeModeToolName = 'codemode'\n\n/** Host-owned limits of one script. */\nexport type CodeModeLimits = {\n  /** Overall deadline including nested calls. Default 120000 (clamped by `deadline`). */\n  readonly timeoutMs?: number\n  /** VM heap cap. Default 64 MiB. */\n  readonly memoryLimitBytes?: number\n  /** Nested tool calls per script; further calls reject with an Error. Default 256. The\n   * `nestedCalls` record keeps up to this many calls, at most `nestedToolCallMaxRecordedCalls`\n   * (4096) whatever the limit (argument byte budgets still apply).\n   */\n  readonly maxNestedCalls?: number\n  /** Model-visible result characters, cut head and tail with an omission marker. Default 40000. */\n  readonly maxOutputChars?: number\n  /** Images kept in the result, in order; later images are dropped with a note. Default 8. */\n  readonly maxImages?: number\n  /** Base64 characters of images kept in the result in total; an image that would exceed it is\n   * dropped with a note. Default 4 MiB.\n   */\n  readonly maxImageBytes?: number\n}\n\nexport const defaultCodeModeLimits = {\n  timeoutMs: 120_000,\n  memoryLimitBytes: 64 * 1024 * 1024,\n  maxNestedCalls: 256,\n  maxOutputChars: 40_000,\n  maxImages: defaultCodeModeMaxImages,\n  maxImageBytes: defaultCodeModeMaxImageBytes\n} as const satisfies Required<CodeModeLimits>\n\n/** Kept between a host deadline and the script deadline, for result handling. */\nexport const codeModeDeadlineMarginMs = 5_000\n\n/** A deadline never clamps a script below this timeout. */\nexport const codeModeMinimumTimeoutMs = 1_000\n\nexport type MakeCodeModeToolOptions<Context> = {\n  readonly executor: CodeModeExecutor\n  /** Default `codemode`. */\n  readonly name?: string\n  /** Estimated tokens (four characters each) for listing nested tools. Default 3000. */\n  readonly inlineBudget?: number\n  readonly limits?: CodeModeLimits\n  /**\n   * Epoch milliseconds by which the tool call must end, for example the remaining function budget\n   * of a Workflow step. The script timeout is clamped to it minus 5 s, but never below 1 s.\n   */\n  readonly deadline?: (context: Context) => number | undefined\n  /**\n   * The store scripts read with `load(key)`, usually rebuilt from the transcript with\n   * `codeModeStoreFromToolResults`. Without it every script starts with an empty store.\n   */\n  readonly loadStore?: (context: Context) => Effect.Effect<CodeModeStore, ToolError>\n  /**\n   * Runs before each nested call executes, with the nested call (id `<toolCallId>/<seq>`) and the\n   * host context. A failure rejects that call in the script with the message and records it as an\n   * `error` without executing it. Host decorators around the `ToolExecutor` (outside\n   * `ResolvedToolSet.execute`) never see nested calls: put per-call run-authority checks here or in\n   * registration-level wrappers.\n   */\n  readonly beforeNestedCall?: (input: {\n    readonly call: ToolCall\n    readonly context: Context\n  }) => Effect.Effect<void, string>\n  /**\n   * Runs after each nested call that `beforeNestedCall` admitted, with its outcome: `success` (a\n   * result without `isError`), `failure` (an error result or an unexpected failure), or\n   * `interrupted` (cancelled, for example still running when the script ended). `durationMs`\n   * covers the execution; `result` is present when the call produced one. Calls rejected by\n   * `beforeNestedCall` or the call limit never ran and are not reported. The script waits for the\n   * hook before it sees the call settle. A failing hook (a failure, a defect, or a synchronous\n   * throw) is logged and never changes the call's result.\n   */\n  readonly afterNestedCall?: (input: CodeModeAfterNestedCallInput<Context>) => Effect.Effect<void>\n}\n\n/** Outcome of a nested call for `afterNestedCall`. */\nexport type CodeModeNestedCallOutcome = 'success' | 'failure' | 'interrupted'\n\nexport type CodeModeAfterNestedCallInput<Context> = {\n  readonly call: ToolCall\n  readonly outcome: CodeModeNestedCallOutcome\n  readonly durationMs: number\n  readonly context: Context\n  readonly result?: ToolResult\n}\n\nconst CodeModeParams = Schema.Struct({\n  code: Schema.String.annotate({\n    description:\n      'Raw JavaScript: the body of an async function. Top-level await and return work. Not a function declaration and not a module.'\n  })\n})\n\ntype CodeModeParams = typeof CodeModeParams.Type\n\nclass CodeModeExecutorRejected extends Data.TaggedError('CodeModeExecutorRejected')<{\n  readonly message: string\n}> {}\n\nconst errorMessage = (error: unknown) =>\n  error instanceof Error ? error.message : Predicate.isString(error) ? error : 'unknown error'\n\nconst nestedText = (content: Content) =>\n  Predicate.isString(content)\n    ? content\n    : content\n        .map(contentPartText)\n        .filter(text => text.length > 0)\n        .join('\\n')\n\ntype NestedResolution =\n  | { readonly ok: true; readonly value: unknown }\n  | { readonly ok: false; readonly message: string }\n\n/** What a nested call resolves to: `structuredContent` for tools with an output schema (when\n * present), text content otherwise; error results reject with their text. A tool that declares an\n * output schema but returns no `structuredContent` resolves to its text: that is a tool bug, kept\n * readable rather than turned into a failure.\n */\nconst resolveNestedResult = (tool: CodeModeCatalogTool, result: ToolResult): NestedResolution => {\n  const text = nestedText(result.content)\n\n  if (result.isError === true) {\n    return { ok: false, message: text.length > 0 ? text : `Tool ${tool.name} failed.` }\n  }\n\n  return tool.structured && result.structuredContent !== undefined\n    ? { ok: true, value: result.structuredContent }\n    : { ok: true, value: text }\n}\n\ntype CallOutcome = {\n  status: NestedToolCallStatus\n  durationMs: number\n  error?: string\n  usage?: AgentUsage\n}\n\ntype CallRecord = {\n  readonly name: string\n  readonly args: unknown\n  readonly id: string\n  outcome?: CallOutcome\n}\n\nconst recordedOutcome = (exit: Exit.Exit<ToolResult>, durationMs: number): CallOutcome => {\n  if (Exit.isFailure(exit)) {\n    return Cause.hasInterruptsOnly(exit.cause)\n      ? { status: 'cancelled', durationMs }\n      : { status: 'error', durationMs, error: 'The tool call failed unexpectedly.' }\n  }\n\n  const result = exit.value\n\n  const outcome: CallOutcome =\n    result.isError === true\n      ? { status: 'error', durationMs, error: nestedText(result.content) }\n      : { status: 'ok', durationMs }\n\n  if (result.usage !== undefined) {\n    outcome.usage = result.usage\n  }\n\n  return outcome\n}\n\nconst hookOutcome = (exit: Exit.Exit<ToolResult>): CodeModeNestedCallOutcome =>\n  Exit.isSuccess(exit)\n    ? exit.value.isError === true\n      ? 'failure'\n      : 'success'\n    : Cause.hasInterruptsOnly(exit.cause)\n      ? 'interrupted'\n      : 'failure'\n\n/** What `describeNamespace(name)` resolves to. */\ntype CodeModeNamespaceDescription = {\n  readonly name: string\n  description?: string\n  readonly tools: ReadonlyArray<{ readonly name: string; readonly description: string }>\n}\n\nconst SearchOptions = Schema.Struct({\n  limit: Schema.optionalKey(Schema.Finite),\n  namespace: Schema.optionalKey(Schema.String)\n})\n\nconst decodeSearchOptions = Schema.decodeUnknownOption(SearchOptions)\n\n/** `searchTools`, `describeTool`, and `describeNamespace` over every nested tool. */\nconst discoveryGlobals = (\n  catalog: ReadonlyArray<CodeModeCatalogTool>\n): ReadonlyArray<CodeModeExecutorGlobal> => [\n  {\n    name: 'searchTools',\n    spread: true,\n    execute: args => {\n      const [query, options] = Array.isArray(args) ? args : []\n\n      return Promise.resolve(\n        searchCodeModeTools(\n          catalog,\n          Predicate.isString(query) ? query : '',\n          Option.getOrElse(decodeSearchOptions(options ?? {}), () => ({}))\n        )\n      )\n    }\n  },\n  {\n    name: 'describeTool',\n    execute: name => {\n      const tool = Predicate.isString(name) ? findCodeModeTool(catalog, name) : undefined\n\n      return Promise.resolve(tool === undefined ? undefined : describeCodeModeTool(tool))\n    }\n  },\n  {\n    name: 'describeNamespace',\n    execute: name => {\n      const tools = catalog.filter(tool => tool.namespace === name)\n\n      if (!Predicate.isString(name) || tools.length === 0) return Promise.resolve(undefined)\n\n      const description = tools.find(\n        tool => tool.namespaceDescription !== undefined\n      )?.namespaceDescription\n\n      const namespace: CodeModeNamespaceDescription = {\n        name,\n        tools: tools.map(tool => ({ name: tool.identifier, description: tool.description }))\n      }\n\n      if (description !== undefined) namespace.description = description\n\n      return Promise.resolve(namespace)\n    }\n  }\n]\n\nconst hasStoreWrites = (result: CodeModeExecutionResult) =>\n  result.storeWrites !== undefined &&\n  (Object.keys(result.storeWrites.set).length > 0 || result.storeWrites.delete.length > 0)\n\nconst timeoutFor = (limit: number, deadline: number | undefined, now: number) =>\n  deadline === undefined\n    ? limit\n    : Math.max(codeModeMinimumTimeoutMs, Math.min(limit, deadline - now - codeModeDeadlineMarginMs))\n\n/**\n * Waits at most `codeModeDeadlineMarginMs` for an effect (interrupting nested fibers) to finish; it\n * keeps running detached when a nested call does not respond to interruption in time.\n */\nconst boundedWait = (effect: Effect.Effect<void>) =>\n  Effect.forkDetach(effect).pipe(\n    Effect.flatMap(fiber =>\n      Fiber.await(fiber).pipe(\n        Effect.timeoutOption(Duration.millis(codeModeDeadlineMarginMs)),\n        Effect.interruptible\n      )\n    ),\n    Effect.asVoid\n  )\n\ntype RunInput<Context> = {\n  readonly options: MakeCodeModeToolOptions<Context>\n  readonly limits: Required<CodeModeLimits>\n  readonly call: ToolCall\n  readonly context: Context\n  readonly code: string\n  readonly nested: NestedToolExecutor\n}\n\nconst runScript = <Context>(input: RunInput<Context>): Effect.Effect<ToolResult, ToolError> =>\n  Effect.gen(function* () {\n    const { call, limits, nested, options } = input\n    const store = options.loadStore === undefined ? {} : yield* options.loadStore(input.context)\n    const startedAt = yield* Clock.currentTimeMillis\n    const timeoutMs = timeoutFor(limits.timeoutMs, options.deadline?.(input.context), startedAt)\n    const catalog = codeModeCatalog(nested.tools)\n\n    return yield* Effect.acquireUseRelease(\n      Scope.make(),\n      scope =>\n        Effect.gen(function* () {\n          // Nested calls run as fibers of this tool call (same services, interrupted with it).\n          const fibers = yield* FiberSet.make<ToolResult>().pipe(Scope.provide(scope))\n          const runFork = yield* FiberSet.runtime(fibers)<never>()\n          const records: Array<CallRecord> = []\n\n          const callTool =\n            (tool: CodeModeCatalogTool): CodeModeExecutorTool['execute'] =>\n            (args, { signal }) => {\n              if (signal.aborted) {\n                return Promise.reject(new Error(`${tool.callLabel} was cancelled.`))\n              }\n\n              if (records.length >= limits.maxNestedCalls) {\n                return Promise.reject(\n                  new Error(\n                    `${tool.callLabel}: Nested call limit reached: a script may make at most ${limits.maxNestedCalls} tool calls. Batch the work or return partial results.`\n                  )\n                )\n              }\n\n              const params = args === undefined ? {} : args\n\n              const record: CallRecord = {\n                id: `${call.id}/${records.length + 1}`,\n                name: tool.name,\n                args: params\n              }\n\n              records.push(record)\n\n              const nestedCall = ToolCall.make({ id: record.id, name: tool.name, params })\n              const afterNestedCall = options.afterNestedCall\n\n              const run =\n                afterNestedCall === undefined\n                  ? nested.execute(nestedCall)\n                  : Effect.gen(function* () {\n                      const started = yield* Clock.currentTimeMillis\n\n                      // Host observability never changes the call: a hook failure, defects and\n                      // synchronous throws included, is only logged.\n                      const afterNestedCallSafely = (\n                        hookInput: CodeModeAfterNestedCallInput<Context>\n                      ) =>\n                        Effect.suspend(() => afterNestedCall(hookInput)).pipe(\n                          Effect.exit,\n                          Effect.flatMap(hookExit =>\n                            Exit.isSuccess(hookExit)\n                              ? Effect.void\n                              : Effect.logWarning(\n                                  `Code mode afterNestedCall failed for ${nestedCall.id}; ignored: ${Cause.pretty(hookExit.cause)}`\n                                )\n                          )\n                        )\n\n                      return yield* nested.execute(nestedCall).pipe(\n                        Effect.onExit(exit =>\n                          Effect.flatMap(Clock.currentTimeMillis, finished =>\n                            afterNestedCallSafely(\n                              Exit.isSuccess(exit)\n                                ? {\n                                    call: nestedCall,\n                                    outcome: hookOutcome(exit),\n                                    durationMs: finished - started,\n                                    context: input.context,\n                                    result: exit.value\n                                  }\n                                : {\n                                    call: nestedCall,\n                                    outcome: hookOutcome(exit),\n                                    durationMs: finished - started,\n                                    context: input.context\n                                  }\n                            )\n                          )\n                        )\n                      )\n                    })\n\n              const admitted =\n                options.beforeNestedCall === undefined\n                  ? run\n                  : options.beforeNestedCall({ call: nestedCall, context: input.context }).pipe(\n                      Effect.matchEffect({\n                        onFailure: message =>\n                          Effect.succeed(\n                            ToolResult.make({\n                              toolCallId: nestedCall.id,\n                              content: message,\n                              isError: true\n                            })\n                          ),\n                        onSuccess: () => run\n                      })\n                    )\n\n              const execution = Effect.gen(function* () {\n                const started = yield* Clock.currentTimeMillis\n\n                return yield* admitted.pipe(\n                  Effect.onExit(exit =>\n                    Effect.map(Clock.currentTimeMillis, finished => {\n                      record.outcome = recordedOutcome(exit, finished - started)\n                    })\n                  )\n                )\n              })\n\n              return new Promise((resolve, reject) => {\n                runFork(execution, { signal }).addObserver(exit => {\n                  if (Exit.isFailure(exit)) {\n                    reject(\n                      new Error(\n                        Cause.hasInterruptsOnly(exit.cause)\n                          ? `${tool.callLabel} was cancelled.`\n                          : `${tool.callLabel} failed unexpectedly.`\n                      )\n                    )\n\n                    return\n                  }\n\n                  const resolution = resolveNestedResult(tool, exit.value)\n\n                  if (resolution.ok) {\n                    resolve(resolution.value)\n                  } else {\n                    // The script sees which call failed; the nested-call record keeps the raw text.\n                    reject(new Error(`${tool.callLabel}: ${resolution.message}`))\n                  }\n                })\n              })\n            }\n\n          const tools: ReadonlyArray<CodeModeExecutorTool> = catalog.map(tool => ({\n            name: tool.name,\n            description: tool.description,\n            inputSchema: tool.inputSchema,\n            outputSchema: tool.outputSchema,\n            callLabel: tool.callLabel,\n            execute: callTool(tool)\n          }))\n\n          const result = yield* Effect.tryPromise({\n            try: signal =>\n              options.executor.execute(input.code, {\n                tools,\n                globals: discoveryGlobals(catalog),\n                timeoutMs,\n                memoryLimitBytes: limits.memoryLimitBytes,\n                store,\n                signal\n              }),\n            catch: error => new CodeModeExecutorRejected({ message: errorMessage(error) })\n          }).pipe(\n            Effect.catch(error =>\n              Effect.succeed<CodeModeExecutionResult>({\n                ok: false,\n                error: {\n                  kind: 'sandbox',\n                  message: `The code mode executor failed: ${error.message}`\n                },\n                output: []\n              })\n            ),\n            // Backstop for executors that miss their own deadline: interrupting aborts the signal.\n            Effect.timeoutOption(Duration.millis(timeoutMs + codeModeDeadlineMarginMs)),\n            Effect.map(\n              Option.getOrElse((): CodeModeExecutionResult => ({\n                ok: false,\n                error: {\n                  kind: 'timeout',\n                  message: `Execution timed out after ${timeoutMs} ms (the executor did not stop in time)`\n                },\n                output: []\n              }))\n            )\n          )\n\n          // Calls still running when the script ended are cancelled and recorded as such.\n          yield* boundedWait(FiberSet.clear(fibers))\n\n          const finishedAt = yield* Clock.currentTimeMillis\n\n          const recorded = records.map((record): NestedToolCallInput => ({\n            id: record.id,\n            name: record.name,\n            args: record.args,\n            // A call interrupted before it started has no outcome.\n            ...(record.outcome ?? { status: 'cancelled' })\n          }))\n\n          const recorder = recorded.reduce(\n            recordNestedToolCall,\n            makeNestedToolCallRecorder({ maxCalls: limits.maxNestedCalls })\n          )\n\n          const { nestedCalls, usage } = nestedToolCallResultFields(recorder)\n\n          const content = codeModeSegmentsContent(\n            codeModeResultSegments({\n              result,\n              wallTimeMs: finishedAt - startedAt,\n              calls: recorded,\n              maxChars: limits.maxOutputChars,\n              maxImages: limits.maxImages,\n              maxImageBytes: limits.maxImageBytes\n            })\n          )\n\n          const structuredContent: CodeModeStructuredContent = {\n            codemode:\n              result.ok && result.storeWrites !== undefined && hasStoreWrites(result)\n                ? { ok: true, storeWrites: result.storeWrites }\n                : { ok: result.ok }\n          }\n\n          type ResultFields = {\n            toolCallId: string\n            content: Content\n            isError?: boolean\n            structuredContent: CodeModeStructuredContent\n            nestedCalls: typeof nestedCalls\n            usage?: AgentUsage\n          }\n\n          const fields: ResultFields = {\n            toolCallId: call.id,\n            content,\n            structuredContent,\n            nestedCalls\n          }\n\n          if (!result.ok) {\n            fields.isError = true\n          }\n\n          if (usage !== undefined) {\n            fields.usage = usage\n          }\n\n          return ToolResult.make(fields)\n        }),\n      (scope, exit) => boundedWait(Scope.close(scope, exit))\n    )\n  })\n\nconst argsPreviewChars = 200\n\nconst interruptedCallStatus = (entry: ToolLedgerEntry): CodeModeInterruptedCallStatus => {\n  const outcome = entry.outcome\n\n  if (outcome === undefined) return 'unknown'\n\n  if (Predicate.isTagged(outcome, 'Failed')) return 'failed'\n\n  return outcome.result.isError === true ? 'failed' : 'applied'\n}\n\nconst nestedEntryState = (entry: ToolLedgerEntry) => {\n  const outcome = entry.outcome\n\n  if (outcome === undefined) {\n    return 'unknown: it started but never recorded a result, so it may have been applied'\n  }\n\n  if (Predicate.isTagged(outcome, 'Failed'))\n    return `completed with an error: ${truncateCodePoints(outcome.error.message, nestedToolCallMaxErrorChars)}`\n\n  return outcome.result.isError === true ? 'completed with an error result' : 'applied'\n}\n\n/** The bounded, wire-safe `interruptedCalls` of an abandoned execution's nested ledger entries:\n * the `nestedCalls` record bounds (`maxCalls`, 8 KiB of arguments per call, 32 KiB in total).\n */\nconst interruptedCalls = (\n  nested: ReadonlyArray<ToolLedgerEntry>,\n  maxCalls: number\n): CodeModeInterruptedCalls => {\n  const counts = { applied: 0, failed: 0, unknown: 0 }\n  const calls: Array<CodeModeInterruptedCall> = []\n  let argsBytes = 0\n  let complete = true\n\n  for (const entry of nested) {\n    const status = interruptedCallStatus(entry)\n\n    counts[status]++\n\n    if (calls.length >= maxCalls) {\n      complete = false\n      continue\n    }\n\n    const { args, bytes, truncated } = boundNestedToolCallArgs(entry.args, argsBytes)\n\n    // `argsTruncated`: the ledger already cut the arguments when the call was claimed.\n    if (truncated || entry.argsTruncated) complete = false\n\n    argsBytes += bytes\n    calls.push({ key: entry.key, toolName: entry.toolName, args, status })\n  }\n\n  return { calls, complete, counts }\n}\n\n/**\n * The result of a code mode call whose earlier execution was abandoned (claimed, lease expired,\n * no result recorded). The script never runs again: the result lists that execution's ledgered\n * nested calls as applied, failed, or unknown, and says they were not undone. The text is bounded\n * by `maxOutputChars`; `structuredContent.codemode.interruptedCalls` carries the same entries for\n * hosts, bounded like `nestedCalls`. When the ledger cannot list them, the result stays\n * interrupted, says they may have been applied, and sets `interruptedCallsUnavailable` instead.\n */\nconst abandonedScriptResult =\n  (limits: Required<CodeModeLimits>) =>\n  ({ call, nested }: ToolLedgerAbandonedInput): ToolResult => {\n    const maxChars = limits.maxOutputChars\n\n    const listing =\n      nested === undefined\n        ? 'Its ledgered nested tool calls could not be listed (the tool ledger is unavailable), so any of them may already have been applied.'\n        : nested.length === 0\n          ? 'No ledgered nested tool calls were recorded for that execution.'\n          : [\n              `Ledgered nested tool calls of that execution (they were not undone):`,\n              ...nested.map(\n                entry =>\n                  `- ${entry.key} ${entry.toolName} ${truncateCodePoints(entry.args, argsPreviewChars)}: ${nestedEntryState(entry)}`\n              )\n            ].join('\\n')\n\n    const text = [\n      `Script interrupted: an earlier execution of this ${call.name} call (${call.id}) started but never recorded a result. The script was not run again.`,\n      listing,\n      'Calls the ledger policy skips (by default read-only calls) are not listed. Verify the state these calls affect before repeating any work.'\n    ].join('\\n\\n')\n\n    const structuredContent: CodeModeStructuredContent = {\n      codemode:\n        nested === undefined\n          ? { ok: false, interrupted: true, interruptedCallsUnavailable: true }\n          : {\n              ok: false,\n              interrupted: true,\n              interruptedCalls: interruptedCalls(\n                nested,\n                nestedToolCallRecordLimit(limits.maxNestedCalls)\n              )\n            }\n    }\n\n    return ToolResult.make({\n      toolCallId: call.id,\n      content: codeModeSegmentsContent(boundCodeModeSegments([{ type: 'text', text }], maxChars)),\n      isError: true,\n      structuredContent\n    })\n  }\n\n/**\n * The code mode tool: one registration (default name `codemode`, input `{ code }`) whose scripts\n * call the other code-mode-callable tools of the same `resolveTools` resolution. Nested calls run\n * through the resolved execute path with the same host context (input decoding, enablement,\n * registration wrappers), get ids `<toolCallId>/<seq>`, and are recorded on the result's\n * `nestedCalls`. The resolved description lists the callable tools (see\n * `renderCodeModeDescription`).\n *\n * Access is `write`: scripts can call any write tool the resolution exposes to code mode; each\n * nested call keeps its own access metadata and host wrappers.\n *\n * With a tool ledger (`resolveTools(..., { ledger })`) the code mode call itself is ledgered, so a\n * re-executed call never runs its script again: a completed call returns its stored result, an\n * in-flight one is awaited, and an abandoned one returns an interrupted result listing its\n * ledgered nested calls. Nested write calls are ledgered under `<toolCallId>/<seq>`.\n */\nexport const makeCodeModeTool = <Context>(\n  options: MakeCodeModeToolOptions<Context>\n): ToolRegistration<Context> => {\n  const name = options.name ?? codeModeToolName\n  const limits: Required<CodeModeLimits> = { ...defaultCodeModeLimits, ...options.limits }\n  const inlineBudget = options.inlineBudget ?? defaultCodeModeInlineBudget\n  const store = options.loadStore !== undefined\n\n  return makeTool<Context, typeof CodeModeParams>({\n    name,\n    description: renderCodeModeDescription({ tools: [], inlineBudget, store }),\n    parameters: CodeModeParams,\n    access: 'write',\n    nestedToolAccess: true,\n    describe: ({ tools }) => renderCodeModeDescription({ tools, inlineBudget, store }),\n    abandonedResult: abandonedScriptResult(limits),\n    execute: ({\n      call,\n      context,\n      params,\n      nested\n    }: ToolExecutionInput<Context> & { readonly params: CodeModeParams }) =>\n      nested === undefined\n        ? Effect.fail(\n            new ToolError({\n              tool: name,\n              cause: 'unavailable',\n              message: `${name} requires nested tool access; resolve it with resolveTools.`\n            })\n          )\n        : runScript({ options, limits, call, context, code: params.code, nested })\n  })\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@yolk-sdk/codemode",
+  "version": "0.1.0-canary.100",
+  "description": "Code mode for Yolk agents: one tool that runs model-written JavaScript calling the host's resolved tools, plus a Node executor on a confined QuickJS sandbox.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magoz/yolk-sdk.git",
+    "directory": "packages/codemode"
+  },
+  "bugs": {
+    "url": "https://github.com/magoz/yolk-sdk/issues"
+  },
+  "homepage": "https://github.com/magoz/yolk-sdk#readme",
+  "keywords": [
+    "codemode",
+    "agents",
+    "tools",
+    "sandbox",
+    "quickjs",
+    "effect"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.mts",
+      "import": "./dist/node.mjs",
+      "default": "./dist/node.mjs"
+    }
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "dist/**/*",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@earendil-works/pi-codemode": "1.0.0",
+    "effect": "4.0.0",
+    "@yolk-sdk/agent": "^0.1.0-canary.100"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:run": "vitest run --passWithNoTests"
+  }
+}