@travisennis/acai 0.0.6 → 0.0.8

package/dist/utils/yaml.js

@@ -0,0 +1,207 @@
+export function parseYaml(input) {
+    const lines = input.split("\n");
+    const result = {};
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith("#")) {
+            i++;
+            continue;
+        }
+        // Check for key-value pair
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1) {
+            i++;
+            continue;
+        }
+        const indent = getIndent(line);
+        const key = line.slice(0, colonIndex).trim();
+        const afterColon = line.slice(colonIndex + 1).trim();
+        if (afterColon) {
+            // Inline value
+            result[key] = parseValue(afterColon);
+            i++;
+        }
+        else {
+            // Check next line for nested content
+            i++;
+            if (i < lines.length) {
+                const nextLine = lines[i];
+                const nextIndent = getIndent(nextLine);
+                const nextTrimmed = nextLine.trim();
+                if (nextTrimmed.startsWith("-")) {
+                    // Array
+                    const [arr, newIndex] = parseArray(lines, i, nextIndent);
+                    result[key] = arr;
+                    i = newIndex;
+                }
+                else if (nextIndent > indent && nextTrimmed.includes(":")) {
+                    // Nested object
+                    const [obj, newIndex] = parseObject(lines, i, nextIndent);
+                    result[key] = obj;
+                    i = newIndex;
+                }
+                else {
+                    result[key] = null;
+                }
+            }
+            else {
+                result[key] = null;
+            }
+        }
+    }
+    return result;
+}
+function parseObject(lines, start, baseIndent) {
+    const obj = {};
+    let i = start;
+    while (i < lines.length) {
+        const line = lines[i];
+        const indent = getIndent(line);
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            i++;
+            continue;
+        }
+        if (indent < baseIndent) {
+            break;
+        }
+        if (indent === baseIndent) {
+            const colonIndex = line.indexOf(":");
+            if (colonIndex === -1) {
+                i++;
+                continue;
+            }
+            const key = line.slice(0, colonIndex).trim();
+            const afterColon = line.slice(colonIndex + 1).trim();
+            if (afterColon) {
+                obj[key] = parseValue(afterColon);
+                i++;
+            }
+            else {
+                i++;
+                if (i < lines.length) {
+                    const nextLine = lines[i];
+                    const nextIndent = getIndent(nextLine);
+                    const nextTrimmed = nextLine.trim();
+                    if (nextTrimmed.startsWith("-")) {
+                        const [arr, newIndex] = parseArray(lines, i, nextIndent);
+                        obj[key] = arr;
+                        i = newIndex;
+                    }
+                    else if (nextIndent > indent && nextTrimmed.includes(":")) {
+                        const [nested, newIndex] = parseObject(lines, i, nextIndent);
+                        obj[key] = nested;
+                        i = newIndex;
+                    }
+                    else {
+                        obj[key] = null;
+                    }
+                }
+                else {
+                    obj[key] = null;
+                }
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return [obj, i];
+}
+function parseArray(lines, start, baseIndent) {
+    const arr = [];
+    let i = start;
+    while (i < lines.length) {
+        const line = lines[i];
+        const indent = getIndent(line);
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            i++;
+            continue;
+        }
+        if (indent < baseIndent) {
+            break;
+        }
+        if (indent === baseIndent && trimmed.startsWith("-")) {
+            const afterDash = trimmed.slice(1).trim();
+            if (afterDash) {
+                // Inline array item
+                arr.push(parseValue(afterDash));
+                i++;
+            }
+            else {
+                // Check next line for nested content
+                i++;
+                if (i < lines.length) {
+                    const nextLine = lines[i];
+                    const nextIndent = getIndent(nextLine);
+                    const nextTrimmed = nextLine.trim();
+                    if (nextTrimmed.includes(":")) {
+                        const [obj, newIndex] = parseObject(lines, i, nextIndent);
+                        arr.push(obj);
+                        i = newIndex;
+                    }
+                    else {
+                        i++;
+                    }
+                }
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return [arr, i];
+}
+function parseValue(value) {
+    // Handle quoted strings
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    // Handle booleans
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    // Handle null
+    if (value === "null" || value === "~")
+        return null;
+    // Handle numbers
+    if (/^-?\d+$/.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    if (/^-?\d+\.\d+$/.test(value)) {
+        return Number.parseFloat(value);
+    }
+    // Default to string
+    return value;
+}
+function getIndent(line) {
+    const match = line.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+}
+// Helper function to extract and parse Yaml front matter from markdown
+export function parseFrontMatter(markdown) {
+    const lines = markdown.split("\n");
+    if (lines[0] !== "---") {
+        return { data: {}, content: markdown };
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === "---" || lines[i] === "...") {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        return { data: {}, content: markdown };
+    }
+    const yamlContent = lines.slice(1, endIndex).join("\n");
+    const data = parseYaml(yamlContent);
+    const content = lines.slice(endIndex + 1).join("\n");
+    return { data, content };
+}

package/dist/utils/{zod-utils.d.ts → zod.d.ts}

@@ -1,4 +1,5 @@
 import { ZodType } from "zod";
 export declare function isZodSchema(obj: unknown): obj is ZodType<unknown>;
 export declare function zodToJsonSchema(schema: ZodType<unknown>): Record<string, unknown>;
-//# sourceMappingURL=zod-utils.d.ts.map
+export declare const convertNullString: (value: unknown) => unknown;
+//# sourceMappingURL=zod.d.ts.map

package/dist/utils/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../source/utils/zod.ts"],"names":[],"mappings":"AAAA,OAAU,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEjC,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAEjE;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAID,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,OAgBlD,CAAC"}

package/dist/utils/zod.js

@@ -0,0 +1,24 @@
+import z, { ZodType } from "zod";
+export function isZodSchema(obj) {
+    return obj instanceof ZodType;
+}
+export function zodToJsonSchema(schema) {
+    return z.toJSONSchema(schema);
+}
+// Many models do not reliably pass null to optional tool fields. Instead they pass "null", "None", "undefined", or empty strings.
+// This function will coerce all of those values into null.
+export const convertNullString = (value) => {
+    if (typeof value === "undefined") {
+        return null;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.toLowerCase() === "null" ||
+            trimmed.toLowerCase() === "none" ||
+            trimmed.toLowerCase() === "undefined" ||
+            trimmed === "") {
+            return null;
+        }
+    }
+    return value;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travisennis/acai",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "An AI assistant for developing software.",
   "type": "module",
   "main": "dist/index.js",
@@ -11,6 +11,7 @@
   },
   "files": [
     "dist",
+    "bin",
     "README.md",
     "LICENSE"
   ],
@@ -33,57 +34,58 @@
     "format:staged": "biome check --staged --formatter-enabled=true --linter-enabled=false --no-errors-on-unmatched",
     "prepack": "npm run clean && npm run build",
     "prepare": "husky",
-    "test": "node --no-warnings --test test/**/*.test.ts",
-    "test:minimal": "node --no-warnings --test --test-reporter=dot test/**/*.test.ts",
-    "test:coverage": "c8 node --no-warnings --test test/**/*.test.ts",
-    "test:full-coverage": "c8 --all node --no-warnings --test test/**/*.test.ts",
+    "test": "node --no-warnings --require ./test/setup.js --test test/**/*.test.ts",
+    "test:minimal": "node --no-warnings --require ./test/setup.js --test --test-reporter=dot test/**/*.test.ts",
+    "test:coverage": "c8 node --no-warnings --require ./test/setup.js --test test/**/*.test.ts",
+    "test:full-coverage": "c8 --all node --no-warnings --require ./test/setup.js --test test/**/*.test.ts",
     "pretest": "npm run typecheck",
     "format": "biome check --formatter-enabled=true --linter-enabled=false --write ./ && biome format --write",
     "dev": "node --no-warnings --env-file=.env ./source/index.ts",
-    "oxlint": "npx oxlint@latest --ignore-path .gitignore --deny correctness --deny suspicous --deny pedantic --deny style --node-plugin",
+    "oxlint": "npm run oxlint:single -- ./source",
+    "oxlint:single": "oxlint --type-aware --ignore-path .gitignore -A all -c .oxlintrc.json",
     "knip": "npx knip",
-    "check": "npx npm-check-updates --interactive --format group",
+    "knip:prod": "npx knip --production",
+    "update": "npx npm-check-updates --interactive --format group",
     "cpd": "npx jscpd ./source",
     "typecheck": "tsc --noEmit --pretty -p tsconfig.json",
-    "typecheck:staged": "npm run typecheck"
+    "typecheck:staged": "npm run typecheck",
+    "check": "npm run typecheck && npm run lint:fix && npm run format"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.47",
-    "@ai-sdk/deepseek": "^1.0.29",
-    "@ai-sdk/google": "^2.0.43",
-    "@ai-sdk/groq": "^2.0.31",
-    "@ai-sdk/openai": "^2.0.72",
-    "@ai-sdk/openai-compatible": "^1.0.27",
+    "@ai-sdk/anthropic": "^3.0.12",
+    "@ai-sdk/deepseek": "^2.0.5",
+    "@ai-sdk/google": "^3.0.7",
+    "@ai-sdk/groq": "^3.0.6",
+    "@ai-sdk/openai": "^3.0.9",
+    "@ai-sdk/openai-compatible": "^2.0.8",
     "@crosscopy/clipboard": "^0.2.8",
-    "@openrouter/ai-sdk-provider": "^1.2.5",
     "@travisennis/stdlib": "^0.0.14",
-    "ai": "^5.0.101",
-    "cheerio": "^1.1.2",
-    "cli-table3": "^0.6.5",
-    "diff": "^8.0.2",
-    "duck-duck-scrape": "^2.2.7",
+    "ai": "^6.0.33",
+    "diff": "^8.0.3",
     "fast-glob": "^3.3.3",
+    "fdir": "^6.5.0",
     "highlight.js": "^11.11.1",
-    "jsonrepair": "^3.13.1",
     "marked": "17.0.1",
     "p-throttle": "^8.1.0",
     "parse5": "^8.0.0",
     "parse5-htmlparser2-tree-adapter": "^8.0.0",
-    "pino": "^10.1.0",
-    "pino-pretty": "^13.1.2",
+    "pino": "^10.1.1",
+    "pino-pretty": "^13.1.3",
     "pino-roll": "^4.0.0",
     "tiktoken": "^1.0.22",
-    "zod": "^4.1.13"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@ai-sdk/provider": "^2.0.0",
-    "@biomejs/biome": "2.3.7",
-    "@commitlint/config-conventional": "^20.0.0",
-    "@types/node": "^24.10.1",
+    "@ai-sdk/provider": "^3.0.2",
+    "@biomejs/biome": "2.3.11",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@types/node": "^25.0.8",
     "c8": "^10.1.3",
-    "commitlint": "^20.1.0",
+    "commitlint": "^20.3.1",
     "domhandler": "^5.0.3",
     "husky": "^9.1.7",
+    "oxlint": "^1.39.0",
+    "oxlint-tsgolint": "^0.11.0",
     "typescript": "^5.9.3"
   },
   "engines": {

package/dist/agent/manual-loop.d.ts

@@ -1,41 +0,0 @@
-import type { LanguageModelUsage, ToolExecuteFunction } from "ai";
-import { type ToolCallRepairFunction } from "ai";
-import type { MessageHistory } from "../messages.ts";
-import type { ModelManager } from "../models/manager.ts";
-import type { Terminal } from "../terminal/index.ts";
-import type { CompleteToolSet } from "../tools/index.ts";
-type ManualLoopOptions = {
-    modelManager: ModelManager;
-    terminal: Terminal;
-    messageHistory: MessageHistory;
-    systemPrompt: string;
-    input: string;
-    toolDefs: CompleteToolSet;
-    executors: Map<keyof CompleteToolSet, ToolExecuteFunction<unknown, string>>;
-    maxIterations?: number;
-    maxRetries?: number;
-    abortSignal?: AbortSignal;
-    toolCallRepair?: ToolCallRepairFunction<CompleteToolSet>;
-};
-type ManualLoopResult = {
-    steps: {
-        toolResults: Array<{
-            toolName: string;
-        }>;
-        toolCalls: Array<{
-            toolName: string;
-        }>;
-    }[];
-    usage: {
-        [K in keyof LanguageModelUsage]-?: number;
-    };
-    totalUsage: {
-        [K in keyof LanguageModelUsage]-?: number;
-    };
-};
-export declare function runManualLoop(opts: ManualLoopOptions): Promise<ManualLoopResult>;
-export declare function consumeToolAsyncIterable(iterable: AsyncIterable<unknown>, terminal?: Terminal): Promise<{
-    finalValue: unknown;
-}>;
-export {};
-//# sourceMappingURL=manual-loop.d.ts.map

package/dist/agent/manual-loop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manual-loop.d.ts","sourceRoot":"","sources":["../../source/agent/manual-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,IAAI,CAAC;AACZ,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,IAAI,CAAC;AAEZ,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIzD,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,GAAG,CAAC,MAAM,eAAe,EAAE,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,sBAAsB,CAAC,eAAe,CAAC,CAAC;CAC1D,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE;QACL,WAAW,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACzC,SAAS,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACxC,EAAE,CAAC;IACJ,KAAK,EAAE;SAAG,CAAC,IAAI,MAAM,kBAAkB,CAAC,CAAC,GAAG,MAAM;KAAE,CAAC;IACrD,UAAU,EAAE;SAAG,CAAC,IAAI,MAAM,kBAAkB,CAAC,CAAC,GAAG,MAAM;KAAE,CAAC;CAC3D,CAAC;AAEF,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAoS3B;AAED,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,QAAQ,CAAC,EAAE,QAAQ,GAClB,OAAO,CAAC;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CAuBlC"}

package/dist/agent/manual-loop.js

@@ -1,278 +0,0 @@
-import { NoOutputGeneratedError, streamText, } from "ai";
-import { logger } from "../logger.js";
-import { AiConfig } from "../models/ai-config.js";
-import { displayToolMessages } from "../repl/display-tool-messages.js";
-import style from "../terminal/style.js";
-import { isToolMessage } from "../tools/types.js";
-import { isAsyncIterable } from "../utils/iterables.js";
-export async function runManualLoop(opts) {
-    const { modelManager, messageHistory, systemPrompt, input, toolDefs, executors, maxIterations = 90, maxRetries = 2, abortSignal, toolCallRepair, } = opts;
-    const terminal = opts.terminal;
-    const langModel = modelManager.getModel("repl");
-    const modelConfig = modelManager.getModelMetadata("repl");
-    const aiConfig = new AiConfig({
-        modelMetadata: modelConfig,
-        prompt: input,
-    });
-    const loopResult = {
-        usage: {
-            inputTokens: 0,
-            outputTokens: 0,
-            totalTokens: 0,
-            reasoningTokens: 0,
-            cachedInputTokens: 0,
-        },
-        totalUsage: {
-            inputTokens: 0,
-            outputTokens: 0,
-            totalTokens: 0,
-            reasoningTokens: 0,
-            cachedInputTokens: 0,
-        },
-        steps: [],
-    };
-    let iter = 0;
-    let consecutiveErrors = 0;
-    while (iter < maxIterations) {
-        if (abortSignal?.aborted) {
-            logger.warn("The agent loop was aborted by the user.");
-            terminal.warn("Operation aborted by user.");
-            break;
-        }
-        try {
-            const result = streamText({
-                model: langModel,
-                maxOutputTokens: aiConfig.maxOutputTokens(),
-                system: systemPrompt,
-                messages: messageHistory.get(),
-                temperature: aiConfig.temperature(),
-                topP: aiConfig.topP(),
-                maxRetries: 2,
-                providerOptions: aiConfig.providerOptions(),
-                tools: toolDefs,
-                // biome-ignore lint/style/useNamingConvention: third-party code
-                experimental_repairToolCall: toolCallRepair,
-                abortSignal,
-            });
-            let accumulatedText = "";
-            let lastType = null;
-            for await (const chunk of result.fullStream) {
-                if (chunk.type === "reasoning-delta" || chunk.type === "text-delta") {
-                    if (chunk.type === "reasoning-delta") {
-                        if (lastType !== "reasoning") {
-                            terminal.writeln(style.dim("<think>"));
-                        }
-                        terminal.write(style.dim(chunk.text));
-                        lastType = "reasoning";
-                    }
-                    else {
-                        terminal.stopProgress();
-                        if (lastType === "reasoning") {
-                            terminal.writeln(style.dim("\n</think>\n"));
-                        }
-                        accumulatedText += chunk.text;
-                        lastType = "text";
-                    }
-                }
-                else {
-                    // finish off this step
-                    if (lastType === "reasoning") {
-                        terminal.write(style.dim("\n</think>\n\n"));
-                    }
-                    terminal.stopProgress();
-                    if (accumulatedText.trim()) {
-                        terminal.writeln(`${style.blue.bold("● Response:")}`);
-                        terminal.display(accumulatedText, true);
-                        terminal.lineBreak();
-                    }
-                    accumulatedText = "";
-                    lastType = null;
-                }
-            }
-            // Get response and tool calls
-            const response = await result.response;
-            const responseMessages = response.messages;
-            messageHistory.appendResponseMessages(responseMessages);
-            const toolCalls = await result.toolCalls;
-            const thisStepToolCalls = [];
-            const thisStepToolResults = [];
-            loopResult.steps.push({
-                toolCalls: thisStepToolCalls,
-                toolResults: thisStepToolResults,
-            });
-            // If finishReason is not tool-calls, break
-            const finishReason = await result.finishReason;
-            if (finishReason !== "tool-calls") {
-                const lastStepUsage = await result.usage;
-                loopResult.usage.inputTokens = lastStepUsage.inputTokens ?? 0;
-                loopResult.usage.outputTokens = lastStepUsage.outputTokens ?? 0;
-                loopResult.usage.totalTokens = lastStepUsage.totalTokens ?? 0;
-                loopResult.usage.cachedInputTokens =
-                    lastStepUsage.cachedInputTokens ?? 0;
-                loopResult.usage.reasoningTokens = lastStepUsage.reasoningTokens ?? 0;
-                loopResult.totalUsage.inputTokens += lastStepUsage.inputTokens ?? 0;
-                loopResult.totalUsage.outputTokens += lastStepUsage.outputTokens ?? 0;
-                loopResult.totalUsage.totalTokens += lastStepUsage.totalTokens ?? 0;
-                loopResult.totalUsage.cachedInputTokens +=
-                    lastStepUsage.cachedInputTokens ?? 0;
-                loopResult.totalUsage.reasoningTokens +=
-                    lastStepUsage.reasoningTokens ?? 0;
-                break;
-            }
-            // Execute tools in parallel (order not guaranteed)
-            // Check response.messages for already-processed tool results
-            const alreadyProcessedToolCallIds = new Set();
-            // Look for tool results and tool errors in the response messages
-            for (const message of responseMessages) {
-                if (message.role === "tool" && Array.isArray(message.content)) {
-                    for (const content of message.content) {
-                        if ((content.type === "tool-result" ||
-                            content.type === "tool-error") &&
-                            content.toolCallId) {
-                            alreadyProcessedToolCallIds.add(content.toolCallId);
-                        }
-                    }
-                }
-            }
-            // Filter out tool calls that have already been processed or are invalid
-            const validToolCalls = toolCalls.filter((call) => !alreadyProcessedToolCallIds.has(call.toolCallId) &&
-                // Also check if the tool call is marked as invalid by the AI SDK
-                !call.invalid);
-            if (validToolCalls.length === 0) {
-                // All tool calls were already processed by the AI SDK
-                logger.debug(`All ${toolCalls.length} tool calls were already processed by AI SDK, skipping manual execution`);
-                continue;
-            }
-            if (validToolCalls.length < toolCalls.length) {
-                logger.debug(`Filtered out ${toolCalls.length - validToolCalls.length} already-processed tool calls, executing ${validToolCalls.length} remaining`);
-            }
-            // Process all tools concurrently
-            const toolMessagesPromise = Promise.allSettled(validToolCalls.map(async (call) => {
-                const toolName = call.toolName;
-                let resultOutput = "Unknown result.";
-                try {
-                    thisStepToolCalls.push({ toolName });
-                    thisStepToolResults.push({ toolName });
-                    const exec = executors.get(toolName);
-                    if (!exec) {
-                        resultOutput = `No executor for tool ${toolName}`;
-                    }
-                    else {
-                        try {
-                            const output = await exec(call.input, {
-                                toolCallId: call.toolCallId,
-                                messages: messageHistory.get(),
-                                abortSignal,
-                            });
-                            if (isAsyncIterable(output)) {
-                                const { finalValue } = await consumeToolAsyncIterable(output, terminal);
-                                resultOutput = formatToolResult(finalValue);
-                            }
-                            else {
-                                resultOutput = formatToolResult(output);
-                            }
-                        }
-                        catch (err) {
-                            resultOutput = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
-                        }
-                    }
-                }
-                catch (error) {
-                    resultOutput = `Tool error: ${error instanceof Error ? error.message : String(error)}`;
-                }
-                return {
-                    role: "tool",
-                    content: [
-                        {
-                            type: "tool-result",
-                            toolName,
-                            toolCallId: call.toolCallId,
-                            output: {
-                                type: "text",
-                                value: resultOutput,
-                            },
-                        },
-                    ],
-                };
-            }));
-            const toolMessages = (await toolMessagesPromise)
-                .filter((result) => result.status === "fulfilled")
-                .map((result) => result.value);
-            messageHistory.appendToolMessages(toolMessages);
-            // Calculate usage for the current step/iteration
-            const stepUsage = await result.usage;
-            loopResult.totalUsage.inputTokens += stepUsage.inputTokens ?? 0;
-            loopResult.totalUsage.outputTokens += stepUsage.outputTokens ?? 0;
-            loopResult.totalUsage.totalTokens += stepUsage.totalTokens ?? 0;
-            loopResult.totalUsage.cachedInputTokens +=
-                stepUsage.cachedInputTokens ?? 0;
-            loopResult.totalUsage.reasoningTokens += stepUsage.reasoningTokens ?? 0;
-            // Consume the rest of the team if necessary
-            // await result.consumeStream();
-            // continue iterations
-            iter += 1;
-        }
-        catch (error) {
-            consecutiveErrors += 1;
-            logger.error(error, // Log the full error object
-            `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
-            terminal.error("Error in manual agent loop.");
-            terminal.error(error.message.length > 100
-                ? `${error.message.slice(0, 100)}...`
-                : error.message);
-            if (NoOutputGeneratedError.isInstance(error)) {
-                break;
-            }
-            // Break loop if we exceed max retries
-            if (consecutiveErrors > maxRetries) {
-                terminal.error(`Exceeded maximum retry attempts (${maxRetries}). Stopping manual loop.`);
-                break;
-            }
-        }
-    }
-    return loopResult;
-}
-export async function consumeToolAsyncIterable(iterable, terminal) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    const toolResultValues = [];
-    let next = await iterator.next();
-    while (!next.done) {
-        const value = next.value;
-        if (isToolMessage(value)) {
-            if (terminal) {
-                displayToolMessages(value, terminal);
-            }
-        }
-        else {
-            toolResultValues.push(value);
-        }
-        next = await iterator.next();
-    }
-    const finalValue = next.value ??
-        (toolResultValues.length > 0 ? toolResultValues.at(-1) : undefined);
-    return { finalValue };
-}
-function formatToolResult(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (value === undefined) {
-        return "";
-    }
-    if (value === null) {
-        return "null";
-    }
-    if (typeof value === "number" || typeof value === "boolean") {
-        return String(value);
-    }
-    try {
-        const serialized = JSON.stringify(value);
-        if (typeof serialized === "string") {
-            return serialized;
-        }
-    }
-    catch {
-        // noop - fallback below
-    }
-    return String(value);
-}