@nodetool-ai/agents 0.7.0-rc.22 → 0.8.1

package/dist/step-executor.js

@@ -4,24 +4,25 @@
  * Port of src/nodetool/agents/step_executor.py
  *
  * Manages the LLM interaction loop: sending messages, handling tool calls,
- * monitoring token limits, and capturing the step result via finish_step
- * or inline JSON extraction.
+ * and capturing the step result via finish_step (for schema'd steps) or the
+ * assistant's text response (for unstructured steps).
  */
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { createHash } from "node:crypto";
-import { withAgentSpanGen } from "@nodetool-ai/runtime";
+import { ACTIVE_MODEL_CONTEXT_KEY, isChunk, isToolCall, memoryKeys, withAgentSpanGen, mediaResolverFor } from "@nodetool-ai/runtime";
+import { linkAbort } from "./utils/link-abort.js";
 import { createLogger } from "@nodetool-ai/config";
 import { TaskUpdateEvent } from "@nodetool-ai/protocol";
-import { ControlNodeTool } from "./tools/control-tool.js";
+import { Tool } from "./tools/base-tool.js";
+import { extractInjectableImages, stripImagePayload } from "./tools/image-injection.js";
 import { FinishStepTool } from "./tools/finish-step-tool.js";
-import { extractJSON } from "./utils/json-parser.js";
-import { DEFAULT_TOKEN_LIMIT, MAX_TOOL_RESULT_CHARS } from "./constants.js";
-import { rejectAgenticProvider } from "./reject-agentic-provider.js";
+import { getSharedTools } from "./tools/shared-tools.js";
+import { truncateToolResult } from "./constants.js";
+import { formatViolations, validateAgainstSchema } from "./utils/json-schema-validate.js";
+import { lastProseHint } from "./utils/step-failure.js";
+import { createUiEventBuffer } from "./utils/ui-event-buffer.js";
+import { removeThinkTags } from "./utils/think-tags.js";
+import { isBoolean, isFunction, isNonEmptyString, isNumber, isObjectLike, isRecord, isString } from "./utils/type-guards.js";
 const log = createLogger("nodetool.agents.step-executor");
 const DEFAULT_MAX_ITERATIONS = 30;
-const JSON_FAILURE_ALERT_THRESHOLD = 3;
-const MAX_JSON_PARSE_FAILURES = 6;
 // ---------------------------------------------------------------------------
 // Shared prompt fragments (DRY)
 // ---------------------------------------------------------------------------
@@ -41,24 +42,32 @@ const PROMPT_TOOL_USE = `# Tool Use
 - Use tools only when they materially improve correctness or are required.
 - Avoid exploratory or repeated tool calls that are unlikely to change the outcome.
 - Before each tool call, emit a one-sentence rationale describing what you're doing and why.
+- Every tool's input schema includes a \`_message\` string field. Set it on EVERY call to a short (5-12 words), present-continuous status describing what you're doing — this is what the user sees while the tool runs. Examples: "Reading config.json", "Searching the web for AI trends", "Adding image generator node", "Calling http_request to POST /api/items". Be specific about the target (file, URL, query, node type) — generic strings like "Running tool" are useless to the user.
+
+## Memory Tools (progressive disclosure)
+- Shared agent memory holds results from prior steps and tasks, original inputs, and facts published by other agents.
+- Memory contents are NOT auto-included in your prompt. If you need upstream context, discover it on demand:
+  1. Call \`list_shared\` to see what's available (returns metadata only — keys, titles, kinds, byte sizes).
+  2. Call \`read_shared\` with the specific keys you actually need; it returns full values.
+  3. Call \`share_result\` to publish a value under \`shared:<key>\` so other agents can find it via \`list_shared\`.
+- Pull only what you need — don't fetch every entry by reflex.
 
 ## File Tools
-- Use \`read_file\` to read files. Do not use \`run_code\` with cat/head/tail.
+- Use \`read_file\` to read files.
 - Use \`edit_file\` for modifying existing files — it performs exact string replacement and only sends the diff. Prefer it over \`write_file\` for modifications.
 - Use \`write_file\` only for creating new files or complete rewrites.
-- Use \`glob\` to find files by name pattern (e.g. "**/*.ts"). Do not use \`run_code\` with find or ls.
-- Use \`grep\` to search file contents with regex. Do not use \`run_code\` with grep or rg.
-- Use \`run_code\` with language="bash" only for system commands and operations that require shell execution.
+- Use \`glob\` to find files by name pattern (e.g. "**/*.ts").
+- Use \`grep\` to search file contents with regex.
 
 ## Web Tools
 - Use \`browser\` to fetch and read the content of a web page. It returns cleaned, readable text extracted from HTML. This is the right choice for reading articles, documentation, or any page content.
 - Use \`http_request\` for API calls, POST/PUT/PATCH requests, or when you need raw response headers and body. Do not use it for reading page content — use \`browser\` instead.
 - Use \`download_file\` to save a file (binary or text) from a URL to disk.`;
-const PROMPT_FINISH_STEP = `# Completion (Tool Call Only)
-- When done, CALL \`finish_step\` exactly once with:
-  {"result": <result>}
-- Do NOT output the final result in assistant text — only use the tool.
-- Stop immediately after calling \`finish_step\`.`;
+const PROMPT_FINISH_STEP = `# Completion
+- When you have everything you need, call \`finish_step\` exactly once with
+  \`{"result": <result>}\` matching the declared schema.
+- Use \`read_shared\` to fetch any upstream values you still need before
+  finishing.`;
 // ---------------------------------------------------------------------------
 // Assembled system prompts
 // ---------------------------------------------------------------------------
@@ -124,7 +133,7 @@ function validateAndSanitizeSchema(schema, defaultDescription = "Result object")
         throw new Error("Schema is null or undefined");
     }
     let parsed = schema;
-    if (typeof parsed === "string") {
+    if (isString(parsed)) {
         parsed = JSON.parse(parsed);
     }
     if (typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -168,7 +177,7 @@ function validateAndSanitizeSchema(schema, defaultDescription = "Result object")
         if (Array.isArray(obj)) {
             return obj.map(cleanSchemaRecursive);
         }
-        if (obj !== null && typeof obj === "object") {
+        if (isObjectLike(obj)) {
             const cleaned = {};
             for (const [key, value] of Object.entries(obj)) {
                 cleaned[key] = cleanSchemaRecursive(value);
@@ -182,16 +191,17 @@ function validateAndSanitizeSchema(schema, defaultDescription = "Result object")
     }
     return cleanSchemaRecursive(result);
 }
-// ---------------------------------------------------------------------------
-// Think-tag removal
-// ---------------------------------------------------------------------------
-function removeThinkTags(text) {
-    if (!text)
-        return "";
-    return text
-        .replace(/<think>[\s\S]*?<\/(?:redacted_thinking|think)>/g, "")
-        .replace(/<think>[\s\S]*/g, "")
-        .trim();
+/**
+ * The authored schema, deep-copied and given a `type` when it omits one, so
+ * host validation reads exactly what the caller declared and nothing more.
+ */
+function normalizeDeclaredSchema(raw) {
+    if (!isRecord(raw))
+        return null;
+    const copy = JSON.parse(JSON.stringify(raw));
+    if (!("type" in copy) && "properties" in copy)
+        copy["type"] = "object";
+    return copy;
 }
 // ---------------------------------------------------------------------------
 // Tool result normalization
@@ -199,15 +209,13 @@ function removeThinkTags(text) {
 function normalizeToolResult(value) {
     if (value === null || value === undefined)
         return value;
-    if (typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean")
+    if (isString(value) || isNumber(value) || isBoolean(value))
         return value;
     if (Array.isArray(value))
         return value.map(normalizeToolResult);
-    if (typeof value === "object") {
+    if (isObjectLike(value)) {
         const obj = value;
-        if (typeof obj["toJSON"] === "function") {
+        if (isFunction(obj["toJSON"])) {
             return normalizeToolResult(obj.toJSON());
         }
         const result = {};
@@ -229,6 +237,12 @@ function renderTemplate(template, context) {
     }
     return result;
 }
+/**
+ * Rejections by the acceptance callback before the step gives up. Three is
+ * enough for the model to read the reason and correct course; more is a model
+ * that cannot satisfy the contract, and looping costs real money.
+ */
+export const MAX_REPAIR_ROUNDS = 3;
 export class StepExecutor {
     history = [];
     step;
@@ -238,22 +252,24 @@ export class StepExecutor {
     model;
     context;
     systemPrompt;
-    maxTokenLimit;
     maxIterations;
+    maxTokens;
     useFinishTask;
-    inConclusionStage = false;
+    signal;
     result = null;
     finishStepTool = null;
     resultSchema = null;
+    /** The schema as the caller wrote it — what host validation checks. */
+    declaredSchema = null;
     iterations = 0;
-    jsonParseFailures = 0;
     generationFailures = 0;
-    sources = [];
-    sourcesSet = new Set();
-    inputTokensTotal = 0;
-    outputTokensTotal = 0;
-    _controlEvents = [];
     threadId;
+    upstreamMemoryKeys;
+    acceptResult;
+    turnBudget;
+    repairRounds = 0;
+    /** Set when acceptance rejected the result once too often. */
+    acceptanceError = null;
     constructor(opts) {
         this.task = opts.task;
         this.step = opts.step;
@@ -261,26 +277,29 @@ export class StepExecutor {
         this.provider = opts.provider;
         this.model = opts.model;
         this.tools = opts.tools ? [...opts.tools] : [];
-        this.maxTokenLimit = opts.maxTokenLimit ?? DEFAULT_TOKEN_LIMIT;
         this.maxIterations = opts.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+        this.maxTokens = opts.maxTokens;
         this.useFinishTask = opts.useFinishTask ?? false;
         this.threadId = opts.threadId;
-        // Load and sanitize the output schema
+        this.upstreamMemoryKeys = opts.upstreamMemoryKeys ?? [];
+        this.signal = opts.signal;
+        this.acceptResult = opts.acceptResult;
+        this.turnBudget = opts.turnBudget;
         this.resultSchema = this.loadResultSchema();
-        // Setup finish_step tool if we have a schema
+        // Auto-attach memory tools so the step can list / read / write
+        // shared agent memory on demand. Skip any caller-supplied duplicates.
+        const existingNames = new Set(this.tools.map((t) => t.name));
+        for (const sharedTool of getSharedTools()) {
+            if (!existingNames.has(sharedTool.name)) {
+                this.tools.push(sharedTool);
+            }
+        }
         if (this.resultSchema) {
             this.finishStepTool = new FinishStepTool(this.resultSchema);
             this.tools.push(this.finishStepTool);
         }
-        // Build the system prompt from templates
         this.systemPrompt = this.buildSystemPrompt(opts.systemPrompt);
     }
-    /**
-     * Rough token estimate based on JSON serialized history length / 4.
-     */
-    estimateTokens() {
-        return Math.ceil(JSON.stringify(this.history).length / 4);
-    }
     /**
      * Parse and sanitize the declared output schema for this step.
      */
@@ -291,39 +310,51 @@ export class StepExecutor {
             ? "The task result"
             : "The step result";
         try {
-            const raw = typeof this.step.outputSchema === "string"
+            const raw = isString(this.step.outputSchema)
                 ? JSON.parse(this.step.outputSchema)
                 : this.step.outputSchema;
+            // Two schemas, on purpose. The sanitized one is what the provider is
+            // shown — it injects `additionalProperties: false` because strict
+            // structured-output modes demand it. The authored one is the contract,
+            // and it is what the host validates against: an author who wrote
+            // `properties: {}` meant "an object", not "an empty object", and
+            // enforcing a transport artifact would reject a result nobody forbade.
+            this.declaredSchema = normalizeDeclaredSchema(raw);
             return validateAndSanitizeSchema(raw, defaultDescription);
         }
         catch {
             // Fallback: permissive object schema
+            this.declaredSchema = null;
             return { type: "object", description: defaultDescription };
         }
     }
     /**
      * Build the system prompt for this step using templates.
+     *
+     * The default execution prompts encode the contract every step relies on
+     * (output discipline, finish_step protocol). They must always be present.
+     * A caller-supplied `userPrompt` is added as a preamble — never as a
+     * replacement — so domain context can be layered in without losing the
+     * execution discipline.
      */
-    buildSystemPrompt(customPrompt) {
+    buildSystemPrompt(userPrompt) {
         let basePrompt;
         const templateContext = {};
         if (this.resultSchema) {
             const schemaJson = JSON.stringify(this.resultSchema, null, 2);
             templateContext["output_schema_json"] = schemaJson;
-            if (this.useFinishTask) {
-                basePrompt = customPrompt ?? DEFAULT_FINISH_TASK_SYSTEM_PROMPT;
-                templateContext["step_content"] = this.step.instructions;
-            }
-            else {
-                basePrompt = customPrompt ?? DEFAULT_EXECUTION_SYSTEM_PROMPT;
-                templateContext["step_content"] = this.step.instructions;
-            }
+            basePrompt = this.useFinishTask
+                ? DEFAULT_FINISH_TASK_SYSTEM_PROMPT
+                : DEFAULT_EXECUTION_SYSTEM_PROMPT;
         }
         else {
-            basePrompt = customPrompt ?? DEFAULT_UNSTRUCTURED_SYSTEM_PROMPT;
-            templateContext["step_content"] = this.step.instructions;
+            basePrompt = DEFAULT_UNSTRUCTURED_SYSTEM_PROMPT;
         }
+        templateContext["step_content"] = this.step.instructions;
         let prompt = renderTemplate(basePrompt, templateContext);
+        if (userPrompt && userPrompt.trim().length > 0) {
+            prompt = `${userPrompt.trim()}\n\n---\n\n${prompt}`;
+        }
         prompt += `\n\nToday's date is ${new Date().toISOString().slice(0, 10)}`;
         return prompt;
     }
@@ -336,43 +367,41 @@ export class StepExecutor {
         if (this.resultSchema === null) {
             return [true, null, normalized];
         }
-        // Basic structural validation: check required keys from schema
-        if (this.resultSchema["type"] === "object" &&
-            typeof normalized === "object" &&
-            normalized !== null) {
-            const requiredKeys = this.resultSchema["required"];
-            if (Array.isArray(requiredKeys)) {
-                const obj = normalized;
-                for (const key of requiredKeys) {
-                    if (!(key in obj)) {
-                        return [false, `Missing required key: ${key}`, normalized];
-                    }
-                }
-            }
-        }
-        // Type check
-        const expectedType = this.resultSchema["type"];
-        if (expectedType === "string" && typeof normalized !== "string") {
-            return [false, `Expected string, got ${typeof normalized}`, normalized];
-        }
-        if (expectedType === "object" &&
-            (typeof normalized !== "object" || normalized === null)) {
-            return [false, `Expected object, got ${typeof normalized}`, normalized];
-        }
-        if (expectedType === "array" && !Array.isArray(normalized)) {
-            return [false, `Expected array, got ${typeof normalized}`, normalized];
+        // The whole declared schema, not its outline. Backends vary in how much of
+        // a tool-parameter schema they enforce — enums and unions are routinely
+        // dropped — so a contract holds only where the host checks it.
+        const violations = validateAgainstSchema(normalized, this.declaredSchema ?? this.resultSchema);
+        if (violations.length > 0) {
+            return [false, formatViolations(violations), normalized];
         }
         return [true, null, normalized];
     }
     /**
      * Persist the final result and mark the step as completed.
+     *
+     * Writes a `step_result` entry to {@link ProcessingContext.memory} under
+     * `step:<id>`. For finish-task steps it additionally writes the same value
+     * as a `task_result` under `task:<id>` so downstream tasks can discover it
+     * via memory.
      */
-    async storeCompletionResult(normalizedResult) {
+    storeCompletionResult(normalizedResult) {
         this.step.completed = true;
         this.step.endTime = Date.now();
-        await this.context.storeStepResult(this.step.id, normalizedResult);
+        this.context.memory.set({
+            key: memoryKeys.step(this.step.id),
+            kind: "step_result",
+            value: normalizedResult,
+            source: this.step.id,
+            title: this.step.instructions.slice(0, 80)
+        });
         if (this.useFinishTask) {
-            await this.context.storeStepResult(this.task.id, normalizedResult);
+            this.context.memory.set({
+                key: memoryKeys.task(this.task.id),
+                kind: "task_result",
+                value: normalizedResult,
+                source: this.task.id,
+                title: this.task.title
+            });
         }
         this.result = normalizedResult;
     }
@@ -401,166 +430,18 @@ export class StepExecutor {
         this.history.push({ role: "system", content: lines.join("\n") });
     }
     /**
-     * Attempt to parse and store a completion payload from the assistant message.
+     * For unstructured steps (no schema), accept the assistant's text content
+     * as the result when the model produces a final response without tool
+     * calls. Schema'd steps finalize exclusively through `finish_step`.
      */
     maybeFinalizeFromMessage(message) {
         if (!message)
             return [false, null];
-        // For unstructured steps (no schema), accept text content as the result
-        if (this.resultSchema === null) {
-            if (!message.toolCalls || message.toolCalls.length === 0) {
-                return [true, message.content];
-            }
-            return [false, null];
-        }
-        if (!message.content || typeof message.content !== "string")
-            return [false, null];
-        const parsed = extractJSON(message.content);
-        if (!parsed || typeof parsed !== "object")
+        if (this.resultSchema !== null)
             return [false, null];
-        const obj = parsed;
-        const status = obj["status"];
-        if (status !== undefined && status !== "completed")
-            return [false, null];
-        if (status === "completed" && !("result" in obj)) {
-            this.history.push({
-                role: "system",
-                content: 'Missing \'result\' in completion payload. Provide: {"status": "completed", "result": <your_result>}.'
-            });
-            return [false, null];
-        }
-        const candidateResult = "result" in obj ? obj["result"] : parsed;
-        const [isValid, errorDetail, normalizedResult] = this.validateResultPayload(candidateResult);
-        if (!isValid ||
-            normalizedResult === null ||
-            normalizedResult === undefined) {
-            this.history.push({
-                role: "system",
-                content: `Schema validation failed: ${errorDetail ?? "unknown error"}`
-            });
+        if (message.toolCalls && message.toolCalls.length > 0)
             return [false, null];
-        }
-        return [true, normalizedResult];
-    }
-    /**
-     * Track JSON parsing/validation failures and enforce a hard stop.
-     */
-    registerJsonFailure(detail) {
-        this.jsonParseFailures++;
-        if (this.jsonParseFailures === JSON_FAILURE_ALERT_THRESHOLD) {
-            const reminder = "SYSTEM: Do NOT output completion JSON in assistant text. You MUST call " +
-                "`finish_step` with {'result': <result>} matching the schema, with no extra keys.";
-            this.history.push({ role: "system", content: reminder });
-            this.inConclusionStage = true;
-        }
-        if (this.jsonParseFailures >= MAX_JSON_PARSE_FAILURES) {
-            throw new Error(`Exceeded maximum JSON parse attempts (${MAX_JSON_PARSE_FAILURES}) for step ${this.step.id}. Last failure: ${detail}`);
-        }
-    }
-    /**
-     * Filter tool calls based on whether we're in the conclusion stage.
-     */
-    filterToolCallsForCurrentStage(toolCalls) {
-        if (!this.inConclusionStage)
-            return toolCalls;
-        return toolCalls.filter((tc) => tc.name === "finish_step");
-    }
-    /**
-     * Get the tools available for the current stage.
-     */
-    getCurrentTools() {
-        if (this.inConclusionStage) {
-            return this.finishStepTool ? [this.finishStepTool] : [];
-        }
-        return [...this.tools];
-    }
-    /**
-     * Transition to conclusion stage: restrict tools to finish_step only.
-     */
-    enterConclusionStage() {
-        if (this.inConclusionStage)
-            return;
-        this.inConclusionStage = true;
-        const hasFinishTool = !!this.finishStepTool;
-        const message = hasFinishTool
-            ? `SYSTEM: The conversation history is approaching the token limit (${this.maxTokenLimit} tokens).\n` +
-                "ENTERING CONCLUSION STAGE: You MUST now synthesize all gathered information and finalize the step.\n" +
-                "Only the `finish_step` tool is available. Call `finish_step` exactly once with:\n" +
-                '{"result": <result>} where <result> matches the declared schema.'
-            : `SYSTEM: The conversation history is approaching the token limit (${this.maxTokenLimit} tokens).\n` +
-                "ENTERING CONCLUSION STAGE: You MUST now synthesize all gathered information and finalize the step.\n" +
-                "Tools are not available. Provide the final answer concisely.";
-        // Prevent duplicate conclusion messages
-        if (!this.history.some((m) => m.role === "system" &&
-            typeof m.content === "string" &&
-            m.content.includes("ENTERING CONCLUSION STAGE"))) {
-            this.history.push({ role: "system", content: message });
-        }
-    }
-    /**
-     * Summarize older messages into a concise, factual summary.
-     */
-    async summarizeMessages(messages) {
-        const joined = messages
-            .filter((m) => m.content)
-            .map((m) => `${(m.role ?? "").toUpperCase()}: ${m.content}`)
-            .join("\n");
-        const prompt = "Summarize the following conversation concisely while preserving key facts, " +
-            "decisions, and results:\n\n" +
-            joined;
-        try {
-            const msg = await this.provider.generateMessageTraced({
-                messages: [
-                    { role: "system", content: "Summarize previous context." },
-                    { role: "user", content: prompt }
-                ],
-                model: this.model,
-                tools: [],
-                maxTokens: 512
-            });
-            return String(msg.content ?? "").trim();
-        }
-        catch {
-            return "Summary unavailable due to compression error.";
-        }
-    }
-    /**
-     * Trim or summarize older messages to stay within token limits.
-     */
-    async trimHistoryIfNeeded() {
-        const tokenCount = this.estimateTokens();
-        if (tokenCount < this.maxTokenLimit * 0.9)
-            return;
-        // Preserve the last 6 messages
-        const preserved = [];
-        for (let i = this.history.length - 1; i >= 0 && preserved.length < 6; i--) {
-            preserved.unshift(this.history[i]);
-        }
-        const earlierCount = this.history.length - preserved.length;
-        const earlierContext = earlierCount > 1 ? this.history.slice(1, earlierCount) : [];
-        if (earlierContext.length > 0) {
-            const summary = await this.summarizeMessages(earlierContext);
-            const systemPrompt = this.history[0];
-            this.history = [];
-            if (systemPrompt) {
-                this.history.push(systemPrompt);
-            }
-            this.history.push({
-                role: "system",
-                content: `Summary of previous context:\n${summary}`
-            });
-        }
-        else {
-            this.history = this.history.slice(0, 1);
-        }
-        this.history.push(...preserved);
-        // Trim further if still over budget
-        let currentTokens = this.estimateTokens();
-        while (currentTokens > this.maxTokenLimit * 0.85 &&
-            this.history.length > 2) {
-            this.history.splice(2, 1);
-            currentTokens = this.estimateTokens();
-        }
+        return [true, message.content];
     }
     /**
      * Serialize a tool result for history, with truncation.
@@ -572,11 +453,7 @@ export class StepExecutor {
         try {
             const normalized = normalizeToolResult(toolResult);
             const serialized = JSON.stringify(normalized);
-            if (serialized.length > MAX_TOOL_RESULT_CHARS) {
-                return (serialized.slice(0, MAX_TOOL_RESULT_CHARS) +
-                    "... [truncated to maintain context size]");
-            }
-            return serialized;
+            return truncateToolResult(serialized);
         }
         catch (e) {
             return JSON.stringify({
@@ -586,164 +463,61 @@ export class StepExecutor {
         }
     }
     /**
-     * Save base64 encoded binary data (images, audio) from tool results to workspace files.
-     * Mirrors Python's StepExecutor._handle_binary_artifact().
-     */
-    async handleBinaryArtifact(toolResult) {
-        if (typeof toolResult !== "object" ||
-            toolResult === null ||
-            Array.isArray(toolResult)) {
-            return toolResult;
-        }
-        const result = { ...toolResult };
-        const workspaceDir = this.context.workspaceDir;
-        if (!workspaceDir)
-            return result;
-        for (const field of ["image", "audio"]) {
-            const value = result[field];
-            if (typeof value !== "string")
-                continue;
-            const dataUriMatch = value.match(/^data:([^;]+);base64,(.+)$/s);
-            if (!dataUriMatch)
-                continue;
-            const [, mimeType, base64Data] = dataUriMatch;
-            const ext = mimeType.split("/")[1] ?? "bin";
-            const hash = createHash("sha256")
-                .update(base64Data)
-                .digest("hex")
-                .slice(0, 16);
-            const filename = `artifact_${hash}.${ext}`;
-            const artifactsDir = path.join(workspaceDir, "artifacts");
-            await fs.mkdir(artifactsDir, { recursive: true });
-            const filepath = path.join(artifactsDir, filename);
-            await fs.writeFile(filepath, Buffer.from(base64Data, "base64"));
-            result[field] = filepath;
-            if (!this.sourcesSet.has(filepath)) {
-                this.sources.push(filepath);
-                this.sourcesSet.add(filepath);
-            }
-        }
-        return result;
-    }
-    /**
-     * Persist important sandbox outputs (downloads, screenshots, generated artifacts)
-     * as assets so they survive ephemeral workspace/container cleanup.
-     */
-    async capturePersistentSandboxOutputs(toolName, toolArgs, toolResult) {
-        if (typeof toolResult !== "object" ||
-            toolResult === null ||
-            Array.isArray(toolResult)) {
-            return toolResult;
-        }
-        const result = { ...toolResult };
-        if (result.success === false) {
-            return result;
-        }
-        const candidates = [];
-        const candidateKeys = new Set();
-        const isExternalUri = (value) => {
-            const lower = value.toLowerCase();
-            return (lower.startsWith("http://") ||
-                lower.startsWith("https://") ||
-                lower.startsWith("asset://") ||
-                lower.startsWith("memory://") ||
-                lower.startsWith("s3://") ||
-                lower.startsWith("file://"));
-        };
-        const maybeAdd = (label, value) => {
-            if (typeof value === "string" &&
-                value.trim().length > 0 &&
-                !value.startsWith("data:") &&
-                !isExternalUri(value)) {
-                const key = `${label}:${value}`;
-                if (!candidateKeys.has(key)) {
-                    candidates.push({ label, path: value });
-                    candidateKeys.add(key);
-                }
-            }
-        };
-        maybeAdd("output_file", result.output_file);
-        if (result.success === true) {
-            maybeAdd("output_file", toolArgs?.["output_file"]);
-        }
-        maybeAdd("image", result.image);
-        maybeAdd("audio", result.audio);
-        if (candidates.length === 0) {
-            return result;
-        }
-        const refs = {};
-        for (const candidate of candidates) {
-            try {
-                const ref = await this.context.sandboxToAsset(candidate.path);
-                refs[candidate.label] = ref;
-                const uri = ref.uri;
-                if (typeof uri === "string" && uri && !this.sourcesSet.has(uri)) {
-                    this.sources.push(uri);
-                    this.sourcesSet.add(uri);
-                }
-            }
-            catch (error) {
-                log.warn("Failed to persist sandbox output as asset", {
-                    stepId: this.step.id,
-                    toolName,
-                    path: candidate.path,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-        if (Object.keys(refs).length > 0) {
-            const existing = result.asset_refs;
-            if (typeof existing === "object" &&
-                existing !== null &&
-                !Array.isArray(existing)) {
-                result.asset_refs = { ...existing, ...refs };
-            }
-            else {
-                result.asset_refs = refs;
-            }
-        }
-        return result;
-    }
-    /**
-     * Track URLs from browser tool navigation results.
-     * Mirrors Python's _process_special_tool_side_effects().
-     */
-    trackToolSideEffects(toolName, result) {
-        if (toolName === "browser" &&
-            typeof result === "object" &&
-            result !== null) {
-            const url = result.url;
-            if (typeof url === "string" && url && !this.sourcesSet.has(url)) {
-                this.sources.push(url);
-                this.sourcesSet.add(url);
-            }
-        }
-    }
-    /**
-     * Generate a user-facing message for a tool call.
+     * Generate a user-facing message for a tool call. Prefers the LLM-authored
+     * `_message` arg; falls back to the tool's parameter-aware template.
      */
     generateToolCallMessage(toolCall) {
+        const llm = Tool.extractMessage(toolCall.args);
+        if (llm)
+            return llm;
         for (const tool of this.tools) {
             if (tool.name === toolCall.name) {
-                return tool.userMessage(toolCall.args);
+                return tool.userMessage(Tool.stripMessage(toolCall.args));
             }
         }
         return `Running ${toolCall.name}`;
     }
     /**
-     * Build the initial user message with instructions and dependency results.
+     * Build the initial user message.
+     *
+     * Memory contents are NOT auto-included — callers fetch on demand via the
+     * `list_shared` / `read_shared` tools (progressive disclosure; tool usage
+     * is documented in the default system prompt).
+     *
+     * The only memory information the user message carries is a short list of
+     * **specific** upstream keys the planner declared as relevant to this step:
+     *
+     *   - `step:<id>` for every entry of `step.dependsOn` (intra-task deps).
+     *   - any caller-supplied {@link StepExecutorOptions.upstreamMemoryKeys}
+     *     (typically `task:<id>` entries from the parent task's `dependsOn`).
+     *
+     * Only keys that actually exist in `context.memory` are listed. The LLM
+     * is expected to call `read_shared` with whichever subset it needs.
      */
-    async buildUserMessage() {
+    buildUserMessage() {
         const parts = [this.step.instructions];
-        if (this.step.dependsOn.length > 0) {
-            for (const depId of this.step.dependsOn) {
-                const depResult = await this.context.loadStepResult(depId);
-                if (depResult !== undefined && depResult !== null) {
-                    parts.push(`**Result from Task ${depId}:**\n${JSON.stringify(depResult, null, 2)}\n`);
-                }
+        const declared = [
+            ...this.step.dependsOn.map((id) => memoryKeys.step(id)),
+            ...this.upstreamMemoryKeys
+        ];
+        const seen = new Set();
+        const hints = [];
+        for (const key of declared) {
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const entry = this.context.memory.get(key);
+            if (!entry)
+                continue;
+            hints.push({ key: entry.key, title: entry.title });
+        }
+        if (hints.length > 0) {
+            parts.push("");
+            parts.push("# Required upstream memory (call `read_shared` with these keys):");
+            for (const hint of hints) {
+                parts.push(`- ${hint.key}${hint.title ? ` — ${hint.title}` : ""}`);
             }
         }
-        parts.push("Please perform the step based on the provided context, instructions, and upstream task results.");
         return parts.join("\n");
     }
     /**
@@ -766,12 +540,15 @@ export class StepExecutor {
             stepId: this.step.id,
             instructions: this.step.instructions.slice(0, 60)
         });
-        // Initialize history with system prompt
+        // Stamp the loop's own selection so a tool that launches another harness
+        // inherits this agent's provider/model when the call doesn't name one.
+        this.context.set(ACTIVE_MODEL_CONTEXT_KEY, {
+            provider: this.provider.provider,
+            model: this.model
+        });
         this.history.push({ role: "system", content: this.systemPrompt });
-        // Build user message with instructions and dependency results
-        const userContent = await this.buildUserMessage();
+        const userContent = this.buildUserMessage();
         this.history.push({ role: "user", content: userContent });
-        // Yield task update: step started
         this.step.startTime = Date.now();
         yield {
             type: "task_update",
@@ -780,280 +557,231 @@ export class StepExecutor {
             step: { id: this.step.id, instructions: this.step.instructions },
             event: TaskUpdateEvent.StepStarted
         };
-        rejectAgenticProvider(this.provider, "StepExecutor.execute");
-        // --- Standard multi-iteration loop ---
-        while (!this.step.completed && this.iterations < this.maxIterations) {
-            this.iterations++;
-            // Check token budget
-            const tokenCount = this.estimateTokens();
-            if (tokenCount > this.maxTokenLimit && !this.inConclusionStage) {
-                this.enterConclusionStage();
-                yield {
-                    type: "task_update",
-                    node_id: this.step.id,
-                    task: { id: this.task.id, title: this.task.title },
-                    step: { id: this.step.id, instructions: this.step.instructions },
-                    event: TaskUpdateEvent.EnteredConclusionStage
-                };
-            }
-            // Trim history if needed
-            await this.trimHistoryIfNeeded();
-            // Determine available tools
-            const currentTools = this.getCurrentTools();
-            const providerTools = currentTools.map((t) => t.toProviderTool());
-            // Yield log update
-            yield {
-                type: "log_update",
+        // The provider drives the tool loop, so backends that run their own agent
+        // loop (e.g. the Claude Agent SDK) work. Each tool carries its own `execute`
+        // closure — running the tool, persisting artifacts, tracking sources — and
+        // buffers the completion events; the stream consumer surfaces chunks and
+        // tool-call updates.
+        //
+        // `finish_step` is only *conditionally* terminal: it ends the loop when it
+        // captures a schema-valid result, but on an invalid result it returns the
+        // error so the model can retry within the iteration budget. The static
+        // `terminal` flag can't express that, so the AbortController stops the loop
+        // on a valid completion instead.
+        const abort = new AbortController();
+        // External cancellation (user pressed Stop) fires the same controller.
+        const unlinkAbort = linkAbort(abort, this.signal);
+        const ui = createUiEventBuffer();
+        let lastAssistant = null;
+        // Captures a real exception thrown by the provider loop (401, rate limit,
+        // network, tool-schema error) so the failure path reports the actual cause
+        // instead of misattributing it to iteration exhaustion.
+        let generationError = null;
+        const emitCompletion = (normalizedResult) => {
+            this.storeCompletionResult(normalizedResult);
+            ui.push({
+                type: "task_update",
                 node_id: this.step.id,
-                node_name: `Step: ${this.step.id}`,
-                content: !this.inConclusionStage
-                    ? "Generating next steps..."
-                    : "Synthesizing final answer...",
-                severity: "info"
-            };
-            // Track input tokens
-            this.inputTokensTotal += this.estimateTokens();
-            // Call LLM
-            let content = "";
-            const toolCalls = [];
-            let message;
-            try {
-                const stream = this.provider.generateMessagesTraced({
-                    messages: [...this.history],
-                    model: this.model,
-                    tools: providerTools.length > 0 ? providerTools : undefined,
-                    threadId: this.threadId
-                });
-                for await (const item of stream) {
-                    if (isChunk(item)) {
-                        content += item.content ?? "";
-                        yield {
-                            type: "chunk",
-                            node_id: this.step.id,
-                            content: item.content,
-                            done: false
-                        };
-                    }
-                    if (isToolCall(item)) {
-                        log.debug("Tool call", { name: item.name });
-                        toolCalls.push(item);
+                task: { id: this.task.id, title: this.task.title },
+                step: { id: this.step.id, instructions: this.step.instructions },
+                event: TaskUpdateEvent.StepCompleted
+            });
+            ui.push({
+                type: "step_result",
+                step: { id: this.step.id, instructions: this.step.instructions },
+                result: normalizedResult,
+                is_task_result: this.useFinishTask
+            });
+        };
+        // finish_step is the only completion path for schema'd steps.
+        const finishStepExecute = async (args) => {
+            const rawResult = args?.["result"];
+            // Fall back to the whole args object when `result` is absent, but strip
+            // the injected `_message` protocol field so it can't leak into the result.
+            let resultPayload = rawResult !== undefined && rawResult !== null
+                ? rawResult
+                : Tool.stripMessage(args ?? {});
+            // Array-output steps are wrapped as `{ result: { items: <array> } }` for
+            // the tool parameter schema (OpenAI requires an object top-level). Unwrap
+            // `{ items: [...] }` back to the array before validating against the
+            // original array schema. Gate on the declared schema type so a legitimate
+            // object result with an `items` key is not misinterpreted.
+            if (this.resultSchema?.["type"] === "array" &&
+                isRecord(resultPayload) &&
+                Array.isArray(resultPayload["items"])) {
+                resultPayload = resultPayload["items"];
+            }
+            if (resultPayload === undefined || resultPayload === null) {
+                return '{"error": "Missing result in finish_step call"}';
+            }
+            const [isValid, errorDetail, normalizedResult] = this.validateResultPayload(resultPayload);
+            if (isValid &&
+                normalizedResult !== null &&
+                normalizedResult !== undefined) {
+                if (this.acceptResult) {
+                    const acceptance = await this.acceptResult(normalizedResult);
+                    if (!acceptance.accepted) {
+                        this.repairRounds++;
+                        if (this.repairRounds >= MAX_REPAIR_ROUNDS) {
+                            // Out of rounds. Stop the loop rather than pay for another
+                            // attempt at a contract this model is not meeting.
+                            this.acceptanceError = acceptance.reason;
+                            abort.abort();
+                            return JSON.stringify({
+                                error: `Result rejected: ${acceptance.reason}`
+                            });
+                        }
+                        return JSON.stringify({
+                            error: `Result rejected: ${acceptance.reason}. Call finish_step again with a corrected result.`
+                        });
                     }
                 }
-                // Clean think tags from content
-                content = removeThinkTags(content);
-                message = { role: "assistant", content: content ?? "" };
-                if (toolCalls.length > 0) {
-                    message.toolCalls = toolCalls;
-                }
-                // Estimate output tokens
-                this.outputTokensTotal += Math.ceil((content.length + JSON.stringify(toolCalls).length) / 4);
+                emitCompletion(normalizedResult);
+                abort.abort();
+                return '{"status": "completed"}';
+            }
+            return JSON.stringify({
+                error: `Result validation failed: ${errorDetail ?? "Result failed schema validation."}`
+            });
+        };
+        const runTool = async (tool, args, toolCallId) => {
+            let toolResult;
+            try {
+                toolResult = await Tool.executeTool(tool, this.context, args, {
+                    toolCallId
+                });
             }
             catch (e) {
-                log.error("Step failed", { stepId: this.step.id, error: String(e) });
-                this.generationFailures++;
-                if (this.generationFailures >= 3)
-                    throw e;
-                message = {
-                    role: "assistant",
-                    content: `Error generating message: ${e}`
-                };
+                return JSON.stringify({ error: String(e) });
+            }
+            // A view-image-style result carries pixels the model asked for. Forward
+            // them as a user image message (generateLoop splits a MessageContent[]
+            // result into a light tool note + the image); the note stays in history.
+            const injected = extractInjectableImages(toolResult);
+            if (injected) {
+                toolResult = stripImagePayload(toolResult);
+            }
+            const resultStr = this.serializeToolResultForHistory(toolResult, tool.name);
+            if (injected) {
+                return [{ type: "text", text: resultStr }, ...injected.images];
             }
-            // Filter tool calls for current stage
-            const filteredToolCalls = message.toolCalls
-                ? this.filterToolCallsForCurrentStage(message.toolCalls)
-                : [];
-            message.toolCalls =
-                filteredToolCalls.length > 0 ? filteredToolCalls : undefined;
-            // Add assistant message to history
-            this.history.push(message);
-            // Process tool calls
-            if (filteredToolCalls.length > 0) {
-                // Check for finish_step tool call first
-                const finishStepCall = filteredToolCalls.find((tc) => tc.name === "finish_step");
-                if (finishStepCall && this.finishStepTool) {
-                    // Yield tool call update
+            return resultStr;
+        };
+        const providerTools = this.tools.map((tool) => {
+            if (tool === this.finishStepTool) {
+                return { ...tool.toProviderTool(), execute: finishStepExecute };
+            }
+            return {
+                ...tool.toProviderTool(),
+                execute: (args, toolCallId) => runTool(tool, args, toolCallId)
+            };
+        });
+        try {
+            const stream = this.provider.generateLoop({
+                messages: this.history,
+                model: this.model,
+                tools: providerTools.length > 0 ? providerTools : undefined,
+                threadId: this.threadId,
+                maxIterations: this.maxIterations,
+                maxTokens: this.maxTokens,
+                sequentialTools: true,
+                turnBudget: this.turnBudget,
+                resolveMedia: mediaResolverFor(this.context),
+                signal: abort.signal
+            });
+            for await (const item of stream) {
+                if (isToolCall(item)) {
                     yield {
                         type: "tool_call_update",
                         node_id: this.step.id,
-                        name: finishStepCall.name,
-                        args: finishStepCall.args,
-                        message: this.generateToolCallMessage(finishStepCall)
+                        tool_call_id: item.id,
+                        name: item.name,
+                        args: item.args,
+                        message: this.generateToolCallMessage(item)
                     };
-                    // Extract and validate result
-                    const resultPayload = finishStepCall.args?.["result"] ?? finishStepCall.args;
-                    if (resultPayload !== undefined && resultPayload !== null) {
-                        const [isValid, errorDetail, normalizedResult] = this.validateResultPayload(resultPayload);
-                        if (isValid &&
-                            normalizedResult !== null &&
-                            normalizedResult !== undefined) {
-                            // Add tool result to history
-                            this.history.push({
-                                role: "tool",
-                                toolCallId: finishStepCall.id,
-                                content: '{"status": "completed"}'
-                            });
-                            await this.storeCompletionResult(normalizedResult);
-                            log.debug("Step completed", { stepId: this.step.id });
-                            yield {
-                                type: "task_update",
-                                node_id: this.step.id,
-                                task: { id: this.task.id, title: this.task.title },
-                                step: {
-                                    id: this.step.id,
-                                    instructions: this.step.instructions
-                                },
-                                event: TaskUpdateEvent.StepCompleted
-                            };
-                            yield {
-                                type: "step_result",
-                                step: {
-                                    id: this.step.id,
-                                    instructions: this.step.instructions
-                                },
-                                result: normalizedResult,
-                                is_task_result: this.useFinishTask
-                            };
-                            break;
-                        }
-                        else {
-                            // Invalid result - add feedback and continue loop
-                            this.history.push({
-                                role: "tool",
-                                toolCallId: finishStepCall.id,
-                                content: JSON.stringify({
-                                    error: `Result validation failed: ${errorDetail}`
-                                })
-                            });
-                            this.appendCompletionFeedback(errorDetail ?? "Result failed schema validation.", resultPayload);
-                        }
-                    }
-                    else {
-                        this.history.push({
-                            role: "tool",
-                            toolCallId: finishStepCall.id,
-                            content: '{"error": "Missing result in finish_step call"}'
-                        });
-                    }
+                    yield* ui.drain();
+                    continue;
                 }
-                else {
-                    // Process non-finish_step tool calls
-                    const regularToolCalls = filteredToolCalls.filter((tc) => tc.name !== "finish_step");
-                    // Yield tool call updates
-                    for (const tc of regularToolCalls) {
+                if (isChunk(item)) {
+                    if (isNonEmptyString(item.content)) {
                         yield {
-                            type: "tool_call_update",
+                            type: "chunk",
                             node_id: this.step.id,
-                            name: tc.name,
-                            args: tc.args,
-                            message: this.generateToolCallMessage(tc)
+                            content: item.content,
+                            done: false
                         };
                     }
-                    const toolNamesStr = regularToolCalls.map((tc) => tc.name).join(", ");
-                    // Standard execution path: run tools ourselves and add results to history
-                    yield {
-                        type: "log_update",
-                        node_id: this.step.id,
-                        node_name: `Step: ${this.step.id}`,
-                        content: `Executing tools: ${toolNamesStr}...`,
-                        severity: "info"
-                    };
-                    // Execute tool calls in parallel
-                    const toolResults = await Promise.allSettled(regularToolCalls.map(async (tc) => {
-                        const tool = this.tools.find((t) => t.name === tc.name);
-                        if (!tool)
-                            return { error: `Unknown tool: ${tc.name}` };
-                        // Intercept ControlNodeTool: create event instead of calling process()
-                        if (tool instanceof ControlNodeTool) {
-                            const event = tool.createControlEvent(tc.args ?? {});
-                            this._controlEvents.push({
-                                targetNodeId: tool.targetNodeId,
-                                event
-                            });
-                            return tool.userMessage(tc.args ?? {});
-                        }
-                        try {
-                            const result = await tool.process(this.context, tc.args ?? {});
-                            return result;
-                        }
-                        catch (e) {
-                            return { error: String(e) };
-                        }
-                    }));
-                    // Add tool results to history
-                    for (let i = 0; i < regularToolCalls.length; i++) {
-                        const tc = regularToolCalls[i];
-                        const settledResult = toolResults[i];
-                        let toolResult;
-                        if (settledResult.status === "fulfilled") {
-                            toolResult = settledResult.value;
-                        }
-                        else {
-                            toolResult = {
-                                error: `Tool execution failed: ${settledResult.reason}`
-                            };
-                        }
-                        // Save base64 binary artifacts (images, audio) to workspace files
-                        toolResult = await this.handleBinaryArtifact(toolResult);
-                        toolResult = await this.capturePersistentSandboxOutputs(tc.name, tc.args, toolResult);
-                        // Track browser URLs for source lineage (from args and results)
-                        if (tc.name === "browser" && tc.args?.["url"]) {
-                            const url = String(tc.args["url"]);
-                            if (!this.sourcesSet.has(url)) {
-                                this.sources.push(url);
-                                this.sourcesSet.add(url);
-                            }
-                        }
-                        this.trackToolSideEffects(tc.name, toolResult);
-                        const resultStr = this.serializeToolResultForHistory(toolResult, tc.name);
-                        this.history.push({
-                            role: "tool",
-                            toolCallId: tc.id,
-                            content: resultStr
-                        });
+                    yield* ui.drain();
+                    continue;
+                }
+                if ("type" in item && item.type === "message") {
+                    const m = item.message;
+                    if (m && m.role === "assistant") {
+                        // One assistant message per provider turn — this is the iteration
+                        // count the failure path reports.
+                        this.iterations++;
+                        lastAssistant = isString(m.content)
+                            ? { ...m, content: removeThinkTags(m.content) }
+                            : m;
                     }
-                    yield {
-                        type: "log_update",
-                        node_id: this.step.id,
-                        node_name: `Step: ${this.step.id}`,
-                        content: `Completed tool execution: ${toolNamesStr}.`,
-                        severity: "info"
-                    };
                 }
+                yield* ui.drain();
             }
-            // Try to finalize from message content (inline JSON completion).
-            if (!this.step.completed) {
-                const [completed, normalizedResult] = this.maybeFinalizeFromMessage(message);
-                if (completed &&
-                    normalizedResult !== null &&
-                    normalizedResult !== undefined) {
-                    await this.storeCompletionResult(normalizedResult);
-                    yield {
-                        type: "task_update",
-                        node_id: this.step.id,
-                        task: { id: this.task.id, title: this.task.title },
-                        step: { id: this.step.id, instructions: this.step.instructions },
-                        event: TaskUpdateEvent.StepCompleted
-                    };
-                    yield {
-                        type: "step_result",
-                        step: { id: this.step.id, instructions: this.step.instructions },
-                        result: normalizedResult,
-                        is_task_result: this.useFinishTask
-                    };
-                    break;
-                }
+        }
+        catch (e) {
+            generationError = e instanceof Error ? e : new Error(String(e));
+            log.error("Step generation failed", {
+                stepId: this.step.id,
+                error: generationError.message
+            });
+        }
+        finally {
+            unlinkAbort();
+        }
+        yield* ui.drain();
+        // Unstructured steps finalize from the final assistant text (no finish_step).
+        if (!this.step.completed) {
+            const [done, normalizedResult] = this.maybeFinalizeFromMessage(lastAssistant);
+            if (done && normalizedResult !== null && normalizedResult !== undefined) {
+                emitCompletion(normalizedResult);
+                yield* ui.drain();
             }
         }
-        // If we exhausted iterations without completing, yield a failure event
-        // and a step_result so downstream steps see an explicit error rather than undefined.
+        // If we didn't complete, yield a failure event and a step_result so
+        // downstream steps see an explicit error rather than undefined. Each
+        // terminal state gets its own sentence: the provider threw, the iteration
+        // budget really ran out, or the model ended its turn without calling
+        // `finish_step`. Reporting them all as "exceeded N iterations" pointed the
+        // reader at a budget that a two-turn step never came near.
+        //
+        // A failed step is terminal but NOT completed: `failed`/`error` are set and
+        // `completed` stays false, so a scheduler cannot treat the failure as a
+        // satisfied dependency. The protocol-level `error` field carries the same
+        // cause, so a consumer never has to sniff the result payload for it.
         if (!this.step.completed) {
-            this.step.completed = true;
             this.step.endTime = Date.now();
-            const errorResult = {
-                error: `Step failed: exceeded ${this.maxIterations} iterations without completion`
-            };
+            const message = this.acceptanceError
+                ? `Step failed: result rejected after ${MAX_REPAIR_ROUNDS} attempts — ${this.acceptanceError}`
+                : generationError
+                    ? `Step failed: ${generationError.message}`
+                    : this.iterations >= this.maxIterations
+                        ? `Step failed: exceeded ${this.maxIterations} iterations without completion`
+                        : this.resultSchema !== null
+                            ? `Step failed: ended after ${this.iterations} model turn(s) ` +
+                                `without calling finish_step.${lastProseHint(lastAssistant)}`
+                            : `Step failed: ended after ${this.iterations} model turn(s) ` +
+                                `with no final message to use as the result.`;
+            this.step.failed = true;
+            this.step.error = message;
+            const errorResult = { error: message };
             this.result = errorResult;
-            await this.context.storeStepResult(this.step.id, errorResult);
+            this.context.memory.set({
+                key: memoryKeys.step(this.step.id),
+                kind: "step_result",
+                value: errorResult,
+                source: this.step.id,
+                title: `Failed: ${this.step.instructions.slice(0, 60)}`
+            });
             yield {
                 type: "task_update",
                 node_id: this.step.id,
@@ -1065,6 +793,7 @@ export class StepExecutor {
                 type: "step_result",
                 step: { id: this.step.id, instructions: this.step.instructions },
                 result: errorResult,
+                error: message,
                 is_task_result: this.useFinishTask
             };
         }
@@ -1075,40 +804,5 @@ export class StepExecutor {
     getResult() {
         return this.result;
     }
-    /**
-     * Get tracked sources (e.g. browser URLs).
-     */
-    getSources() {
-        return [...this.sources];
-    }
-    /**
-     * Get token usage statistics.
-     */
-    getTokenUsage() {
-        return {
-            inputTokensTotal: this.inputTokensTotal,
-            outputTokensTotal: this.outputTokensTotal
-        };
-    }
-    /**
-     * Get control events emitted during execution (from ControlNodeTool calls).
-     * The caller (workflow actor/runner) is responsible for dispatching these.
-     */
-    getControlEvents() {
-        return [...this._controlEvents];
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers to discriminate ProviderStreamItem union members
-// ---------------------------------------------------------------------------
-function isChunk(item) {
-    return ("type" in item &&
-        item["type"] === "chunk" &&
-        typeof item["content"] === "string");
-}
-function isToolCall(item) {
-    return ("name" in item &&
-        typeof item["name"] === "string" &&
-        "id" in item);
 }
 //# sourceMappingURL=step-executor.js.map