@yolk-sdk/codemode 0.1.0-canary.97 → 0.1.0-canary.99

package/README.md

@@ -55,8 +55,9 @@ const program = Effect.gen(function* () {
 - Scripts call tools as `await tools.<id>(args)`. Every nested call runs through the resolution's
   normal execute path (input decoding, enablement, registration wrappers, same host context), gets
   the id `<toolCallId>/<seq>`, and is recorded on the result's `nestedCalls` with status, duration,
-  truncated error, and usage. Nested results never reach the model; only the script output and
-  return value do.
+  truncated error, and usage. The record keeps up to `maxNestedCalls` calls, at most 4096
+  (`nestedToolCallMaxRecordedCalls`; argument byte budgets still apply), and per-status `counts`
+  over every call. Nested results never reach the model; only the script output and return value do.
 - A call resolves to `structuredContent` for tools with an output schema and to the text content
   otherwise; error results, `beforeNestedCall` failures, and calls past `maxNestedCalls` reject
   with an `Error` whose message is `tools.<id>: <text>`, or `tools["<name>"]: <text>` for a tool
@@ -93,20 +94,49 @@ const program = Effect.gen(function* () {
   `ToolResultMessage`s carry no tool name: pair each with its assistant tool call's name.
 - `beforeNestedCall({ call, context })` runs before each nested call; a failure rejects that call in
   the script with `<label>: <message>` and records it as `error` without executing it.
+- `afterNestedCall({ call, outcome, durationMs, context, result? })` runs after each admitted
+  nested call with `success`, `failure` (error result or unexpected failure), or `interrupted`
+  (cancelled, for example still running when the script ended). Calls rejected before running are
+  not reported. A failing hook (a failure, a defect, or a synchronous throw) is logged and never
+  changes the call's result.
 - A nested call that is interrupted rejects with `<label> was cancelled.`; a defect rejects with
   `<label> failed unexpectedly.` (the same label as above). If an executor misses its deadline, the tool returns a `timeout` failure
   `timeoutMs` + 5 s after the start and aborts it.
 
+## Re-execution and the tool ledger
+
+Hosts that re-execute steps (Vercel Workflow's queue is at-least-once) pass a durable ledger to
+`resolveTools(modules, context, { ledger: { store } })` (see `@yolk-sdk/agent/tools`). The
+`codemode` call is itself ledgered, so a re-executed call never runs its script again:
+
+- completed: the stored result is returned;
+- still running elsewhere: the call waits for it (up to `maxWaitMs`/`deadline`);
+- abandoned (the earlier execution crashed): an interrupted error result lists that script's
+  ledgered nested calls as applied, failed, or unknown (started, no recorded result), states that
+  they were not undone, and asks the model to verify. Hosts get the same entries in
+  `structuredContent.codemode` without calling the store again:
+  `{ ok: false, interrupted: true, interruptedCalls: { calls, complete, counts } }`, where each call
+  is `{ key, toolName, args, status: 'applied' | 'failed' | 'unknown' }` (`args` compact JSON cut
+  with a trailing `…`), bounded like `nestedCalls` (`maxNestedCalls` calls, 8 KiB of arguments per
+  call, 32 KiB in total; `complete: false` when cut, here or by the ledger), and `counts` covers
+  every entry. Types: `CodeModeInterruptedCalls`, `CodeModeInterruptedCall`,
+  `CodeModeInterruptedCallStatus`. When the ledger cannot list the nested calls, the result stays
+  interrupted, says they may already have been applied, and sets
+  `interruptedCallsUnavailable: true` instead of `interruptedCalls`.
+
+Nested write calls are ledgered under `<toolCallId>/<seq>` and receive a stable `idempotencyKey`.
+Calls the ledger policy skips (by default read-only calls) are not listed.
+
 ## Limits
 
-| Limit              | Default | Notes                                                     |
-| ------------------ | ------- | --------------------------------------------------------- |
-| `timeoutMs`        | 120000  | Clamped to `deadline(context)` minus 5 s, never below 1 s |
-| `memoryLimitBytes` | 64 MiB  | QuickJS heap cap                                          |
-| `maxNestedCalls`   | 256     | Further calls reject with an `Error`                      |
-| `maxOutputChars`   | 40000   | Head-and-tail cut with an omission marker                 |
-| `maxImages`        | 8       | Later images are dropped with a note                      |
-| `maxImageBytes`    | 4 MiB   | Base64 characters of images in total                      |
+| Limit              | Default | Notes                                                                    |
+| ------------------ | ------- | ------------------------------------------------------------------------ |
+| `timeoutMs`        | 120000  | Clamped to `deadline(context)` minus 5 s, never below 1 s                |
+| `memoryLimitBytes` | 64 MiB  | QuickJS heap cap                                                         |
+| `maxNestedCalls`   | 256     | Further calls reject; also sizes the `nestedCalls` record (at most 4096) |
+| `maxOutputChars`   | 40000   | Head-and-tail cut with an omission marker                                |
+| `maxImages`        | 8       | Later images are dropped with a note                                     |
+| `maxImageBytes`    | 4 MiB   | Base64 characters of images in total                                     |
 
 ## Classifier tool
 
@@ -130,7 +160,7 @@ permits. Nested-call records carry token usage; cost stays in the result's
 - Where the tool is advertised (voice sessions do not get it in v1), deadlines, and limits.
 - Next.js: `serverExternalPackages: ['@yolk-sdk/codemode', '@earendil-works/pi-codemode', 'quickjs-wasi']`.
 - Vercel Workflow: run the code mode call inside the tool-batch step (`'use step'`), never inside a
-  `'use workflow'` function.
+  `'use workflow'` function, and supply a durable tool ledger: steps are at-least-once.
 
 ## Boundaries
 

package/dist/index.d.mts

@@ -3,6 +3,6 @@ import { CodeModeCatalogTool, CodeModeDescriptionInput, CodeModeListing, CodeMod
 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 };
+import { CodeModeInterruptedCall, CodeModeInterruptedCallStatus, CodeModeInterruptedCalls, CodeModeStructuredContent, CodeModeToolResultEntry, codeModeStoreFromToolResults, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars } from "./store.mjs";
+import { CodeModeAfterNestedCallInput, CodeModeLimits, CodeModeNestedCallOutcome, MakeCodeModeToolOptions, codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeToolName, defaultCodeModeLimits, makeCodeModeTool } from "./tool.mjs";
+export { type ClassifierConcurrencyLimiter, ClassifierToolParams, type CodeModeAfterNestedCallInput, type CodeModeCallSummary, type CodeModeCatalogTool, type CodeModeDescriptionInput, type CodeModeError, type CodeModeErrorKind, type CodeModeExecuteOptions, type CodeModeExecutionResult, type CodeModeExecutor, type CodeModeExecutorGlobal, type CodeModeExecutorTool, type CodeModeInterruptedCall, type CodeModeInterruptedCallStatus, type CodeModeInterruptedCalls, type CodeModeJsonSchema, type CodeModeLimits, type CodeModeListing, type CodeModeNestedCallOutcome, 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/store.d.mts

@@ -7,7 +7,44 @@ import { CodeModeStore, CodeModeStoreWrites } from "./executor.mjs";
 type CodeModeStructuredContent = {
   readonly codemode: {
     readonly ok: boolean;
-    readonly storeWrites?: CodeModeStoreWrites;
+    readonly storeWrites?: CodeModeStoreWrites; /** Set on the result of a re-executed call whose earlier execution was abandoned. */
+    readonly interrupted?: true; /** With `interrupted`: the abandoned execution's ledgered nested calls. */
+    readonly interruptedCalls?: CodeModeInterruptedCalls;
+    /** With `interrupted`, instead of `interruptedCalls`: the nested calls could not be listed
+     * (the ledger's `list` failed), so any of them may have been applied.
+     */
+    readonly interruptedCallsUnavailable?: true;
+  };
+};
+/** What an abandoned execution's ledgered nested call is known to have done: `applied` (recorded
+ * a result), `failed` (recorded a `ToolError` or an `isError` result), or `unknown` (started, no
+ * recorded outcome, so it may have been applied).
+ */
+type CodeModeInterruptedCallStatus = 'applied' | 'failed' | 'unknown';
+/** One ledgered nested call of an abandoned execution. `key` is its ledger key
+ * (`<toolCallId>/<seq>`); `args` is compact JSON, cut with a trailing `…` (then no longer JSON).
+ */
+type CodeModeInterruptedCall = {
+  readonly key: string;
+  readonly toolName: string;
+  readonly args: string;
+  readonly status: CodeModeInterruptedCallStatus;
+};
+/**
+ * `structuredContent.codemode.interruptedCalls`: plain JSON, in sequence order, bounded like
+ * `nestedCalls` (at most `limits.maxNestedCalls` calls; arguments within 8 KiB per call and
+ * 32 KiB in total). `complete: false` means calls were dropped or arguments cut, here or already
+ * in the ledger entry (`ToolLedgerEntry.argsTruncated`); `counts` covers every ledgered nested
+ * call, dropped ones included. Calls the ledger policy skips (by default read-only calls) never
+ * appear.
+ */
+type CodeModeInterruptedCalls = {
+  readonly calls: ReadonlyArray<CodeModeInterruptedCall>;
+  readonly complete: boolean;
+  readonly counts: {
+    readonly applied: number;
+    readonly failed: number;
+    readonly unknown: number;
   };
 };
 /** Largest stored value: characters of JSON (256 KiB), as the pi engine counts them. */
@@ -36,5 +73,5 @@ declare const codeModeStoreFromToolResults: (entries: ReadonlyArray<CodeModeTool
   readonly toolName?: string;
 }) => CodeModeStore;
 //#endregion
-export { CodeModeStructuredContent, CodeModeToolResultEntry, codeModeStoreFromToolResults, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars };
+export { CodeModeInterruptedCall, CodeModeInterruptedCallStatus, CodeModeInterruptedCalls, CodeModeStructuredContent, CodeModeToolResultEntry, codeModeStoreFromToolResults, maxCodeModeStoreTotalChars, maxCodeModeStoreValueChars };
 //# sourceMappingURL=store.d.mts.map

package/dist/store.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.mts","names":[],"sources":["../src/store.ts"],"mappings":";;;;;AAQA;KAAY,yBAAA;EAAA,SACD,QAAA;IAAA,SACE,EAAA;IAAA,SACA,WAAA,GAAc,mBAAmB;EAAA;AAAA;;cAmBjC,0BAAA;AAnBiC;AAAA,cAsBjC,0BAAA;;KAGD,uBAAA;EAAA,SACD,QAAA;EAAA,SACA,MAAA;IAAA,SAAmB,iBAAA;EAAA;AAAA;;AALuB;AAGrD;;;;;;;;AAE+C;cAclC,4BAAA,GACX,OAAA,EAAS,aAAA,CAAc,uBAAA,GACvB,OAAA;EAAA,SAAoB,QAAA;AAAA,MACnB,aAAA"}
+{"version":3,"file":"store.d.mts","names":[],"sources":["../src/store.ts"],"mappings":";;;;;AAQA;KAAY,yBAAA;EAAA,SACD,QAAA;IAAA,SACE,EAAA;IAAA,SACA,WAAA,GAAc,mBAAA,EADd;IAAA,SAGA,WAAA,SAFc;IAAA,SAId,gBAAA,GAAmB,wBAAwB;IAA3C;;;IAAA,SAIA,2BAAA;EAAA;AAAA;;;;AAQ4B;KAA7B,6BAAA;;;;KAKA,uBAAA;EAAA,SACD,GAAA;EAAA,SACA,QAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA,EAAQ,6BAA6B;AAAA;AAAA;AAWhD;;;;;;;AAXgD,KAWpC,wBAAA;EAAA,SACD,KAAA,EAAO,aAAa,CAAC,uBAAA;EAAA,SACrB,QAAA;EAAA,SACA,MAAA;IAAA,SACE,OAAA;IAAA,SACA,MAAA;IAAA,SACA,OAAA;EAAA;AAAA;;cAmBA,0BAAA;AAAuC;AAAA,cAGvC,0BAAA;;KAGD,uBAAA;EAAA,SACD,QAAA;EAAA,SACA,MAAA;IAAA,SAAmB,iBAAA;EAAA;AAAA;;;;;;AAAiB;AAc/C;;;;;cAAa,4BAAA,GACX,OAAA,EAAS,aAAA,CAAc,uBAAA,GACvB,OAAA;EAAA,SAAoB,QAAA;AAAA,MACnB,aAAA"}

package/dist/store.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"store.mjs","names":[],"sources":["../src/store.ts"],"sourcesContent":["import { Option } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport type { CodeModeStore, CodeModeStoreWrites } from './executor.ts'\nimport { codeModeToolName } from './tool.ts'\n\n/** `structuredContent` of a code mode `ToolResult`. `storeWrites` is present only for successful\n * scripts that changed the store.\n */\nexport type CodeModeStructuredContent = {\n  readonly codemode: {\n    readonly ok: boolean\n    readonly storeWrites?: CodeModeStoreWrites\n  }\n}\n\nconst StoreWritesSchema = Schema.Struct({\n  set: Schema.Record(Schema.String, Schema.Json),\n  delete: Schema.Array(Schema.String)\n})\n\nconst CodeModeStructuredContentSchema = Schema.Struct({\n  codemode: Schema.Struct({\n    ok: Schema.Boolean,\n    storeWrites: Schema.optionalKey(StoreWritesSchema)\n  })\n})\n\nconst decodeStructuredContent = Schema.decodeUnknownOption(CodeModeStructuredContentSchema)\n\n/** Largest stored value: characters of JSON (256 KiB), as the pi engine counts them. */\nexport const maxCodeModeStoreValueChars = 256 * 1024\n\n/** Largest store: characters of keys plus JSON values (1 MiB), as the pi engine counts them. */\nexport const maxCodeModeStoreTotalChars = 1024 * 1024\n\n/** One prior tool result with the name of the tool that produced it. */\nexport type CodeModeToolResultEntry = {\n  readonly toolName: string\n  readonly result: { readonly structuredContent?: unknown }\n}\n\n/**\n * Rebuilds the code mode store from prior tool results, oldest first: applies the `storeWrites` of\n * each successful script of the code mode tool named `toolName` (default `codemode`) in order.\n * Results of other tools (even when their `structuredContent` looks like a code mode result),\n * failed scripts, and malformed contents are skipped. Transcript `ToolResultMessage`s carry no tool\n * name; pair each with the name of its assistant tool call.\n *\n * The rebuilt store keeps the engine bounds: a write whose JSON value exceeds 256 Ki characters, or\n * that would grow the store beyond 1 Mi characters (keys plus JSON values), is dropped and the key\n * keeps its previous value. Deletions always apply. Pass the value from `loadStore`.\n */\nexport const codeModeStoreFromToolResults = (\n  entries: ReadonlyArray<CodeModeToolResultEntry>,\n  options: { readonly toolName?: string } = {}\n): CodeModeStore => {\n  const toolName = options.toolName ?? codeModeToolName\n  const store = new Map<string, { readonly value: Schema.Json; readonly chars: number }>()\n  let total = 0\n\n  for (const entry of entries) {\n    if (entry.toolName !== toolName) continue\n\n    const content = decodeStructuredContent(entry.result.structuredContent)\n\n    if (Option.isNone(content) || !content.value.codemode.ok) continue\n\n    const writes = content.value.codemode.storeWrites\n\n    if (writes === undefined) continue\n\n    for (const key of writes.delete) {\n      total -= store.get(key)?.chars ?? 0\n      store.delete(key)\n    }\n\n    for (const [key, value] of Object.entries(writes.set)) {\n      const json = JSON.stringify(value)\n\n      if (json.length > maxCodeModeStoreValueChars) continue\n\n      const chars = key.length + json.length\n      const next = total - (store.get(key)?.chars ?? 0) + chars\n\n      if (next > maxCodeModeStoreTotalChars) continue\n\n      store.set(key, { value, chars })\n      total = next\n    }\n  }\n\n  return Object.fromEntries([...store].map(([key, stored]) => [key, stored.value]))\n}\n"],"mappings":";;;;AAeA,MAAM,oBAAoB,OAAO,OAAO;CACtC,KAAK,OAAO,OAAO,OAAO,QAAQ,OAAO,IAAI;CAC7C,QAAQ,OAAO,MAAM,OAAO,MAAM;AACpC,CAAC;AAED,MAAM,kCAAkC,OAAO,OAAO,EACpD,UAAU,OAAO,OAAO;CACtB,IAAI,OAAO;CACX,aAAa,OAAO,YAAY,iBAAiB;AACnD,CAAC,EACH,CAAC;AAED,MAAM,0BAA0B,OAAO,oBAAoB,+BAA+B;;AAG1F,MAAa,6BAA6B,MAAM;;AAGhD,MAAa,6BAA6B,OAAO;;;;;;;;;;;;AAmBjD,MAAa,gCACX,SACA,UAA0C,CAAC,MACzB;CAClB,MAAM,WAAW,QAAQ,YAAA;CACzB,MAAM,wBAAQ,IAAI,IAAqE;CACvF,IAAI,QAAQ;CAEZ,KAAK,MAAM,SAAS,SAAS;EAC3B,IAAI,MAAM,aAAa,UAAU;EAEjC,MAAM,UAAU,wBAAwB,MAAM,OAAO,iBAAiB;EAEtE,IAAI,OAAO,OAAO,OAAO,KAAK,CAAC,QAAQ,MAAM,SAAS,IAAI;EAE1D,MAAM,SAAS,QAAQ,MAAM,SAAS;EAEtC,IAAI,WAAW,KAAA,GAAW;EAE1B,KAAK,MAAM,OAAO,OAAO,QAAQ;GAC/B,SAAS,MAAM,IAAI,GAAG,GAAG,SAAS;GAClC,MAAM,OAAO,GAAG;EAClB;EAEA,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAAG,GAAG;GACrD,MAAM,OAAO,KAAK,UAAU,KAAK;GAEjC,IAAI,KAAK,SAAA,QAAqC;GAE9C,MAAM,QAAQ,IAAI,SAAS,KAAK;GAChC,MAAM,OAAO,SAAS,MAAM,IAAI,GAAG,GAAG,SAAS,KAAK;GAEpD,IAAI,OAAA,SAAmC;GAEvC,MAAM,IAAI,KAAK;IAAE;IAAO;GAAM,CAAC;GAC/B,QAAQ;EACV;CACF;CAEA,OAAO,OAAO,YAAY,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,KAAK,YAAY,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;AAClF"}
+{"version":3,"file":"store.mjs","names":[],"sources":["../src/store.ts"],"sourcesContent":["import { Option } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport type { CodeModeStore, CodeModeStoreWrites } from './executor.ts'\nimport { codeModeToolName } from './tool.ts'\n\n/** `structuredContent` of a code mode `ToolResult`. `storeWrites` is present only for successful\n * scripts that changed the store.\n */\nexport type CodeModeStructuredContent = {\n  readonly codemode: {\n    readonly ok: boolean\n    readonly storeWrites?: CodeModeStoreWrites\n    /** Set on the result of a re-executed call whose earlier execution was abandoned. */\n    readonly interrupted?: true\n    /** With `interrupted`: the abandoned execution's ledgered nested calls. */\n    readonly interruptedCalls?: CodeModeInterruptedCalls\n    /** With `interrupted`, instead of `interruptedCalls`: the nested calls could not be listed\n     * (the ledger's `list` failed), so any of them may have been applied.\n     */\n    readonly interruptedCallsUnavailable?: true\n  }\n}\n\n/** What an abandoned execution's ledgered nested call is known to have done: `applied` (recorded\n * a result), `failed` (recorded a `ToolError` or an `isError` result), or `unknown` (started, no\n * recorded outcome, so it may have been applied).\n */\nexport type CodeModeInterruptedCallStatus = 'applied' | 'failed' | 'unknown'\n\n/** One ledgered nested call of an abandoned execution. `key` is its ledger key\n * (`<toolCallId>/<seq>`); `args` is compact JSON, cut with a trailing `…` (then no longer JSON).\n */\nexport type CodeModeInterruptedCall = {\n  readonly key: string\n  readonly toolName: string\n  readonly args: string\n  readonly status: CodeModeInterruptedCallStatus\n}\n\n/**\n * `structuredContent.codemode.interruptedCalls`: plain JSON, in sequence order, bounded like\n * `nestedCalls` (at most `limits.maxNestedCalls` calls; arguments within 8 KiB per call and\n * 32 KiB in total). `complete: false` means calls were dropped or arguments cut, here or already\n * in the ledger entry (`ToolLedgerEntry.argsTruncated`); `counts` covers every ledgered nested\n * call, dropped ones included. Calls the ledger policy skips (by default read-only calls) never\n * appear.\n */\nexport type CodeModeInterruptedCalls = {\n  readonly calls: ReadonlyArray<CodeModeInterruptedCall>\n  readonly complete: boolean\n  readonly counts: {\n    readonly applied: number\n    readonly failed: number\n    readonly unknown: number\n  }\n}\n\nconst StoreWritesSchema = Schema.Struct({\n  set: Schema.Record(Schema.String, Schema.Json),\n  delete: Schema.Array(Schema.String)\n})\n\nconst CodeModeStructuredContentSchema = Schema.Struct({\n  codemode: Schema.Struct({\n    ok: Schema.Boolean,\n    storeWrites: Schema.optionalKey(StoreWritesSchema)\n  })\n})\n\nconst decodeStructuredContent = Schema.decodeUnknownOption(CodeModeStructuredContentSchema)\n\n/** Largest stored value: characters of JSON (256 KiB), as the pi engine counts them. */\nexport const maxCodeModeStoreValueChars = 256 * 1024\n\n/** Largest store: characters of keys plus JSON values (1 MiB), as the pi engine counts them. */\nexport const maxCodeModeStoreTotalChars = 1024 * 1024\n\n/** One prior tool result with the name of the tool that produced it. */\nexport type CodeModeToolResultEntry = {\n  readonly toolName: string\n  readonly result: { readonly structuredContent?: unknown }\n}\n\n/**\n * Rebuilds the code mode store from prior tool results, oldest first: applies the `storeWrites` of\n * each successful script of the code mode tool named `toolName` (default `codemode`) in order.\n * Results of other tools (even when their `structuredContent` looks like a code mode result),\n * failed scripts, and malformed contents are skipped. Transcript `ToolResultMessage`s carry no tool\n * name; pair each with the name of its assistant tool call.\n *\n * The rebuilt store keeps the engine bounds: a write whose JSON value exceeds 256 Ki characters, or\n * that would grow the store beyond 1 Mi characters (keys plus JSON values), is dropped and the key\n * keeps its previous value. Deletions always apply. Pass the value from `loadStore`.\n */\nexport const codeModeStoreFromToolResults = (\n  entries: ReadonlyArray<CodeModeToolResultEntry>,\n  options: { readonly toolName?: string } = {}\n): CodeModeStore => {\n  const toolName = options.toolName ?? codeModeToolName\n  const store = new Map<string, { readonly value: Schema.Json; readonly chars: number }>()\n  let total = 0\n\n  for (const entry of entries) {\n    if (entry.toolName !== toolName) continue\n\n    const content = decodeStructuredContent(entry.result.structuredContent)\n\n    if (Option.isNone(content) || !content.value.codemode.ok) continue\n\n    const writes = content.value.codemode.storeWrites\n\n    if (writes === undefined) continue\n\n    for (const key of writes.delete) {\n      total -= store.get(key)?.chars ?? 0\n      store.delete(key)\n    }\n\n    for (const [key, value] of Object.entries(writes.set)) {\n      const json = JSON.stringify(value)\n\n      if (json.length > maxCodeModeStoreValueChars) continue\n\n      const chars = key.length + json.length\n      const next = total - (store.get(key)?.chars ?? 0) + chars\n\n      if (next > maxCodeModeStoreTotalChars) continue\n\n      store.set(key, { value, chars })\n      total = next\n    }\n  }\n\n  return Object.fromEntries([...store].map(([key, stored]) => [key, stored.value]))\n}\n"],"mappings":";;;;AAyDA,MAAM,oBAAoB,OAAO,OAAO;CACtC,KAAK,OAAO,OAAO,OAAO,QAAQ,OAAO,IAAI;CAC7C,QAAQ,OAAO,MAAM,OAAO,MAAM;AACpC,CAAC;AAED,MAAM,kCAAkC,OAAO,OAAO,EACpD,UAAU,OAAO,OAAO;CACtB,IAAI,OAAO;CACX,aAAa,OAAO,YAAY,iBAAiB;AACnD,CAAC,EACH,CAAC;AAED,MAAM,0BAA0B,OAAO,oBAAoB,+BAA+B;;AAG1F,MAAa,6BAA6B,MAAM;;AAGhD,MAAa,6BAA6B,OAAO;;;;;;;;;;;;AAmBjD,MAAa,gCACX,SACA,UAA0C,CAAC,MACzB;CAClB,MAAM,WAAW,QAAQ,YAAA;CACzB,MAAM,wBAAQ,IAAI,IAAqE;CACvF,IAAI,QAAQ;CAEZ,KAAK,MAAM,SAAS,SAAS;EAC3B,IAAI,MAAM,aAAa,UAAU;EAEjC,MAAM,UAAU,wBAAwB,MAAM,OAAO,iBAAiB;EAEtE,IAAI,OAAO,OAAO,OAAO,KAAK,CAAC,QAAQ,MAAM,SAAS,IAAI;EAE1D,MAAM,SAAS,QAAQ,MAAM,SAAS;EAEtC,IAAI,WAAW,KAAA,GAAW;EAE1B,KAAK,MAAM,OAAO,OAAO,QAAQ;GAC/B,SAAS,MAAM,IAAI,GAAG,GAAG,SAAS;GAClC,MAAM,OAAO,GAAG;EAClB;EAEA,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAAG,GAAG;GACrD,MAAM,OAAO,KAAK,UAAU,KAAK;GAEjC,IAAI,KAAK,SAAA,QAAqC;GAE9C,MAAM,QAAQ,IAAI,SAAS,KAAK;GAChC,MAAM,OAAO,SAAS,MAAM,IAAI,GAAG,GAAG,SAAS,KAAK;GAEpD,IAAI,OAAA,SAAmC;GAEvC,MAAM,IAAI,KAAK;IAAE;IAAO;GAAM,CAAC;GAC/B,QAAQ;EACV;CACF;CAEA,OAAO,OAAO,YAAY,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,KAAK,YAAY,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;AAClF"}

package/dist/tool.d.mts

@@ -1,6 +1,6 @@
 import { CodeModeExecutor, CodeModeStore } from "./executor.mjs";
 import { Effect } from "effect";
-import { ToolCall } from "@yolk-sdk/agent/protocol";
+import { ToolCall, ToolResult } from "@yolk-sdk/agent/protocol";
 import { ToolRegistration } from "@yolk-sdk/agent/tools";
 import { ToolError } from "@yolk-sdk/agent/loop";
 
@@ -10,7 +10,11 @@ declare const codeModeToolName = "codemode";
 /** Host-owned limits of one script. */
 type CodeModeLimits = {
   /** Overall deadline including nested calls. Default 120000 (clamped by `deadline`). */readonly timeoutMs?: number; /** VM heap cap. Default 64 MiB. */
-  readonly memoryLimitBytes?: number; /** Nested tool calls per script; further calls reject with an Error. Default 256. */
+  readonly memoryLimitBytes?: number;
+  /** Nested tool calls per script; further calls reject with an Error. Default 256. The
+   * `nestedCalls` record keeps up to this many calls, at most `nestedToolCallMaxRecordedCalls`
+   * (4096) whatever the limit (argument byte budgets still apply).
+   */
   readonly maxNestedCalls?: number; /** Model-visible result characters, cut head and tail with an omission marker. Default 40000. */
   readonly maxOutputChars?: number; /** Images kept in the result, in order; later images are dropped with a note. Default 8. */
   readonly maxImages?: number;
@@ -57,6 +61,25 @@ type MakeCodeModeToolOptions<Context> = {
     readonly call: ToolCall;
     readonly context: Context;
   }) => Effect.Effect<void, string>;
+  /**
+   * Runs after each nested call that `beforeNestedCall` admitted, with its outcome: `success` (a
+   * result without `isError`), `failure` (an error result or an unexpected failure), or
+   * `interrupted` (cancelled, for example still running when the script ended). `durationMs`
+   * covers the execution; `result` is present when the call produced one. Calls rejected by
+   * `beforeNestedCall` or the call limit never ran and are not reported. The script waits for the
+   * hook before it sees the call settle. A failing hook (a failure, a defect, or a synchronous
+   * throw) is logged and never changes the call's result.
+   */
+  readonly afterNestedCall?: (input: CodeModeAfterNestedCallInput<Context>) => Effect.Effect<void>;
+};
+/** Outcome of a nested call for `afterNestedCall`. */
+type CodeModeNestedCallOutcome = 'success' | 'failure' | 'interrupted';
+type CodeModeAfterNestedCallInput<Context> = {
+  readonly call: ToolCall;
+  readonly outcome: CodeModeNestedCallOutcome;
+  readonly durationMs: number;
+  readonly context: Context;
+  readonly result?: ToolResult;
 };
 /**
  * The code mode tool: one registration (default name `codemode`, input `{ code }`) whose scripts
@@ -68,8 +91,13 @@ type MakeCodeModeToolOptions<Context> = {
  *
  * 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>`.
  */
 declare const makeCodeModeTool: <Context>(options: MakeCodeModeToolOptions<Context>) => ToolRegistration<Context>;
 //#endregion
-export { CodeModeLimits, MakeCodeModeToolOptions, codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeToolName, defaultCodeModeLimits, makeCodeModeTool };
+export { CodeModeAfterNestedCallInput, CodeModeLimits, CodeModeNestedCallOutcome, MakeCodeModeToolOptions, codeModeDeadlineMarginMs, codeModeMinimumTimeoutMs, codeModeToolName, defaultCodeModeLimits, makeCodeModeTool };
 //# sourceMappingURL=tool.d.mts.map

package/dist/tool.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.mts","names":[],"sources":["../src/tool.ts"],"mappings":";;;;;;;;cA0Da,gBAAA;AAAb;AAAA,KAGY,cAAA;kGAED,SAAA,WALkB;EAAA,SAOlB,gBAAA,WAJe;EAAA,SAMf,cAAA,WANe;EAAA,SAQf,cAAA,WAJA;EAAA,SAMA,SAAA;EAFA;;;EAAA,SAMA,aAAA;AAAA;AAAA,cAGE,qBAAA;EAAA;;;;;;;;cAUA,wBAAA;;cAGA,wBAAA;AAAA,KAED,uBAAA;EAAA,SACD,QAAA,EAAU,gBAAA;WAEV,IAAA,WAR0B;EAAA,SAU1B,YAAA;EAAA,SACA,MAAA,GAAS,cAAA;;;AARiB;AAErC;WAWW,QAAA,IAAY,OAAA,EAAS,OAAA;EAXG;;;;EAAA,SAgBxB,SAAA,IAAa,OAAA,EAAS,OAAA,KAAY,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,SAAA;EAAf;;;;;;;EAAA,SAQhD,gBAAA,IAAoB,KAAA;IAAA,SAClB,IAAA,EAAM,QAAA;IAAA,SACN,OAAA,EAAS,OAAA;EAAA,MACd,MAAA,CAAO,MAAA;AAAA;;;;;;;;;;;;cA+YF,gBAAA,YACX,OAAA,EAAS,uBAAA,CAAwB,OAAA,MAChC,gBAAA,CAAiB,OAAA"}
+{"version":3,"file":"tool.d.mts","names":[],"sources":["../src/tool.ts"],"mappings":";;;;;;;;cAsEa,gBAAA;AAAb;AAAA,KAGY,cAAA;kGAED,SAAA,WALkB;EAAA,SAOlB,gBAAA;EAJe;;;;EAAA,SASf,cAAA;EAAA,SAEA,cAAA,WAEA;EAAA,SAAA,SAAA;EAIa;AAAA;AAGxB;EAHwB,SAAb,aAAA;AAAA;AAAA,cAGE,qBAAA;EAAA;;;;;;;;cAUA,wBAAA;;cAGA,wBAAA;AAAA,KAED,uBAAA;EAAA,SACD,QAAA,EAAU,gBAAA,EAHR;EAAA,SAKF,IAAA;WAEA,YAAA;EAAA,SACA,MAAA,GAAS,cAAA;EANR;;;;EAAA,SAWD,QAAA,IAAY,OAAA,EAAS,OAAA;EAAA;;;;EAAA,SAKrB,SAAA,IAAa,OAAA,EAAS,OAAA,KAAY,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,SAAA;EASvD;;;;;;;EAAA,SADR,gBAAA,IAAoB,KAAA;IAAA,SAClB,IAAA,EAAM,QAAA;IAAA,SACN,OAAA,EAAS,OAAA;EAAA,MACd,MAAA,CAAO,MAAA;EAxBJ;;;;;;;;;EAAA,SAkCA,eAAA,IAAmB,KAAA,EAAO,4BAAA,CAA6B,OAAA,MAAa,MAAA,CAAO,MAAA;AAAA;;KAI1E,yBAAA;AAAA,KAEA,4BAAA;EAAA,SACD,IAAA,EAAM,QAAA;EAAA,SACN,OAAA,EAAS,yBAAA;EAAA,SACT,UAAA;EAAA,SACA,OAAA,EAAS,OAAA;EAAA,SACT,MAAA,GAAS,UAAA;AAAA;;;;;;;;;;AAXwE;AAI5F;;;;AAAqC;AAErC;cAskBa,gBAAA,YACX,OAAA,EAAS,uBAAA,CAAwB,OAAA,MAChC,gBAAA,CAAiB,OAAA"}

package/dist/tool.mjs

@@ -1,8 +1,8 @@
 import { codeModeCatalog, describeCodeModeTool, findCodeModeTool, renderCodeModeDescription } from "./catalog.mjs";
 import { searchCodeModeTools } from "./search.mjs";
-import { codeModeResultSegments, codeModeSegmentsContent, defaultCodeModeMaxImageBytes } from "./output.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, contentPartText, emptyNestedToolCallRecorder, nestedToolCallResultFields, recordNestedToolCall } from "@yolk-sdk/agent/protocol";
+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";
@@ -65,6 +65,7 @@ const recordedOutcome = (exit, 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)
@@ -137,7 +138,24 @@ const runScript = (input) => Effect.gen(function* () {
 				name: tool.name,
 				params
 			});
-			const admitted = options.beforeNestedCall === void 0 ? nested.execute(nestedCall) : options.beforeNestedCall({
+			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({
@@ -146,7 +164,7 @@ const runScript = (input) => Effect.gen(function* () {
 					content: message,
 					isError: true
 				})),
-				onSuccess: () => nested.execute(nestedCall)
+				onSuccess: () => run
 			}));
 			const execution = Effect.gen(function* () {
 				const started = yield* Clock.currentTimeMillis;
@@ -207,7 +225,7 @@ const runScript = (input) => Effect.gen(function* () {
 			args: record.args,
 			...record.outcome ?? { status: "cancelled" }
 		}));
-		const { nestedCalls, usage } = nestedToolCallResultFields(recorded.reduce(recordNestedToolCall, emptyNestedToolCallRecorder));
+		const { nestedCalls, usage } = nestedToolCallResultFields(recorded.reduce(recordNestedToolCall, makeNestedToolCallRecorder({ maxCalls: limits.maxNestedCalls })));
 		const content = codeModeSegmentsContent(codeModeResultSegments({
 			result,
 			wallTimeMs: finishedAt - startedAt,
@@ -231,6 +249,89 @@ const runScript = (input) => Effect.gen(function* () {
 		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
@@ -241,6 +342,11 @@ const runScript = (input) => Effect.gen(function* () {
 *
 * 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";
@@ -265,6 +371,7 @@ const makeCodeModeTool = (options) => {
 			inlineBudget,
 			store
 		}),
+		abandonedResult: abandonedScriptResult(limits),
 		execute: ({ call, context, params, nested }) => nested === void 0 ? Effect.fail(new ToolError({
 			tool: name,
 			cause: "unavailable",

package/dist/tool.mjs.map

@@ -1 +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  emptyNestedToolCallRecorder,\n  nestedToolCallResultFields,\n  recordNestedToolCall,\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 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  codeModeResultSegments,\n  codeModeSegmentsContent,\n  defaultCodeModeMaxImageBytes,\n  defaultCodeModeMaxImages\n} from './output.ts'\nimport { searchCodeModeTools } from './search.ts'\nimport type { CodeModeStructuredContent } 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. */\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\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\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\n              const admitted =\n                options.beforeNestedCall === undefined\n                  ? nested.execute(nestedCall)\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: () => nested.execute(nestedCall)\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(recordNestedToolCall, emptyNestedToolCallRecorder)\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\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 */\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    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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"}
+{"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

@@ -1,6 +1,6 @@
 {
   "name": "@yolk-sdk/codemode",
-  "version": "0.1.0-canary.97",
+  "version": "0.1.0-canary.99",
   "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",
@@ -52,7 +52,7 @@
   "dependencies": {
     "@earendil-works/pi-codemode": "1.0.0",
     "effect": "4.0.0",
-    "@yolk-sdk/agent": "^0.1.0-canary.97"
+    "@yolk-sdk/agent": "^0.1.0-canary.99"
   },
   "scripts": {
     "build": "tsdown",

package/src/index.ts

@@ -51,7 +51,13 @@ export {
   maxCodeModeStoreValueChars
 } from './store.ts'
 
-export type { CodeModeStructuredContent, CodeModeToolResultEntry } from './store.ts'
+export type {
+  CodeModeInterruptedCall,
+  CodeModeInterruptedCalls,
+  CodeModeInterruptedCallStatus,
+  CodeModeStructuredContent,
+  CodeModeToolResultEntry
+} from './store.ts'
 
 export {
   codeModeDeadlineMarginMs,
@@ -61,7 +67,12 @@ export {
   makeCodeModeTool
 } from './tool.ts'
 
-export type { CodeModeLimits, MakeCodeModeToolOptions } from './tool.ts'
+export type {
+  CodeModeAfterNestedCallInput,
+  CodeModeLimits,
+  CodeModeNestedCallOutcome,
+  MakeCodeModeToolOptions
+} from './tool.ts'
 
 export {
   ClassifierToolParams,

package/src/store.ts

@@ -10,6 +10,48 @@ export type CodeModeStructuredContent = {
   readonly codemode: {
     readonly ok: boolean
     readonly storeWrites?: CodeModeStoreWrites
+    /** Set on the result of a re-executed call whose earlier execution was abandoned. */
+    readonly interrupted?: true
+    /** With `interrupted`: the abandoned execution's ledgered nested calls. */
+    readonly interruptedCalls?: CodeModeInterruptedCalls
+    /** With `interrupted`, instead of `interruptedCalls`: the nested calls could not be listed
+     * (the ledger's `list` failed), so any of them may have been applied.
+     */
+    readonly interruptedCallsUnavailable?: true
+  }
+}
+
+/** What an abandoned execution's ledgered nested call is known to have done: `applied` (recorded
+ * a result), `failed` (recorded a `ToolError` or an `isError` result), or `unknown` (started, no
+ * recorded outcome, so it may have been applied).
+ */
+export type CodeModeInterruptedCallStatus = 'applied' | 'failed' | 'unknown'
+
+/** One ledgered nested call of an abandoned execution. `key` is its ledger key
+ * (`<toolCallId>/<seq>`); `args` is compact JSON, cut with a trailing `…` (then no longer JSON).
+ */
+export type CodeModeInterruptedCall = {
+  readonly key: string
+  readonly toolName: string
+  readonly args: string
+  readonly status: CodeModeInterruptedCallStatus
+}
+
+/**
+ * `structuredContent.codemode.interruptedCalls`: plain JSON, in sequence order, bounded like
+ * `nestedCalls` (at most `limits.maxNestedCalls` calls; arguments within 8 KiB per call and
+ * 32 KiB in total). `complete: false` means calls were dropped or arguments cut, here or already
+ * in the ledger entry (`ToolLedgerEntry.argsTruncated`); `counts` covers every ledgered nested
+ * call, dropped ones included. Calls the ledger policy skips (by default read-only calls) never
+ * appear.
+ */
+export type CodeModeInterruptedCalls = {
+  readonly calls: ReadonlyArray<CodeModeInterruptedCall>
+  readonly complete: boolean
+  readonly counts: {
+    readonly applied: number
+    readonly failed: number
+    readonly unknown: number
   }
 }
 

package/src/tool.ts

@@ -14,9 +14,13 @@ import {
 import * as Schema from 'effect/Schema'
 import { ToolError } from '@yolk-sdk/agent/loop'
 import {
-  emptyNestedToolCallRecorder,
+  boundNestedToolCallArgs,
+  makeNestedToolCallRecorder,
+  nestedToolCallMaxErrorChars,
+  nestedToolCallRecordLimit,
   nestedToolCallResultFields,
   recordNestedToolCall,
+  truncateCodePoints,
   contentPartText,
   ToolCall,
   ToolResult,
@@ -29,6 +33,8 @@ import {
   makeTool,
   type NestedToolExecutor,
   type ToolExecutionInput,
+  type ToolLedgerAbandonedInput,
+  type ToolLedgerEntry,
   type ToolRegistration
 } from '@yolk-sdk/agent/tools'
 import {
@@ -47,13 +53,19 @@ import type {
   CodeModeStore
 } from './executor.ts'
 import {
+  boundCodeModeSegments,
   codeModeResultSegments,
   codeModeSegmentsContent,
   defaultCodeModeMaxImageBytes,
   defaultCodeModeMaxImages
 } from './output.ts'
 import { searchCodeModeTools } from './search.ts'
-import type { CodeModeStructuredContent } from './store.ts'
+import type {
+  CodeModeInterruptedCall,
+  CodeModeInterruptedCalls,
+  CodeModeInterruptedCallStatus,
+  CodeModeStructuredContent
+} from './store.ts'
 
 /** Default name of the code mode tool. */
 export const codeModeToolName = 'codemode'
@@ -64,7 +76,10 @@ export type CodeModeLimits = {
   readonly timeoutMs?: number
   /** VM heap cap. Default 64 MiB. */
   readonly memoryLimitBytes?: number
-  /** Nested tool calls per script; further calls reject with an Error. Default 256. */
+  /** Nested tool calls per script; further calls reject with an Error. Default 256. The
+   * `nestedCalls` record keeps up to this many calls, at most `nestedToolCallMaxRecordedCalls`
+   * (4096) whatever the limit (argument byte budgets still apply).
+   */
   readonly maxNestedCalls?: number
   /** Model-visible result characters, cut head and tail with an omission marker. Default 40000. */
   readonly maxOutputChars?: number
@@ -119,6 +134,27 @@ export type MakeCodeModeToolOptions<Context> = {
     readonly call: ToolCall
     readonly context: Context
   }) => Effect.Effect<void, string>
+  /**
+   * Runs after each nested call that `beforeNestedCall` admitted, with its outcome: `success` (a
+   * result without `isError`), `failure` (an error result or an unexpected failure), or
+   * `interrupted` (cancelled, for example still running when the script ended). `durationMs`
+   * covers the execution; `result` is present when the call produced one. Calls rejected by
+   * `beforeNestedCall` or the call limit never ran and are not reported. The script waits for the
+   * hook before it sees the call settle. A failing hook (a failure, a defect, or a synchronous
+   * throw) is logged and never changes the call's result.
+   */
+  readonly afterNestedCall?: (input: CodeModeAfterNestedCallInput<Context>) => Effect.Effect<void>
+}
+
+/** Outcome of a nested call for `afterNestedCall`. */
+export type CodeModeNestedCallOutcome = 'success' | 'failure' | 'interrupted'
+
+export type CodeModeAfterNestedCallInput<Context> = {
+  readonly call: ToolCall
+  readonly outcome: CodeModeNestedCallOutcome
+  readonly durationMs: number
+  readonly context: Context
+  readonly result?: ToolResult
 }
 
 const CodeModeParams = Schema.Struct({
@@ -201,6 +237,15 @@ const recordedOutcome = (exit: Exit.Exit<ToolResult>, durationMs: number): CallO
   return outcome
 }
 
+const hookOutcome = (exit: Exit.Exit<ToolResult>): CodeModeNestedCallOutcome =>
+  Exit.isSuccess(exit)
+    ? exit.value.isError === true
+      ? 'failure'
+      : 'success'
+    : Cause.hasInterruptsOnly(exit.cause)
+      ? 'interrupted'
+      : 'failure'
+
 /** What `describeNamespace(name)` resolves to. */
 type CodeModeNamespaceDescription = {
   readonly name: string
@@ -341,10 +386,57 @@ const runScript = <Context>(input: RunInput<Context>): Effect.Effect<ToolResult,
               records.push(record)
 
               const nestedCall = ToolCall.make({ id: record.id, name: tool.name, params })
+              const afterNestedCall = options.afterNestedCall
+
+              const run =
+                afterNestedCall === undefined
+                  ? nested.execute(nestedCall)
+                  : Effect.gen(function* () {
+                      const started = yield* Clock.currentTimeMillis
+
+                      // Host observability never changes the call: a hook failure, defects and
+                      // synchronous throws included, is only logged.
+                      const afterNestedCallSafely = (
+                        hookInput: CodeModeAfterNestedCallInput<Context>
+                      ) =>
+                        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 === undefined
-                  ? nested.execute(nestedCall)
+                  ? run
                   : options.beforeNestedCall({ call: nestedCall, context: input.context }).pipe(
                       Effect.matchEffect({
                         onFailure: message =>
@@ -355,7 +447,7 @@ const runScript = <Context>(input: RunInput<Context>): Effect.Effect<ToolResult,
                               isError: true
                             })
                           ),
-                        onSuccess: () => nested.execute(nestedCall)
+                        onSuccess: () => run
                       })
                     )
 
@@ -455,7 +547,11 @@ const runScript = <Context>(input: RunInput<Context>): Effect.Effect<ToolResult,
             ...(record.outcome ?? { status: 'cancelled' })
           }))
 
-          const recorder = recorded.reduce(recordNestedToolCall, emptyNestedToolCallRecorder)
+          const recorder = recorded.reduce(
+            recordNestedToolCall,
+            makeNestedToolCallRecorder({ maxCalls: limits.maxNestedCalls })
+          )
+
           const { nestedCalls, usage } = nestedToolCallResultFields(recorder)
 
           const content = codeModeSegmentsContent(
@@ -506,6 +602,119 @@ const runScript = <Context>(input: RunInput<Context>): Effect.Effect<ToolResult,
     )
   })
 
+const argsPreviewChars = 200
+
+const interruptedCallStatus = (entry: ToolLedgerEntry): CodeModeInterruptedCallStatus => {
+  const outcome = entry.outcome
+
+  if (outcome === undefined) return 'unknown'
+
+  if (Predicate.isTagged(outcome, 'Failed')) return 'failed'
+
+  return outcome.result.isError === true ? 'failed' : 'applied'
+}
+
+const nestedEntryState = (entry: ToolLedgerEntry) => {
+  const outcome = entry.outcome
+
+  if (outcome === undefined) {
+    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: ReadonlyArray<ToolLedgerEntry>,
+  maxCalls: number
+): CodeModeInterruptedCalls => {
+  const counts = { applied: 0, failed: 0, unknown: 0 }
+  const calls: Array<CodeModeInterruptedCall> = []
+  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)
+
+    // `argsTruncated`: the ledger already cut the arguments when the call was claimed.
+    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: Required<CodeModeLimits>) =>
+  ({ call, nested }: ToolLedgerAbandonedInput): ToolResult => {
+    const maxChars = limits.maxOutputChars
+
+    const listing =
+      nested === undefined
+        ? '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: CodeModeStructuredContent = {
+      codemode:
+        nested === undefined
+          ? { 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
@@ -516,6 +725,11 @@ const runScript = <Context>(input: RunInput<Context>): Effect.Effect<ToolResult,
  *
  * 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>`.
  */
 export const makeCodeModeTool = <Context>(
   options: MakeCodeModeToolOptions<Context>
@@ -532,6 +746,7 @@ export const makeCodeModeTool = <Context>(
     access: 'write',
     nestedToolAccess: true,
     describe: ({ tools }) => renderCodeModeDescription({ tools, inlineBudget, store }),
+    abandonedResult: abandonedScriptResult(limits),
     execute: ({
       call,
       context,