@botbotgo/agent-harness 0.0.323 → 0.0.325

package/dist/resource/isolation.js

@@ -6,6 +6,10 @@ import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, stat, symlink } from "node:fs/promises";
 const HARNESS_PACKAGE_NAME = "@botbotgo/agent-harness";
 const HARNESS_PACKAGE_ROOT = path.resolve(import.meta.dirname, "..", "..");
+const HARNESS_TOOL_AUTHORING_DEPENDENCIES = [
+    "@langchain/core",
+    "zod",
+];
 const isolatedResourceRootCache = new Map();
 const isolatedResourceRootBuilds = new Map();
 function isolationCacheRoot() {
@@ -91,6 +95,29 @@ async function linkHarnessPackage(isolatedRoot) {
     await mkdir(path.dirname(targetPath), { recursive: true });
     await symlink(HARNESS_PACKAGE_ROOT, targetPath, "junction");
 }
+function resolveHarnessOwnedDependency(dependencyName) {
+    try {
+        const requireFromHarness = createRequire(path.join(HARNESS_PACKAGE_ROOT, "package.json"));
+        return dependencyPackageRoot(requireFromHarness.resolve(`${dependencyName}/package.json`));
+    }
+    catch {
+        return null;
+    }
+}
+async function linkHarnessToolAuthoringDependencies(isolatedRoot) {
+    for (const dependencyName of HARNESS_TOOL_AUTHORING_DEPENDENCIES) {
+        const targetPath = dependencyLinkPath(isolatedRoot, dependencyName);
+        if (existsSync(targetPath)) {
+            continue;
+        }
+        const resolved = resolveHarnessOwnedDependency(dependencyName);
+        if (!resolved) {
+            continue;
+        }
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await symlink(resolved, targetPath, "junction");
+    }
+}
 async function buildIsolatedResourceRoot(packageRoot) {
     const packageJsonPath = path.join(packageRoot, "package.json");
     const manifest = existsSync(packageJsonPath)
@@ -109,6 +136,7 @@ async function buildIsolatedResourceRoot(packageRoot) {
     await mkdir(path.join(isolatedRoot, "node_modules"), { recursive: true });
     await linkDeclaredDependencies(isolatedRoot, packageRoot, manifest);
     await linkHarnessPackage(isolatedRoot);
+    await linkHarnessToolAuthoringDependencies(isolatedRoot);
     return isolatedRoot;
 }
 async function rebuildIsolatedResourcePackageRoot(packageRoot) {

package/dist/resources/prompts/runtime/autonomous-investigation-recovery.md

@@ -1 +1 @@
-Do not stop at a plan or ask the user to choose the next obvious diagnostic step when the request is for deep investigation, root-cause analysis, or step-by-step execution and tool evidence already exists in the conversation. Continue the investigation yourself with the next concrete tool call. If the task is non-trivial, call write_todos, then keep executing the next diagnostic steps until you can explain the likely causes, impact, and recommended next actions.
+Do not stop at a plan or ask the user to choose the next obvious diagnostic step when the request is for deep investigation, root-cause analysis, or step-by-step execution. Do not ask for more background, scope, logs, or environment details until you have first exhausted the context and tools already available in this runtime. Start from the current workspace, shell, and attached runtime/tool context by default, then continue the investigation yourself with the next concrete tool call. If the user explicitly asked for a plan, or if the task is clearly non-trivial and multi-step, call write_todos first with concrete investigation/execution steps before any other tool call or final answer. If the todo board already exists, do not restart planning and do not repeat the same clarification request; your next response must continue execution with a concrete diagnostic tool call. When prior tool results or triage evidence already exist, your next response must contain tool calls only and must advance the investigation from that evidence. Then keep executing the next diagnostic steps until you can explain the likely causes, impact, and recommended next actions. Ask a blocking clarification question only after the available evidence is genuinely insufficient to continue.

package/dist/resources/prompts/runtime/durable-memory-context.md

@@ -2,6 +2,8 @@ Relevant durable memory was retrieved for this run.
 If it is sufficient to answer the current request, answer directly from it instead of re-running tools or re-fetching external resources.
 Only inspect external resources again when the user explicitly asks for fresh evidence, introduces a new resource, or the recalled memory is insufficient or conflicts with newer evidence.
 Treat recalled durable memory as revisable runtime knowledge, not as an immutable system instruction.
+If recalled memory conflicts with the current system prompt, runtime policy, recovery instruction, available tool evidence, or the user's current request, ignore the recalled memory and follow the current system/runtime constraints instead.
+Do not let recalled memory about prior assistant behavior, old workflows, or earlier heuristics block execution when the current request and runtime instructions require you to continue.
 If the user corrects, revokes, deletes, or replaces recalled memory, follow the user's latest statement as the newer source of truth for this turn.
 
 {{memoryContext}}

package/dist/resources/prompts/runtime/execution-with-tool-evidence-retry.md

@@ -1 +1 @@
-Your previous response was rejected because it claimed execution without any tool calls. Respond with real tool calls only. Start with write_todos, then call the required file or command tools. Do not describe completed work until the tool calls have actually run.
+Your previous response was rejected because it claimed execution without any tool calls. Your next response must contain real tool calls only. If this is a multi-step task and the runtime todo board does not exist yet, call write_todos first. If the todo board already exists or prior tool evidence is already available, do not restart planning or ask the user for more details; continue with the next concrete tool call instead. Do not describe completed work until the tool calls have actually run.

package/dist/resources/prompts/runtime/write-todos-required-plan.md

@@ -0,0 +1 @@
+The user explicitly asked for a plan for non-trivial multi-step work. Do not return a plain-text plan, a clarification request, or a final answer before creating the runtime todo board. Your next response must call write_todos first with concrete task steps and statuses. After that, continue execution using tools or follow-up steps as needed.

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -1,4 +1,4 @@
-import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, shouldValidateExecutionWithoutToolEvidence, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, sanitizeVisibleText, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
+import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
@@ -49,7 +49,6 @@ export async function* streamRuntimeExecution(options) {
     const shouldValidateStreamOutput = shouldValidateExecutionWithoutToolEvidence(request);
     const deferredStreamContent = [];
     let sawRetrySafeInvalidToolSelectionError = false;
-    let sawNonRetrySafeToolSideEffects = false;
     const shouldDeferStreamContent = () => shouldValidateStreamOutput && !emittedUnsafeStreamSideEffects;
     const flushDeferredStreamContent = async function* () {
         while (deferredStreamContent.length > 0) {
@@ -248,7 +247,6 @@ export async function* streamRuntimeExecution(options) {
                         }
                         if (eventContainsNonTodoToolResult || eventContainsNonRetrySafeChunk) {
                             emittedUnsafeStreamSideEffects = true;
-                            sawNonRetrySafeToolSideEffects = true;
                         }
                         if (chunk.kind === "content" && shouldDeferStreamContent()) {
                             deferredStreamContent.push(chunk);
@@ -280,53 +278,10 @@ export async function* streamRuntimeExecution(options) {
                     });
                 throw error;
             }
-            const streamRecoveryInstruction = resolveExecutionWithoutToolEvidenceTextInstruction(request, projectionState.emittedOutput, projectionState.emittedToolResult || (projectionState.emittedToolError && (sawNonRetrySafeToolSideEffects || !sawRetrySafeInvalidToolSelectionError)));
-            const terminalRecoveryInstruction = streamRecoveryInstruction
-                ?? (!emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION : null);
-            if (!emittedUnsafeStreamSideEffects && terminalRecoveryInstruction) {
-                const toolRecovery = startProfileStep({
-                    id: "profile:agent:stream-output-recovery-fallback",
-                    kind: "agent",
-                    name: "stream output recovery fallback",
-                    action: "invoke",
-                    detail: {
-                        recoveryInstruction: terminalRecoveryInstruction,
-                    },
-                });
-                if (shouldProfile)
-                    yield toolRecovery.chunk;
+            const terminalRecoveryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION : null;
+            if (terminalRecoveryInstruction) {
                 let retried;
-                try {
-                    retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, terminalRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
-                    if (shouldProfile)
-                        yield finishProfileStep({
-                            id: "profile:agent:stream-output-recovery-fallback",
-                            kind: "agent",
-                            name: "stream output recovery fallback",
-                            action: "invoke",
-                            startedAt: toolRecovery.startedAt,
-                            status: "completed",
-                            detail: {
-                                recoveryInstruction: terminalRecoveryInstruction,
-                            },
-                        });
-                }
-                catch (retryError) {
-                    if (shouldProfile)
-                        yield finishProfileStep({
-                            id: "profile:agent:stream-output-recovery-fallback",
-                            kind: "agent",
-                            name: "stream output recovery fallback",
-                            action: "invoke",
-                            startedAt: toolRecovery.startedAt,
-                            status: "failed",
-                            detail: {
-                                recoveryInstruction: terminalRecoveryInstruction,
-                            },
-                            error: retryError,
-                        });
-                    throw retryError;
-                }
+                retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, terminalRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
                 const executedToolResults = Array.isArray(retried.metadata?.executedToolResults)
                     ? retried.metadata.executedToolResults
                     : [];
@@ -340,9 +295,8 @@ export async function* streamRuntimeExecution(options) {
                 }
                 if (retried.output) {
                     const visible = toVisibleContent(retried.output);
-                    if (visible) {
+                    if (visible)
                         yield { kind: "content", content: visible };
-                    }
                 }
                 return;
             }
@@ -492,49 +446,7 @@ export async function* streamRuntimeExecution(options) {
     }
     catch (error) {
         if (!emittedUnsafeStreamSideEffects && options.isRetryableProviderError?.(options.binding, error)) {
-            const providerRetry = startProfileStep({
-                id: "profile:agent:provider-retry-fallback",
-                kind: "agent",
-                name: "provider retry fallback",
-                action: "invoke",
-                detail: {
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            });
-            if (shouldProfile)
-                yield providerRetry.chunk;
-            let recovered;
-            try {
-                recovered = await options.invoke(options.binding, options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
-                if (shouldProfile)
-                    yield finishProfileStep({
-                        id: "profile:agent:provider-retry-fallback",
-                        kind: "agent",
-                        name: "provider retry fallback",
-                        action: "invoke",
-                        startedAt: providerRetry.startedAt,
-                        status: "completed",
-                        detail: {
-                            error: error instanceof Error ? error.message : String(error),
-                        },
-                    });
-            }
-            catch (retryError) {
-                if (shouldProfile)
-                    yield finishProfileStep({
-                        id: "profile:agent:provider-retry-fallback",
-                        kind: "agent",
-                        name: "provider retry fallback",
-                        action: "invoke",
-                        startedAt: providerRetry.startedAt,
-                        status: "failed",
-                        detail: {
-                            error: error instanceof Error ? error.message : String(error),
-                        },
-                        error: retryError,
-                    });
-                throw retryError;
-            }
+            const recovered = await options.invoke(options.binding, options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
             const executedToolResults = Array.isArray(recovered.metadata?.executedToolResults)
                 ? recovered.metadata.executedToolResults
                 : [];
@@ -548,9 +460,8 @@ export async function* streamRuntimeExecution(options) {
             }
             if (recovered.output) {
                 const visible = toVisibleContent(recovered.output);
-                if (visible) {
+                if (visible)
                     yield { kind: "content", content: visible };
-                }
             }
             return;
         }
@@ -566,54 +477,11 @@ export async function* streamRuntimeExecution(options) {
         if (!recoveryInstruction) {
             throw error;
         }
-        const toolRecovery = startProfileStep({
-            id: "profile:agent:tool-recovery-fallback",
-            kind: "agent",
-            name: "tool recovery fallback",
-            action: "invoke",
-            detail: {
-                recoveryInstruction,
-            },
-        });
-        if (shouldProfile)
-            yield toolRecovery.chunk;
-        let retried;
-        try {
-            retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, recoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
-            if (shouldProfile)
-                yield finishProfileStep({
-                    id: "profile:agent:tool-recovery-fallback",
-                    kind: "agent",
-                    name: "tool recovery fallback",
-                    action: "invoke",
-                    startedAt: toolRecovery.startedAt,
-                    status: "completed",
-                    detail: {
-                        recoveryInstruction,
-                    },
-                });
-        }
-        catch (retryError) {
-            if (shouldProfile)
-                yield finishProfileStep({
-                    id: "profile:agent:tool-recovery-fallback",
-                    kind: "agent",
-                    name: "tool recovery fallback",
-                    action: "invoke",
-                    startedAt: toolRecovery.startedAt,
-                    status: "failed",
-                    detail: {
-                        recoveryInstruction,
-                    },
-                    error: retryError,
-                });
-            throw retryError;
-        }
+        const retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, recoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
         if (retried.output) {
             const visible = toVisibleContent(retried.output);
-            if (visible) {
+            if (visible)
                 yield { kind: "content", content: visible };
-            }
         }
     }
 }

package/dist/runtime/adapter/model/invocation-request.js

@@ -123,7 +123,7 @@ function buildContextualFollowUpInstruction(inputText, hasDurableMemory) {
     if (!hasDurableMemory || hasExplicitResourceReference(inputText)) {
         return undefined;
     }
-    return "Answer the user's current follow-up directly from the recalled context. If the current user turn corrects, revokes, deletes, or replaces recalled memory, treat the user's latest statement as newer than the recalled memory for this turn. Do not frame the reply as a fresh URL or page summary unless the current user turn explicitly includes a new resource to inspect.";
+    return "Answer the user's current follow-up directly from the recalled context when it remains relevant. If recalled memory conflicts with the current system prompt, runtime policy, recovery instruction, available tool evidence, or the user's current request, ignore the recalled memory for this turn. If the current user turn corrects, revokes, deletes, or replaces recalled memory, treat the user's latest statement as newer than the recalled memory for this turn. Do not frame the reply as a fresh URL or page summary unless the current user turn explicitly includes a new resource to inspect.";
 }
 export function buildSlashCommandSkillInstruction(binding, input) {
     const inputText = extractMessageText(input).trim();

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -121,6 +121,27 @@ function formatHttpResponse(result) {
     ];
     return lines.length > 0 ? lines.join("\n") : "Request completed.";
 }
+async function fetchUrlWithRuntimeFallback(backend, url) {
+    if (typeof backend.fetchUrl === "function") {
+        try {
+            const result = await Promise.resolve(backend.fetchUrl(url));
+            if (typeof result === "string") {
+                return result;
+            }
+            return formatHttpResponse(result);
+        }
+        catch {
+            // Fall through to the runtime-owned network fetch below.
+        }
+    }
+    const response = await fetch(url);
+    return formatHttpResponse({
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: await response.text(),
+    });
+}
 function parseScheduleWhen(value) {
     const normalized = value.trim().toLowerCase();
     if (!normalized) {
@@ -388,15 +409,8 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         description: "Fetch a URL and return the response body.",
         schema: z.object({ url: z.string() }).passthrough(),
         invoke: async (input, toolConfig) => {
-            if (typeof backend.fetchUrl !== "function") {
-                return notAvailable("fetch_url", "URL fetching");
-            }
             const typed = isRecord(input) ? input : {};
-            const result = await Promise.resolve(backend.fetchUrl(typeof typed.url === "string" ? typed.url : ""));
-            if (typeof result === "string") {
-                return finalizeOutput("fetch_url", result, toolConfig);
-            }
-            return finalizeOutput("fetch_url", formatHttpResponse(result), toolConfig);
+            return finalizeOutput("fetch_url", await fetchUrlWithRuntimeFallback(backend, typeof typed.url === "string" ? typed.url : ""), toolConfig);
         },
     });
     tools.set("http_request", {

package/dist/runtime/harness/run/stream-run.js

@@ -360,6 +360,7 @@ export async function* streamHarnessRun(options) {
     let streamActivityObserved = false;
     let nonUpstreamStreamActivityObserved = false;
     let assistantOutput = "";
+    const bufferAssistantTextUntilCompletion = true;
     let currentAgentId = options.selectedAgentId;
     let currentAgentName = formatAgentName(options.selectedAgentId);
     let delegationChain = [options.selectedAgentId];
@@ -594,6 +595,9 @@ export async function* streamHarnessRun(options) {
             }
             emitted = true;
             assistantOutput += normalizedChunk.content;
+            if (bufferAssistantTextUntilCompletion) {
+                continue;
+            }
             yield {
                 type: "event",
                 event: await options.emit(options.sessionId, options.requestId, 3, "output.delta", { content: normalizedChunk.content }),
@@ -646,6 +650,19 @@ export async function* streamHarnessRun(options) {
                 }
             }
         }
+        if (assistantOutput && bufferAssistantTextUntilCompletion) {
+            yield {
+                type: "event",
+                event: await options.emit(options.sessionId, options.requestId, 3, "output.delta", { content: assistantOutput }),
+            };
+            yield {
+                type: "content",
+                sessionId: options.sessionId,
+                requestId: options.requestId,
+                agentId: currentAgentId,
+                content: assistantOutput,
+            };
+        }
         await options.appendAssistantMessage(options.sessionId, options.requestId, assistantOutput);
         const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "completed", {
             previousState: "running",

package/dist/runtime/harness/system/runtime-memory-manager.js

@@ -5,6 +5,7 @@ import { FileBackedStore } from "./store.js";
 import { compileModel } from "../../../workspace/resource-compilers.js";
 import { resolvePromptValue, resolveRefId } from "../../../workspace/support/workspace-ref-utils.js";
 import { renderRuntimeMemoryManagerPrompt, renderRuntimeMemoryMutationReconciliationPrompt } from "../../prompts/runtime-prompts.js";
+import { isNonDurableTranscriptWorkflowMemory } from "./runtime-memory-policy.js";
 const FORMATION_EVENT_TYPES = new Set([
     "request.state.changed",
     "approval.resolved",
@@ -536,6 +537,9 @@ export async function runModelMemoryManager(input) {
         }
         const refinedCandidates = asCandidateOutputs(parsed, candidate, allowedScopes, input.recordedAt);
         for (const refinedCandidate of refinedCandidates) {
+            if (isNonDurableTranscriptWorkflowMemory(refinedCandidate, candidate)) {
+                continue;
+            }
             const reconciledCandidate = await reconcileKnowledgeMutation({
                 invoker: callableInvoker,
                 candidate: refinedCandidate,

package/dist/runtime/harness/system/runtime-memory-policy.d.ts

@@ -29,6 +29,20 @@ export declare function resolveMemoryNamespace(template: string, values: Record<
 export declare function hasExplicitResourceReference(text: string): boolean;
 export declare function extractExplicitResourceReferences(text: string): string[];
 export declare function shouldRecallDurableMemory(text: string): boolean;
+export declare function isNonDurableTranscriptWorkflowMemory(input: {
+    content: string;
+    summary?: string;
+    kind?: string;
+    scope?: string;
+    sourceType?: string;
+    tags?: string[];
+}, sourceCandidate?: {
+    content?: string;
+    summary?: string;
+    scope?: string;
+    sourceType?: string;
+    tags?: string[];
+}): boolean;
 export declare function collectMemoryCandidateLabels(candidate: {
     kind?: string;
     scope?: string;

package/dist/runtime/harness/system/runtime-memory-policy.js

@@ -110,6 +110,25 @@ export function shouldRecallDurableMemory(text) {
 function normalizePolicyLabel(value) {
     return value.trim().toLowerCase().replace(/[\s-]+/g, "_");
 }
+function normalizeMemoryText(value) {
+    return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function hasTranscriptReflectionSource(input) {
+    const sourceType = normalizeMemoryText(input.sourceType);
+    void input.tags;
+    return sourceType === "runtime-transcript" || sourceType === "runtime-reflection";
+}
+export function isNonDurableTranscriptWorkflowMemory(input, sourceCandidate) {
+    if (!hasTranscriptReflectionSource({
+        sourceType: input.sourceType ?? sourceCandidate?.sourceType,
+        tags: [...(input.tags ?? []), ...(sourceCandidate?.tags ?? [])],
+    })) {
+        return false;
+    }
+    const kind = normalizeMemoryText(input.kind);
+    const scope = normalizeMemoryText(input.scope ?? sourceCandidate?.scope);
+    return kind === "procedural" || scope === "user" || scope === "workspace" || scope === "project";
+}
 export function collectMemoryCandidateLabels(candidate) {
     return Array.from(new Set([
         ...(candidate.kind ? [normalizePolicyLabel(candidate.kind)] : []),

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

@@ -1,3 +1,4 @@
-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, appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.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, } from "../prompts/runtime-prompts.js";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

package/dist/runtime/parsing/output-parsing.js

@@ -1,3 +1,4 @@
-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, appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.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, } from "../prompts/runtime-prompts.js";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

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

@@ -8,8 +8,10 @@ export declare function isToolCallRecoveryFailure(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 resolveExecutionWithoutToolEvidenceTextInstruction(request: unknown, assistantText: string, toolCallEvidence?: boolean, resultEvidence?: {
+    hasWriteTodosEvidence?: boolean;
+    hasToolResultEvidence?: boolean;
+}): string | null;
 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;
-export { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_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 "../prompts/runtime-prompts.js";