agency-lang 0.0.90 → 0.0.92

package/dist/lib/backends/agencyGenerator.js

@@ -793,13 +793,16 @@ export class AgencyGenerator {
         return assigned ? multiLine : this.indentStr(multiLine);
     }
     processAccessChainElement(node) {
+        const dot = node.optional ? "?." : ".";
         switch (node.kind) {
             case "property":
-                return `.${node.name}`;
-            case "index":
-                return `[${this.processNode(node.index).trim()}]`;
+                return `${dot}${node.name}`;
+            case "index": {
+                const inner = this.processNode(node.index).trim();
+                return node.optional ? `?.[${inner}]` : `[${inner}]`;
+            }
             case "methodCall":
-                return `.${this.generateFunctionCallExpression(node.functionCall, "valueAccess")}`;
+                return `${dot}${this.generateFunctionCallExpression(node.functionCall, "valueAccess")}`;
             default:
                 throw new Error(`Unknown access chain element kind: ${node.kind}`);
         }

package/dist/lib/backends/typescriptBuilder.js

@@ -661,10 +661,10 @@ export class TypeScriptBuilder {
         for (const element of node.chain) {
             switch (element.kind) {
                 case "property":
-                    result = ts.prop(result, element.name);
+                    result = ts.prop(result, element.name, { optional: element.optional });
                     break;
                 case "index":
-                    result = ts.index(result, this.processNode(element.index));
+                    result = ts.index(result, this.processNode(element.index), { optional: element.optional });
                     break;
                 case "methodCall": {
                     const callNode = this.generateFunctionCallExpression(element.functionCall, "valueAccess");
@@ -675,15 +675,14 @@ export class TypeScriptBuilder {
                         const args = isClassMethod
                             ? [...callNode.arguments, this.buildMethodCallConfig()]
                             : callNode.arguments;
-                        const callExpr = $(result)
-                            .prop(callNode.callee.name)
-                            .call(args)
-                            .done();
+                        const propNode = ts.prop(result, callNode.callee.name, { optional: element.optional });
+                        const callExpr = ts.call(propNode, args);
                         result = isClassMethod ? ts.await(callExpr) : callExpr;
                     }
                     else {
                         // Fallback for complex cases (e.g. await-wrapped)
-                        result = ts.raw(`${this.str(result)}.${this.str(callNode)}`);
+                        const dot = element.optional ? "?." : ".";
+                        result = ts.raw(`${this.str(result)}${dot}${this.str(callNode)}`);
                     }
                     break;
                 }
@@ -1140,6 +1139,7 @@ export class TypeScriptBuilder {
                 functionName: ts.str(functionName),
                 args: ts.obj(argsObj),
                 isBuiltin: ts.bool(false),
+                moduleId: ts.str(this.moduleId),
             }),
         ];
         // Param assignments to stack
@@ -1778,6 +1778,7 @@ export class TypeScriptBuilder {
         runPromptEntries.maxToolCallRounds = ts.num(this.agencyConfig.maxToolCallRounds || 10);
         runPromptEntries.interruptData = ts.raw("__state?.interruptData");
         runPromptEntries.removedTools = ts.self("__removedTools");
+        runPromptEntries.checkpointInfo = ts.raw("runner.getCheckpointInfo()");
         const runPromptCall = $(ts.id("runPrompt"))
             .call([ts.obj(runPromptEntries)])
             .done();

package/dist/lib/debugger/driver.js

@@ -59,20 +59,22 @@ export class DebuggerDriver {
     getCallbacks() {
         return {
             onFunctionStart: (data) => {
-                const isInSource = this.isInSourceMap(data.functionName);
+                const isAgency = data.moduleId?.endsWith(".agency");
                 this.debuggerState.enterCall();
                 this.ui.state.pushCallStackEntry({
                     functionName: data.functionName,
-                    moduleId: isInSource ? data.functionName : "(ts)",
+                    moduleId: isAgency ? data.moduleId : "(ts)",
                     line: 0,
                 });
-                if (!isInSource) {
+                if (!isAgency) {
                     this.ui.state.log(`[ts] ${data.functionName}()`);
                 }
+                this.ui.render();
             },
             onFunctionEnd: (data) => {
                 this.debuggerState.exitCall();
                 this.ui.state.removeWithFuncName(data.functionName);
+                this.ui.render();
             },
             onNodeStart: (data) => {
                 // gets triggered on every statement, as debugger resumes node execution.
@@ -80,10 +82,12 @@ export class DebuggerDriver {
             },
             onNodeEnd: (data) => {
                 this.ui.state.log(`<- node: ${data.nodeName}`);
+                this.ui.render();
             },
             onLLMCallStart: (data) => {
                 const model = typeof data.model === "string" ? data.model : "unknown";
                 this.ui.state.log(`Calling LLM: ${model}...`);
+                this.ui.render();
             },
             onLLMCallEnd: (data) => {
                 const tokens = data.usage
@@ -91,12 +95,15 @@ export class DebuggerDriver {
                     : "unknown tokens";
                 const time = `${round(data.timeTaken)}ms`;
                 this.ui.state.log(`LLM returned (${tokens}, ${time})`);
+                this.ui.render();
             },
             onToolCallStart: (data) => {
                 this.ui.state.log(`Tool call: ${data.toolName}()`);
+                this.ui.render();
             },
             onToolCallEnd: (data) => {
                 this.ui.state.log(`Tool done: ${data.toolName} (${round(data.timeTaken)}ms)`);
+                this.ui.render();
             },
         };
     }

package/dist/lib/debugger/ui.js

@@ -381,6 +381,7 @@ export class DebuggerUI {
         // Format messages
         const content = threadData.messages
             .map((m) => {
+            // if its not a string,call json.strinfigy
             const truncated = m.content.length > 200 ? m.content.slice(0, 197) + "..." : m.content;
             return `  ${this.bold(`[${this.fmt(m.role)}]`)} ${this.fmt(truncated)}`;
         })

package/dist/lib/ir/builders.d.ts

@@ -51,8 +51,12 @@ export declare const ts: {
         parenLeft?: boolean;
         parenRight?: boolean;
     }): TsBinOp;
-    prop(object: TsNode, property: string): TsPropertyAccess;
-    index(object: TsNode, property: TsNode): TsPropertyAccess;
+    prop(object: TsNode, property: string, opts?: {
+        optional?: boolean;
+    }): TsPropertyAccess;
+    index(object: TsNode, property: TsNode, opts?: {
+        optional?: boolean;
+    }): TsPropertyAccess;
     spread(expr: TsNode): TsSpread;
     id(name: string): TsIdentifier;
     str(value: string): TsStringLiteral;

package/dist/lib/ir/builders.js

@@ -166,11 +166,11 @@ export const ts = {
             parenRight: opts?.parenRight,
         };
     },
-    prop(object, property) {
-        return { kind: "propertyAccess", object, property, computed: false };
+    prop(object, property, opts) {
+        return { kind: "propertyAccess", object, property, computed: false, ...(opts?.optional && { optional: true }) };
     },
-    index(object, property) {
-        return { kind: "propertyAccess", object, property, computed: true };
+    index(object, property, opts) {
+        return { kind: "propertyAccess", object, property, computed: true, ...(opts?.optional && { optional: true }) };
     },
     spread(expr) {
         return { kind: "spread", expr };

package/dist/lib/ir/fluent.d.ts

@@ -9,7 +9,9 @@ export declare class TsChain {
     readonly node: TsNode;
     constructor(node: TsNode);
     /** Property access: .prop("foo") → ts.prop(this, "foo") */
-    prop(name: string): TsChain;
+    prop(name: string, opts?: {
+        optional?: boolean;
+    }): TsChain;
     map(fn: TsNode): TsChain;
     /** Computed index: .index(expr) → ts.index(this, expr) */
     index(expr: TsNode): TsChain;

package/dist/lib/ir/fluent.js

@@ -11,8 +11,8 @@ export class TsChain {
         this.node = node;
     }
     /** Property access: .prop("foo") → ts.prop(this, "foo") */
-    prop(name) {
-        return new TsChain(ts.prop(this.node, name));
+    prop(name, opts) {
+        return new TsChain(ts.prop(this.node, name, opts));
     }
     map(fn) {
         return new TsChain(ts.call(ts.prop(this.node, "map"), [fn]));

package/dist/lib/ir/prettyPrint.js

@@ -189,9 +189,11 @@ export function printTs(node, indent = 0) {
         case "propertyAccess": {
             const obj = printTs(node.object, indent);
             if (node.computed) {
-                return `${obj}[${printTs(node.property, indent)}]`;
+                const prefix = node.optional ? "?." : "";
+                return `${obj}${prefix}[${printTs(node.property, indent)}]`;
             }
-            return `${obj}.${node.property}`;
+            const dot = node.optional ? "?." : ".";
+            return `${obj}${dot}${node.property}`;
         }
         case "spread":
             return `...${printTs(node.expr, indent)}`;

package/dist/lib/ir/tsIR.d.ts

@@ -153,6 +153,7 @@ export interface TsPropertyAccess {
     object: TsNode;
     property: string | TsNode;
     computed: boolean;
+    optional?: boolean;
 }
 export interface TsSpread {
     kind: "spread";

package/dist/lib/parsers/access.test.js

@@ -340,6 +340,73 @@ describe("valueAccessParser", () => {
             }
         });
     });
+    describe("optional chaining", () => {
+        it('should parse "foo?.bar" with optional property access', () => {
+            const result = valueAccessParser("foo?.bar");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "foo" },
+                    chain: [{ kind: "property", name: "bar", optional: true }],
+                });
+            }
+        });
+        it('should parse "foo?.bar?.baz" with chained optional access', () => {
+            const result = valueAccessParser("foo?.bar?.baz");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "foo" },
+                    chain: [
+                        { kind: "property", name: "bar", optional: true },
+                        { kind: "property", name: "baz", optional: true },
+                    ],
+                });
+            }
+        });
+        it('should parse "foo?.bar.baz" mixing optional and regular access', () => {
+            const result = valueAccessParser("foo?.bar.baz");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "foo" },
+                    chain: [
+                        { kind: "property", name: "bar", optional: true },
+                        { kind: "property", name: "baz" },
+                    ],
+                });
+            }
+        });
+        it('should parse "arr?.[0]" with optional index access', () => {
+            const result = valueAccessParser("arr?.[0]");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "arr" },
+                    chain: [{ kind: "index", index: { type: "number", value: "0" }, optional: true }],
+                });
+            }
+        });
+        it('should parse "obj?.method()" with optional method call', () => {
+            const result = valueAccessParser("obj?.method()");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "obj" },
+                    chain: [{
+                            kind: "methodCall",
+                            functionCall: { type: "functionCall", functionName: "method", arguments: [] },
+                            optional: true,
+                        }],
+                });
+            }
+        });
+    });
     describe("failure cases", () => {
         it('should fail to parse ""', () => {
             expect(valueAccessParser("").success).toBe(false);

package/dist/lib/parsers/binop.test.js

@@ -524,6 +524,68 @@ describe("binOpParser", () => {
             }
         });
     });
+    // Nullish coalescing operator
+    describe("nullish coalescing operator", () => {
+        it('should parse "a ?? b"', () => {
+            const result = binOpParser("a ?? b");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: { type: "variableName", value: "a" },
+                    right: { type: "variableName", value: "b" },
+                });
+            }
+        });
+        it('should parse "a ?? b ?? c" as left-associative', () => {
+            const result = binOpParser("a ?? b ?? c");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: {
+                        type: "binOpExpression",
+                        operator: "??",
+                        left: { type: "variableName", value: "a" },
+                        right: { type: "variableName", value: "b" },
+                    },
+                    right: { type: "variableName", value: "c" },
+                });
+            }
+        });
+        it('should parse "a ?? 42"', () => {
+            const result = binOpParser("a ?? 42");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: { type: "variableName", value: "a" },
+                    right: { type: "number", value: "42" },
+                });
+            }
+        });
+        it('should parse ?? with lower precedence than comparison', () => {
+            const result = binOpParser("a == b ?? c");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                // Should parse as (a == b) ?? c
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: {
+                        type: "binOpExpression",
+                        operator: "==",
+                        left: { type: "variableName", value: "a" },
+                        right: { type: "variableName", value: "b" },
+                    },
+                    right: { type: "variableName", value: "c" },
+                });
+            }
+        });
+    });
     // Failure cases
     describe("regex match operators", () => {
         const testCases = [

package/dist/lib/parsers/parsers.js

@@ -22,7 +22,7 @@ export const varNameChar = oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRST
 However, because every agency code gets rendered in a template that imports some standard functions,
 the line numbers would be off if we didn't account for the template lines.
 */
-const AGENCY_TEMPLATE_OFFSET = 2;
+const AGENCY_TEMPLATE_OFFSET = 3;
 /**
  * Wraps a parser to add a `loc` field from tarsec's withSpan.
  * Converts Span { start: Position, end: Position } to SourceLocation { line, col, start, end }.
@@ -409,27 +409,35 @@ export const functionCallParser = label("a function call", _functionCallParser);
 // =============================================================================
 // access.ts
 // =============================================================================
-// Parse a single chain element: .method(), .property, or [index]
+// Parse "?." or "." — returns true for optional, false for regular
+const dotParser = or(map(str("?."), () => true), map(char("."), () => false));
+// Parse a single chain element: .method(), ?.method(), .property, ?.property, [index], ?.[index]
 const dotMethodCallParser = (input) => {
-    // First try: . followed by functionCall (name + parens)
-    const dotResult = char(".")(input);
+    const dotResult = dotParser(input);
     if (!dotResult.success)
         return failure("expected dot", input);
-    const fcResult = _functionCallParser(dotResult.rest);
+    const optional = dotResult.result;
+    const afterDot = dotResult.rest;
+    // First try: functionCall (name + parens)
+    const fcResult = _functionCallParser(afterDot);
     if (fcResult.success) {
-        return success({ kind: "methodCall", functionCall: fcResult.result }, fcResult.rest);
+        return success({ kind: "methodCall", functionCall: fcResult.result, ...(optional && { optional: true }) }, fcResult.rest);
     }
-    // Second try: . followed by just a property name
-    const nameResult = variableNameParser(dotResult.rest);
+    // Second try: just a property name
+    const nameResult = variableNameParser(afterDot);
     if (nameResult.success) {
-        return success({ kind: "property", name: nameResult.result.value }, nameResult.rest);
+        return success({ kind: "property", name: nameResult.result.value, ...(optional && { optional: true }) }, nameResult.rest);
     }
     return failure("expected property name or method call after dot", input);
 };
+// Parse "?.[" or "[" — returns true for optional, false for regular
+const bracketParser = or(map(str("?.["), () => true), map(char("["), () => false));
 const indexChainParser = (input) => {
-    const parser = seqC(set("kind", "index"), char("["), optionalSpaces, capture(lazy(() => exprParser), "index"), optionalSpaces, char("]"));
+    const parser = seqC(capture(bracketParser, "optional"), optionalSpaces, capture(lazy(() => exprParser), "index"), optionalSpaces, char("]"));
     const result = parser(input);
-    return result;
+    if (!result.success)
+        return result;
+    return success({ kind: "index", index: result.result.index, ...(result.result.optional && { optional: true }) }, result.rest);
 };
 const chainElementParser = or(dotMethodCallParser, indexChainParser);
 export const _valueAccessParser = (input) => {
@@ -607,8 +615,9 @@ export const exprParser = label("an expression", buildExpressionParser(atom, [
     [
         { op: wsOp("&&"), assoc: "left", apply: makeBinOp("&&") },
     ],
-    // Precedence 1: logical OR
+    // Precedence 1: logical OR, nullish coalescing
     [
+        { op: wsOp("??"), assoc: "left", apply: makeBinOp("??") },
         { op: wsOp("||"), assoc: "left", apply: makeBinOp("||") },
     ],
     // Precedence 0: catch (unwrap Result with fallback)

package/dist/lib/runtime/hooks.d.ts

@@ -40,6 +40,7 @@ export type CallbackMap = {
         functionName: string;
         args: Record<string, any>;
         isBuiltin: boolean;
+        moduleId: string;
     };
     onFunctionEnd: {
         functionName: string;

package/dist/lib/runtime/interrupts.js

@@ -114,8 +114,10 @@ export async function respondToInterrupt(args) {
         execCtx.debuggerState = metadata.debugger;
     }
     let interruptData = interrupt.interruptData || {};
-    if (interrupt.debugger) {
-        // Debugger-generated interrupts don't carry tool-call data
+    if (interrupt.debugger && !interrupt.interruptData?.toolCall) {
+        // Debugger-generated interrupts don't carry tool-call data,
+        // unless the debug pause happened inside a tool call during an LLM call —
+        // in that case, keep interruptData so runPrompt can resume mid-conversation.
         interruptData = undefined;
     }
     else {

package/dist/lib/runtime/prompt.d.ts

@@ -2,6 +2,7 @@ import * as smoltalk from "smoltalk";
 import { MessageThread } from "./state/messageThread.js";
 import { InterruptData } from "./interrupts.js";
 import type { RuntimeContext } from "./state/context.js";
+import type { SourceLocationOpts } from "./state/checkpointStore.js";
 import { GraphState } from "./types.js";
 export interface ToolHandler {
     name: string;
@@ -20,4 +21,5 @@ export declare function runPrompt(args: {
     maxToolCallRounds?: number;
     interruptData?: InterruptData;
     removedTools?: string[];
+    checkpointInfo?: SourceLocationOpts;
 }): Promise<any>;

package/dist/lib/runtime/prompt.js

@@ -152,6 +152,7 @@ async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, client
                 isToolCall: true,
             });
             const toolCallStartTime = performance.now();
+            ctx.enterToolCall();
             try {
                 result = await handler.execute(...params);
             }
@@ -182,6 +183,9 @@ async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, client
                 }
                 continue;
             }
+            finally {
+                ctx.exitToolCall();
+            }
             // Tool returned a failure Result — handle retry logic
             if (isFailure(result)) {
                 const errorMessage = typeof result.error === "string" ? result.error : String(result.error);
@@ -250,7 +254,7 @@ async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, client
     return { isInterrupt: false, messages };
 }
 export async function runPrompt(args) {
-    const { ctx, prompt, responseFormat, maxToolCallRounds = 10, removedTools = [], } = args;
+    const { ctx, prompt, responseFormat, maxToolCallRounds = 10, removedTools = [], checkpointInfo, } = args;
     // Extract tool registry entries from clientConfig.tools and split into
     // definitions (for smoltalk) and handlers (for execution).
     const toolEntries = (args.clientConfig?.tools || []).map((entry) => entry);
@@ -330,13 +334,18 @@ export async function runPrompt(args) {
                 messages: messages.getMessages(),
                 model: clientConfig.model,
             });
-            const checkpointId = ctx.checkpoints.create(ctx, {
-                moduleId: "",
-                scopeName: "",
-                stepPath: "",
-            });
-            interrupt.checkpointId = checkpointId;
-            interrupt.checkpoint = ctx.checkpoints.get(checkpointId);
+            if (interrupt.debugger === false) {
+                // For real user interrupts, create a checkpoint at the LLM call site
+                // so we can resume the conversation. Debug interrupts keep their
+                // original checkpoint from debugStep (pointing to the tool's source).
+                const checkpointId = ctx.checkpoints.create(ctx, {
+                    moduleId: checkpointInfo?.moduleId ?? "",
+                    scopeName: checkpointInfo?.scopeName ?? "",
+                    stepPath: checkpointInfo?.stepPath ?? "",
+                });
+                interrupt.checkpointId = checkpointId;
+                interrupt.checkpoint = ctx.checkpoints.get(checkpointId);
+            }
             return interrupt;
         }
         const result = await _runPrompt({

package/dist/lib/runtime/runner.d.ts

@@ -1,6 +1,7 @@
 import type { State } from "./state/stateStack.js";
 import { StateStack } from "./state/stateStack.js";
 import type { RuntimeContext } from "./state/context.js";
+import type { SourceLocationOpts } from "./state/checkpointStore.js";
 import type { HandlerFn } from "./types.js";
 /**
  * Runner centralizes step execution logic for generated Agency code.
@@ -31,6 +32,8 @@ export declare class Runner {
     });
     /** The current step path as a string, e.g. "1_0_2" */
     key(): string;
+    /** Return checkpoint metadata for the current step. */
+    getCheckpointInfo(): SourceLocationOpts;
     private getCounter;
     private setCounter;
     halt(result: any): void;

package/dist/lib/runtime/runner.js

@@ -36,6 +36,14 @@ export class Runner {
     key() {
         return this.path.join("_");
     }
+    /** Return checkpoint metadata for the current step. */
+    getCheckpointInfo() {
+        return {
+            moduleId: this.moduleId,
+            scopeName: this.scopeName,
+            stepPath: this.path.join("."),
+        };
+    }
     getCounter() {
         if (this.path.length === 0)
             return this.frame.step;
@@ -84,6 +92,8 @@ export class Runner {
     async maybeDebugHook(id, label = null, isUserAdded = false) {
         if (!this.ctx.debuggerState && !this.ctx.traceWriter)
             return false;
+        if (this.ctx.isInsideToolCall())
+            return false;
         // On resume after a debug pause, skip the hook.
         // Don't delete the flag yet — step() will clean it up after the
         // callback completes. If the callback halts (nested interrupt),

package/dist/lib/runtime/state/checkpointStore.d.ts

@@ -40,6 +40,7 @@ export declare class Checkpoint implements SourceLocation {
     get location(): SourceLocation;
     getCurrentFrame(): import("./stateStack.js").StateJSON | undefined;
     getThreadMessages(): ThreadMessages | null;
+    private getContentFromMessage;
     getGlobalsForModule(): Record<string, any> | null;
     getFilename(): string;
     pathEquals(other: Checkpoint): boolean;

package/dist/lib/runtime/state/checkpointStore.js

@@ -61,16 +61,27 @@ export class Checkpoint {
         const messages = activeThread.messages.map((m) => ({
             role: m.role ?? "unknown",
             // smoltalk content can be string, TextPart[], or null
-            content: typeof m.content === "string"
-                ? m.content
-                : Array.isArray(m.content)
-                    ? m.content.map((p) => p.text ?? "").join("")
-                    : m.content == null
-                        ? ""
-                        : String(m.content),
+            content: this.getContentFromMessage(m),
         }));
         return { threadId: activeId, messages };
     }
+    getContentFromMessage(message) {
+        if (typeof message.content === "string") {
+            return message.content;
+        }
+        else if (Array.isArray(message.content)) {
+            return message.content.map((part) => part.text ?? "").join("");
+        }
+        else if (message.content == null) {
+            if (message.role === "assistant" && message.toolCalls) {
+                return message.toolCalls
+                    .map((toolCall) => `Tool call: ${toolCall.name}(${JSON.stringify(toolCall.arguments)})`)
+                    .join("\n");
+            }
+            return "(no content)";
+        }
+        return JSON.stringify(message.content);
+    }
     getGlobalsForModule() {
         return this.globals.store?.[this.moduleId] ?? null;
     }

package/dist/lib/runtime/state/checkpointStore.test.js

@@ -261,7 +261,7 @@ describe("Checkpoint", () => {
             });
             const result = cp.getThreadMessages();
             expect(result.messages).toEqual([
-                { role: "assistant", content: "" },
+                { role: "assistant", content: "(no content)" },
             ]);
         });
         it("should concatenate TextPart[] content", () => {

package/dist/lib/runtime/state/context.d.ts

@@ -23,6 +23,7 @@ export declare class RuntimeContext<T> {
     _skipNextCheckpoint: boolean;
     _pendingArgOverrides?: Record<string, any>;
     _restoreCount: number;
+    _toolCallDepth: number;
     debuggerState: DebuggerState | null;
     traceWriter: TraceWriter | null;
     statelogClient: StatelogClient;
@@ -40,6 +41,9 @@ export declare class RuntimeContext<T> {
     createExecutionContext(): RuntimeContext<T>;
     pushHandler(fn: HandlerFn): void;
     popHandler(): void;
+    enterToolCall(): void;
+    exitToolCall(): void;
+    isInsideToolCall(): boolean;
     registerClass(name: string, cls: ClassRegistry[string]): void;
     forkStack(): StateStack;
     /** Sever references held by an execution context so GC can reclaim them. */