@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/runtime/harness.js

@@ -36,6 +36,7 @@ import { createRuntimeMemoryManager, RuntimeMemoryFormationSync, readRuntimeMemo
 import { readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { resolveKnowledgeStorePath } from "./support/runtime-layout.js";
+import { SystemScheduleManager } from "./scheduling/system-schedule-manager.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRequests as reclaimHarnessExpiredClaimedRequests, recoverStartupRequests as recoverHarnessStartupRequests, isStaleRunningRequest as isHarnessStaleRunningRequest, } from "./harness/run/startup-runtime.js";
 import { traceStartupStage } from "./startup-tracing.js";
 import { normalizeProcessExecutablePath } from "./support/runtime-env.js";
@@ -72,6 +73,14 @@ function toPublicRequestResultShape(result) {
 }
 function toPublicHarnessStreamItem(item) {
     switch (item.type) {
+        case "commentary":
+            return {
+                type: "commentary",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                content: item.content,
+            };
         case "content":
             return {
                 type: "content",
@@ -98,6 +107,14 @@ function toPublicHarnessStreamItem(item) {
                 output: item.output,
                 ...(item.isError !== undefined ? { isError: item.isError } : {}),
             };
+        case "plan-state":
+            return {
+                type: "plan-state",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                planState: item.planState,
+            };
         case "upstream-event":
             return {
                 type: "upstream-event",
@@ -200,6 +217,7 @@ export class AgentHarnessRuntime {
     runtimeMemoryFormationSync;
     unregisterRuntimeMemoryFormationSync;
     resolvedRuntimeAdapterOptions;
+    scheduleManager;
     healthMonitor;
     recoveryConfig;
     concurrencyConfig;
@@ -252,6 +270,40 @@ export class AgentHarnessRuntime {
             acquireRequestSlot: (sessionId, requestId, activeState, priority) => this.acquireRequestSlot(sessionId, requestId, activeState, priority),
         };
     }
+    buildFunctionToolContext(input) {
+        return {
+            runtime: {
+                sessions: {
+                    list: (filter) => this.listSessions(filter),
+                    get: (sessionId) => this.getSession(sessionId),
+                },
+                requests: {
+                    list: (filter) => this.listRequests(filter),
+                    get: (requestId) => this.getRequest(requestId),
+                    cancel: (options) => this.cancelRequest(options),
+                },
+                approvals: {
+                    list: (filter) => this.listApprovals(filter),
+                    get: (approvalId) => this.getApproval(approvalId),
+                },
+                events: {
+                    list: (sessionId, requestId) => this.listRequestEvents(sessionId, requestId),
+                },
+                artifacts: {
+                    list: (sessionId, requestId) => this.listRequestArtifacts(sessionId, requestId),
+                    read: (sessionId, requestId, artifactPath) => this.readRequestArtifact(sessionId, requestId, artifactPath),
+                },
+                schedules: {
+                    manage: (options) => this.manageSchedule(options),
+                },
+                current: {
+                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+                    ...(input.requestId ? { requestId: input.requestId } : {}),
+                    ...(input.binding ? { agentId: input.binding.agent.id } : {}),
+                },
+            },
+        };
+    }
     constructor(workspace, runtimeAdapterOptions = {}) {
         this.workspace = workspace;
         this.runtimeAdapterOptions = runtimeAdapterOptions;
@@ -260,6 +312,10 @@ export class AgentHarnessRuntime {
         this.defaultRuntimeEntryBinding = this.runtimeEntryBindings[0];
         this.defaultRuntimeRootValue = this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeRoot ?? `${this.workspace.workspaceRoot}/.agent`;
         const runtimeRoot = this.defaultRuntimeRoot();
+        this.scheduleManager = new SystemScheduleManager({
+            workspaceRoot: this.workspace.workspaceRoot,
+            runtimeRoot,
+        });
         this.persistence = new SqlitePersistence(runtimeRoot);
         const defaultStoreConfig = this.defaultRuntimeEntryBinding?.harnessRuntime.store;
         this.defaultStore = resolveStoreFromConfig(this.stores, defaultStoreConfig, runtimeRoot) ?? new SqliteBackedStore(resolveKnowledgeStorePath(runtimeRoot));
@@ -273,7 +329,11 @@ export class AgentHarnessRuntime {
             readRuntimeMemoryMaintenanceConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory) ?? null;
         this.resolvedRuntimeAdapterOptions = resolveRuntimeAdapterOptions({
             workspace,
-            runtimeAdapterOptions,
+            runtimeAdapterOptions: {
+                ...runtimeAdapterOptions,
+                scheduleManager: runtimeAdapterOptions.scheduleManager ?? this.scheduleManager,
+                functionToolContextResolver: runtimeAdapterOptions.functionToolContextResolver ?? ((input) => this.buildFunctionToolContext(input)),
+            },
             checkpointers: this.checkpointers,
             stores: this.stores,
             defaultStore: this.defaultStore,
@@ -406,6 +466,22 @@ export class AgentHarnessRuntime {
         const healthConfig = readHealthMonitorConfig(workspace);
         this.healthMonitor = healthConfig.enabled ? this.createHealthMonitor() : null;
     }
+    async manageSchedule(input) {
+        return this.scheduleManager.manageSchedule(input);
+    }
+    async getSchedule(scheduleId) {
+        return this.scheduleManager.getSchedule(scheduleId);
+    }
+    async runScheduledTask(scheduleId) {
+        const schedule = await this.scheduleManager.getSchedule(scheduleId);
+        if (!schedule) {
+            throw new Error(`Unknown schedule '${scheduleId}'.`);
+        }
+        return this.run({
+            ...(schedule.agentId ? { agentId: schedule.agentId } : {}),
+            input: schedule.instruction,
+        });
+    }
     createHealthMonitor() {
         return new HealthMonitor({
             workspace: this.workspace,
@@ -512,6 +588,7 @@ export class AgentHarnessRuntime {
         return this.knowledgeModule.memorize({
             records: input.records,
             storeCandidateLog: true,
+            forceStore: true,
         }, {
             sessionId: input.sessionId,
             requestId: input.requestId,
@@ -572,6 +649,9 @@ export class AgentHarnessRuntime {
         const request = await this.persistence.getRequest(requestId);
         return request ? buildRequestInspectionRecord(this.persistence, request) : null;
     }
+    async getRequestPlanState(sessionId, requestId) {
+        return this.persistence.getRequestPlanState(sessionId, requestId);
+    }
     async getSessionSummary(sessionId) {
         const session = await this.persistence.getSession(sessionId);
         return session
@@ -916,14 +996,15 @@ export class AgentHarnessRuntime {
     }
     async invokeWithHistory(binding, input, sessionId, requestId, resumePayload, priorHistory, options = {}) {
         const history = priorHistory ?? await this.loadPriorHistory(sessionId, requestId);
-        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, sessionId, input);
+        const memoryRecall = options.memoryRecall ?? await this.buildRuntimeMemoryContext(binding, sessionId, input);
         const startedAt = Date.now();
         try {
             const result = await this.runtimeAdapter.invoke(binding, input, sessionId, requestId, resumePayload, history, {
                 ...options,
-                ...(memoryContext ? { memoryContext } : {}),
+                ...(memoryRecall?.prompt ? { memoryContext: memoryRecall.prompt } : {}),
             });
             await this.persistRuntimeMemoryCandidates(binding, sessionId, requestId, result.metadata?.memoryCandidates);
+            await this.persistRequestPlanState(sessionId, requestId, result.metadata?.executedToolResults);
             this.recordLlmSuccess(startedAt);
             return result;
         }
@@ -948,8 +1029,14 @@ export class AgentHarnessRuntime {
         return path.basename(workspaceRoot) || "default";
     }
     async buildRuntimeMemoryContext(binding, sessionId, input) {
-        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
-        return this.knowledgeModule.buildPromptContext({
+        if (!this.runtimeMemoryPolicy) {
+            return undefined;
+        }
+        const query = extractMessageText(input ?? "").trim();
+        if (!query) {
+            return undefined;
+        }
+        const promptRecall = await this.knowledgeModule.buildPromptRecall({
             query,
             topK: this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? 8,
         }, {
@@ -957,6 +1044,13 @@ export class AgentHarnessRuntime {
             agentId: binding.agent.id,
             workspaceId: this.getWorkspaceId(binding),
         });
+        if (!promptRecall.context?.trim()) {
+            return undefined;
+        }
+        return {
+            prompt: promptRecall.context,
+            items: promptRecall.items,
+        };
     }
     async persistRuntimeMemoryCandidates(binding, sessionId, requestId, value) {
         if (!Array.isArray(value) || value.length === 0) {
@@ -979,6 +1073,42 @@ export class AgentHarnessRuntime {
             recordedAt: new Date().toISOString(),
         }, { storeCandidateLog: true });
     }
+    async persistRequestPlanState(sessionId, requestId, value) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return;
+        }
+        const executedToolResults = value
+            .filter((item) => typeof item === "object" && item !== null);
+        let typedSummary = null;
+        for (const latest of [...executedToolResults].reverse()) {
+            const summary = typeof latest.output === "object" && latest.output !== null
+                ? latest.output.summary
+                : undefined;
+            if (!summary || typeof summary !== "object" || summary === null) {
+                continue;
+            }
+            const candidate = summary;
+            if (!Array.isArray(candidate.items) || !candidate.summary || typeof candidate.summary !== "object") {
+                continue;
+            }
+            typedSummary = candidate;
+            break;
+        }
+        if (!typedSummary) {
+            return;
+        }
+        const items = typedSummary.items;
+        const summary = typedSummary.summary;
+        const current = await this.persistence.getRequestPlanState(sessionId, requestId);
+        await this.persistence.saveRequestPlanState(sessionId, requestId, {
+            sessionId,
+            requestId,
+            version: (current?.version ?? 0) + 1,
+            updatedAt: new Date().toISOString(),
+            items,
+            summary,
+        });
+    }
     async resolvePersistedRequestPriority(sessionId, requestId) {
         const persisted = await this.persistence.getRequestInput(sessionId, requestId);
         return normalizeRequestPriority(persisted?.priority);
@@ -1154,7 +1284,7 @@ export class AgentHarnessRuntime {
             input: options.input,
             invocation: {
                 ...invocation,
-                memoryContext: await this.buildRuntimeMemoryContext(binding, sessionId, options.input),
+                memoryRecall: await this.buildRuntimeMemoryContext(binding, sessionId, options.input),
             },
             sessionId,
             requestId,
@@ -1164,7 +1294,10 @@ export class AgentHarnessRuntime {
             releaseRequestSlotPromise,
             getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
             loadPriorHistory: (sessionId, requestId) => this.loadPriorHistory(sessionId, requestId),
-            stream: (binding, message, sessionId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, sessionId, priorHistory, streamOptions),
+            stream: (binding, message, sessionId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, sessionId, priorHistory, {
+                ...streamOptions,
+                profiling: true,
+            }),
             invokeWithHistory: (binding, input, sessionId, requestId) => this.invokeWithHistory(binding, input, sessionId, requestId),
             emit: (sessionId, requestId, sequence, eventType, payload) => this.emit(sessionId, requestId, sequence, eventType, payload),
             setRequestStateAndEmit: (sessionId, requestId, sequence, state, stateOptions) => this.setRequestStateAndEmit(sessionId, requestId, sequence, state, stateOptions),
@@ -1236,6 +1369,7 @@ export class AgentHarnessRuntime {
         }
         this.closed = true;
         await this.healthMonitor?.stop();
+        await this.eventBus.drain();
         this.unregisterSessionMemorySync();
         this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();

package/dist/runtime/maintenance/sqlite-checkpoint-saver.d.ts

@@ -8,17 +8,22 @@ type MemorySaverPutResult = ReturnType<MemorySaver["put"]>;
 export declare class SqliteCheckpointSaver extends MemorySaver {
     readonly filePath: string;
     private client;
-    private loaded;
+    private readonly savers;
     private initialized;
     private initialization;
     private operationChain;
+    private legacyDefaultRow;
     constructor(filePath: string);
     private runSerialized;
     private getClient;
+    private executeWithBusyRetry;
     private ensureInitialized;
+    private getStateKey;
     private loadStateRow;
-    private ensureLoaded;
-    private persist;
+    private loadLegacyDefaultRow;
+    private loadSaver;
+    private ensureLoadedState;
+    private persistState;
     getTuple(config: MemorySaverConfig): Promise<import("@langchain/langgraph").CheckpointTuple | undefined>;
     list(config: MemorySaverConfig, options?: MemorySaverListOptions): AsyncGenerator<import("@langchain/langgraph").CheckpointTuple, void, unknown>;
     put(config: MemorySaverConfig, checkpoint: MemorySaverPutCheckpoint, metadata: MemorySaverPutMetadata): MemorySaverPutResult;

package/dist/runtime/maintenance/sqlite-checkpoint-saver.js

@@ -5,6 +5,8 @@ import { createClient } from "@libsql/client";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "../adapter/upstream-configurable-keys.js";
 const CHECKPOINT_TABLE = "checkpoint_state";
 const DEFAULT_STATE_KEY = "default";
+const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
+const SQLITE_BUSY_RETRY_DELAY_MS = 100;
 function normalizeCheckpointConfig(config) {
     if (!config?.configurable) {
         return config;
@@ -52,28 +54,70 @@ function decodeBinary(value) {
     }
     return value;
 }
-function pruneSessionEntries(record, sessionId) {
-    for (const key of Object.keys(record)) {
-        if (key.includes(sessionId)) {
-            delete record[key];
-            continue;
-        }
-        const value = record[key];
-        if (typeof value === "object" && value && !Array.isArray(value)) {
-            pruneSessionEntries(value, sessionId);
-            if (Object.keys(value).length === 0) {
-                delete record[key];
-            }
-        }
+function parseWriteScopeKey(key) {
+    try {
+        const parsed = JSON.parse(key);
+        return Array.isArray(parsed) && typeof parsed[0] === "string" ? parsed[0] : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractScopedStorage(storage, stateKey) {
+    if (stateKey === DEFAULT_STATE_KEY) {
+        return structuredClone(storage);
+    }
+    const scoped = storage[stateKey];
+    return scoped === undefined ? {} : { [stateKey]: structuredClone(scoped) };
+}
+function extractScopedWrites(writes, stateKey) {
+    if (stateKey === DEFAULT_STATE_KEY) {
+        return structuredClone(writes);
     }
+    return Object.fromEntries(Object.entries(writes)
+        .filter(([key]) => parseWriteScopeKey(key) === stateKey)
+        .map(([key, value]) => [key, structuredClone(value)]));
+}
+function createIsolatedMemorySaver(storage, writes) {
+    const saver = new MemorySaver();
+    const typed = saver;
+    typed.storage = storage;
+    typed.writes = writes;
+    return saver;
+}
+function serializeSaverState(saver) {
+    const typed = saver;
+    return {
+        storage: structuredClone(typed.storage ?? {}),
+        writes: structuredClone(typed.writes ?? {}),
+    };
+}
+function collectErrorMessages(error) {
+    const messages = [];
+    let current = error;
+    while (current instanceof Error) {
+        messages.push(current.message);
+        current = current.cause;
+    }
+    if (typeof current === "string" && current.length > 0) {
+        messages.push(current);
+    }
+    return messages;
+}
+function isSqliteBusyError(error) {
+    return collectErrorMessages(error).some((message) => /SQLITE_BUSY|database is locked/i.test(message));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export class SqliteCheckpointSaver extends MemorySaver {
     filePath;
     client = null;
-    loaded = false;
+    savers = new Map();
     initialized = false;
     initialization = null;
     operationChain = Promise.resolve();
+    legacyDefaultRow;
     constructor(filePath) {
         super();
         this.filePath = filePath;
@@ -90,6 +134,19 @@ export class SqliteCheckpointSaver extends MemorySaver {
         }
         return this.client;
     }
+    async executeWithBusyRetry(operation) {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
+                    throw error;
+                }
+                await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
+            }
+        }
+    }
     async ensureInitialized() {
         if (this.initialized) {
             return;
@@ -100,97 +157,139 @@ export class SqliteCheckpointSaver extends MemorySaver {
         }
         this.initialization = (async () => {
             const client = await this.getClient();
-            await client.execute("PRAGMA journal_mode=WAL");
-            await client.execute("PRAGMA foreign_keys=ON");
-            await client.execute("PRAGMA busy_timeout=5000");
-            await client.execute(`
+            await this.executeWithBusyRetry(() => client.execute("PRAGMA journal_mode=WAL"));
+            await this.executeWithBusyRetry(() => client.execute("PRAGMA foreign_keys=ON"));
+            await this.executeWithBusyRetry(() => client.execute("PRAGMA busy_timeout=5000"));
+            await this.executeWithBusyRetry(() => client.execute(`
         CREATE TABLE IF NOT EXISTS ${CHECKPOINT_TABLE} (
           state_key TEXT PRIMARY KEY,
           state_json TEXT NOT NULL,
           updated_at TEXT NOT NULL
         )
-      `);
+      `));
             this.initialized = true;
             this.initialization = null;
         })();
         await this.initialization;
     }
-    async loadStateRow() {
+    getStateKey(config) {
+        const normalized = normalizeCheckpointConfig(config);
+        const sessionId = normalized?.configurable?.[UPSTREAM_SESSION_CONFIG_KEY];
+        return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : DEFAULT_STATE_KEY;
+    }
+    async loadStateRow(stateKey) {
         await this.ensureInitialized();
         const client = await this.getClient();
-        const result = await client.execute({
+        const result = await this.executeWithBusyRetry(() => client.execute({
             sql: `SELECT state_json, updated_at FROM ${CHECKPOINT_TABLE} WHERE state_key = ?`,
-            args: [DEFAULT_STATE_KEY],
-        });
+            args: [stateKey],
+        }));
         return result.rows[0] ?? null;
     }
-    async ensureLoaded() {
-        if (this.loaded) {
-            return;
+    async loadLegacyDefaultRow() {
+        if (this.legacyDefaultRow !== undefined) {
+            return this.legacyDefaultRow;
         }
-        const row = await this.loadStateRow();
+        this.legacyDefaultRow = await this.loadStateRow(DEFAULT_STATE_KEY);
+        return this.legacyDefaultRow;
+    }
+    async loadSaver(stateKey) {
+        if (this.savers.has(stateKey)) {
+            return this.savers.get(stateKey);
+        }
+        let storage = {};
+        let writes = {};
+        const row = await this.loadStateRow(stateKey);
         if (row) {
             const parsed = JSON.parse(row.state_json);
-            this.storage = decodeBinary(parsed.storage ?? {});
-            this.writes = decodeBinary(parsed.writes ?? {});
+            storage = extractScopedStorage(decodeBinary(parsed.storage ?? {}), stateKey);
+            writes = extractScopedWrites(decodeBinary(parsed.writes ?? {}), stateKey);
         }
-        else {
-            this.storage = {};
-            this.writes = {};
+        else if (stateKey !== DEFAULT_STATE_KEY) {
+            const legacyRow = await this.loadLegacyDefaultRow();
+            if (legacyRow) {
+                const parsed = JSON.parse(legacyRow.state_json);
+                storage = extractScopedStorage(decodeBinary(parsed.storage ?? {}), stateKey);
+                writes = extractScopedWrites(decodeBinary(parsed.writes ?? {}), stateKey);
+            }
         }
-        this.loaded = true;
+        const saver = createIsolatedMemorySaver(storage, writes);
+        this.savers.set(stateKey, saver);
+        return saver;
+    }
+    async ensureLoadedState(config) {
+        const stateKey = this.getStateKey(config);
+        return { stateKey, saver: await this.loadSaver(stateKey) };
     }
-    async persist() {
+    async persistState(stateKey, saver) {
         await this.ensureInitialized();
         const client = await this.getClient();
+        const snapshot = serializeSaverState(saver);
+        const scopedStorage = snapshot.storage;
+        const scopedWrites = snapshot.writes;
+        if (stateKey !== DEFAULT_STATE_KEY &&
+            Object.keys(scopedStorage).length === 0 &&
+            Object.keys(scopedWrites).length === 0) {
+            await this.executeWithBusyRetry(() => client.execute({
+                sql: `DELETE FROM ${CHECKPOINT_TABLE} WHERE state_key = ?`,
+                args: [stateKey],
+            }));
+            this.savers.delete(stateKey);
+            return;
+        }
         const now = new Date().toISOString();
         const payload = JSON.stringify({
-            storage: this.storage,
-            writes: this.writes,
+            storage: scopedStorage,
+            writes: scopedWrites,
         }, (_key, value) => encodeBinary(value));
-        await client.execute({
+        await this.executeWithBusyRetry(() => client.execute({
             sql: `INSERT INTO ${CHECKPOINT_TABLE} (state_key, state_json, updated_at)
          VALUES (?, ?, ?)
          ON CONFLICT(state_key) DO UPDATE SET
            state_json = excluded.state_json,
            updated_at = excluded.updated_at`,
-            args: [DEFAULT_STATE_KEY, payload, now],
-        });
+            args: [stateKey, payload, now],
+        }));
     }
     async getTuple(config) {
         return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            return super.getTuple(normalizeCheckpointConfig(config));
+            const { saver } = await this.ensureLoadedState(config);
+            return saver.getTuple(normalizeCheckpointConfig(config));
         });
     }
     async *list(config, options) {
-        await this.ensureLoaded();
-        for await (const item of super.list(normalizeCheckpointConfig(config), options)) {
+        const { saver } = await this.ensureLoadedState(config);
+        for await (const item of saver.list(normalizeCheckpointConfig(config), options)) {
             yield item;
         }
     }
     async put(config, checkpoint, metadata) {
         return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            const result = await super.put(normalizeCheckpointConfig(config), checkpoint, metadata);
-            await this.persist();
+            const { stateKey, saver } = await this.ensureLoadedState(config);
+            const result = await saver.put(normalizeCheckpointConfig(config), checkpoint, metadata);
+            await this.persistState(stateKey, saver);
             return result;
         });
     }
     async putWrites(config, writes, taskId) {
         return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            const result = await super.putWrites(normalizeCheckpointConfig(config), writes, taskId);
-            await this.persist();
+            const { stateKey, saver } = await this.ensureLoadedState(config);
+            const result = await saver.putWrites(normalizeCheckpointConfig(config), writes, taskId);
+            await this.persistState(stateKey, saver);
             return result;
         });
     }
     async deleteSession(sessionId) {
         return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            pruneSessionEntries(this.storage, sessionId);
-            pruneSessionEntries(this.writes, sessionId);
-            await this.persist();
+            const { saver } = await this.ensureLoadedState({
+                configurable: {
+                    [UPSTREAM_SESSION_CONFIG_KEY]: sessionId,
+                },
+            });
+            const typed = saver;
+            typed.storage = {};
+            typed.writes = {};
+            await this.persistState(sessionId, saver);
         });
     }
 }

package/dist/runtime/parsing/output-parsing.d.ts

@@ -1,9 +1,12 @@
+import { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION } from "../support/runtime-prompts.js";
+export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, };
 export declare function sanitizeVisibleText(value: string): string;
 export declare function tryParseJson(value: string): unknown | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
 export declare function isLikelyToolArgsObject(value: unknown): boolean;
 export declare function readTextContent(value: unknown): string;
 export declare function hasToolCalls(value: unknown): boolean;
+export declare function containsLikelySkillDocument(value: unknown): boolean;
 export declare function extractToolFallbackContext(value: unknown): string;
 export declare function extractVisibleOutput(value: unknown): string;
 export declare function extractOutputContent(value: unknown): unknown;
@@ -12,9 +15,14 @@ export declare function extractEmptyAssistantMessageFailure(value: unknown): str
 export declare function isToolCallParseFailure(error: unknown): boolean;
 export declare function isToolCallValidationFailure(error: unknown): boolean;
 export declare function isToolCallRecoveryFailure(error: unknown): boolean;
-export declare const STRICT_TOOL_JSON_INSTRUCTION = "When calling tools, return only the tool call itself. The arguments must be a pure JSON object with no explanatory text before or after it.";
-export declare const WRITE_TODOS_FULL_ENTRY_INSTRUCTION = "When calling write_todos, every todo item must include both content and status. Do not send status-only updates. Retry by resending the full todo entry with the original content preserved.";
+export declare function isWorkspacePathScopeFailure(error: unknown): boolean;
+export declare function isRepairableWriteTodosPlaceholderFailure(error: unknown): boolean;
+export declare function isRetrySafeInvalidToolSelectionError(value: unknown): boolean;
+export declare function shouldValidateExecutionWithoutToolEvidence(request: unknown): boolean;
+export declare function resolveExecutionWithoutToolEvidenceInstruction(request: unknown, result: unknown): string | null;
+export declare function resolveExecutionWithoutToolEvidenceTextInstruction(request: unknown, assistantText: string, toolCallEvidence?: boolean): string | null;
 export declare function isRepairableWriteTodosContentFailure(error: unknown): boolean;
+export declare function isRepairableWriteTodosEmptyFailure(error: unknown): boolean;
 export declare function resolveToolCallRecoveryInstruction(error: unknown): string | null;
 export declare function appendToolRecoveryInstruction(input: unknown, instruction: string): unknown;
 export declare function wrapResolvedModel<T>(value: T): T;