glitool 1.0.1 → 2.0.0

package/README.md

@@ -1,48 +1,115 @@
-# glitool
-
-AI coding assistant for your terminal. Powered by OpenAI.
-
-
-## Install
-
-```bash
-npm install -g glitool
-```
-
-## Setup
-
-On first run, glitool will ask for your OpenAI API key. Get one at https://platform.openai.com/api-keys
-
-Or set it manually:
-
-```bash
-mkdir ~/.glitool
-echo "OPENAI_API_KEY=sk-..." > ~/.glitool/.env
-```
-
-## Usage
-
-```bash
-glitool              # start AI chat session
-glitool --explain    # explain every change in simple language
-glitool config --set-name "Your Name"
-glitool config --set-model gpt-4o
-glitool config --show
-```
-
-## Commands (inside chat)
-
-| Command | Description |
-|---------|-------------|
-| /help   | Show available commands |
-| /clear  | Clear current session |
-| /reset  | Clear session + memory |
-| /exit   | Save and exit |
-
-## Requirements
-- Node.js 22 or higher
-- npm install -g glitool
-
-
-curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
-sudo apt-get install -y nodejs
+# glitool
+
+AI coding assistant for your terminal. Multi-agent pipeline, smart routing,
+and a live process trace — all without leaving your terminal.
+
+## Install
+
+```bash
+npm install -g glitool
+```
+
+## Setup
+
+```bash
+mkdir -p ~/.glitool
+echo "OPENAI_API_KEY=sk-..." > ~/.glitool/.env
+```
+
+Then start:
+
+```bash
+glitool
+```
+
+## Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/plan` | Create a structured plan for a complex task |
+| `/coder` | Run the full multi-agent coding pipeline |
+| `/debug` | Diagnose errors and broken behavior |
+| `/refactor` | Restructure code without changing behavior |
+| `/review` | Audit code for bugs, security, and quality |
+| `/git` | Commit, push, diff, branch — full git operations |
+| `/explain` | Explain a concept or file (no file edits) |
+| `/quick` | Fast chat, cheapest model, no pipeline |
+| `/model` | Show or switch the active model |
+| `/memory` | View project memory and session summary |
+| `/tools` | List available tools |
+| `/clear` | Clear session (keeps memory) |
+| `/reset` | Clear session and wipe memory |
+| `/exit` | Save summary and quit |
+
+## Smart Routing
+
+You don't need slash commands. Glitool reads your message and picks the
+right agent automatically:
+
+```
+why is my server crashing?       → DEBUGGER
+review src/auth.ts               → REVIEWER
+refactor the parser module       → REFACTORER
+commit my changes                → GIT AGENT
+how does useEffect work?         → EXPLAINER
+add a rate limiter               → CODER (full pipeline)
+```
+
+## Multi-Agent Pipeline
+
+For coding tasks, four agents run in sequence:
+
+```
+PLANNER → CODER → VALIDATOR → JUDGE
+```
+
+- **PLANNER** reads your request and produces a numbered step-by-step plan
+- **CODER** executes the plan using file and shell tools
+- **VALIDATOR** runs TypeScript and ESLint checks on the result
+- **JUDGE** reviews the output and decides if it meets the requirement
+
+Each stage is shown live in the terminal as it runs — with reasoning text
+and every tool call displayed in order.
+
+## Tools
+
+Agents have access to:
+
+| Tool | What it does |
+|------|-------------|
+| `readFile` | Read any file in the project |
+| `listFiles` | List files matching a glob pattern |
+| `searchCode` | Search source files for a string or pattern |
+| `writeFile` | Create a new file |
+| `editFile` | Edit an existing file |
+| `bash` | Run shell commands (risk-gated) |
+| `webFetch` | Fetch a URL and read its content |
+
+Dangerous shell commands (`rm -rf /`, `sudo`, `curl \| sh`) are blocked.
+Sensitive commands (`git push`, `npm publish`) require your confirmation.
+
+## Memory
+
+Glitool remembers context across sessions:
+
+- **Session memory** — last 40 messages saved per project, auto-summarized
+- **Project memory** — tech stack, architecture decisions, and TODOs
+  extracted from your conversations, stored in `.glitool/memory.json`
+
+## Configuration
+
+Config file: `~/.glitool/config.json`
+
+```json
+{
+  "name": "Developer",
+  "preferredLanguage": "TypeScript",
+  "codingStyle": "spaces",
+  "preferredModel": "gpt-4o-mini"
+}
+```
+
+## Requirements
+
+- Node.js 18 or higher
+- OpenAI API key ([get one here](https://platform.openai.com/api-keys))

package/dist/agent.js

@@ -1,4 +1,4 @@
-import { writeFileTool, analyzeProjectTool, listFilesTool, readFileTool, searchCodeTool, editFileTool } from "./tools/index.js";
+import { writeFileTool, listFilesTool, readFileTool, searchCodeTool, editFileTool, bashTool, readBackgroundOutputTool, webFetchTool, } from "./tools/index.js";
 import { AIMessage, BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { StructuredTool } from "@langchain/core/tools";
 import { createReactAgent } from '@langchain/langgraph/prebuilt';
@@ -9,28 +9,39 @@ import { loadProjectMemory } from "./projectMemory.js";
 import { config as loadEnv } from 'dotenv';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { route } from './llm/router.js';
+import { route, stripExplicitPrefix } from './llm/router.js';
 import { logRouting } from './llm/telemetry.js';
 import { runAgentGraph } from "./agents/graph.js";
+import { runReviewer } from "./agents/reviewer-agent.js";
 import os from 'os';
+import { cleanupAll } from "./tools/processRegistry.js";
+import { runPlanningAgent } from "./agents/planningAgent.js";
+import { runDebugger } from "./agents/debugger.js";
+import { runRefactorer } from "./agents/refactorer.js";
+import { runGitAgent } from "./agents/git-agent.js";
+import { ToolMessage } from "@langchain/core/messages";
+import { makeLlm } from './llm/factory.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 loadEnv({ path: join(os.homedir(), '.glitool', '.env') });
-const simpleLlm = new ChatOpenAI({
-    model: 'gpt-4o-mini',
-    apiKey: process.env.OPENAI_API_KEY
-});
-export const llm = new ChatOpenAI({
-    model: 'gpt-4o-mini',
-    apiKey: process.env.OPENAI_API_KEY
-});
-const config = loadConfig();
-const tools = [listFilesTool, readFileTool, searchCodeTool, writeFileTool, analyzeProjectTool, editFileTool];
+const MAX_HISTORY_CHARS = 60_000;
+// const simpleLlm = makeLlm('meta-llama/Llama-3.3-70B-Instruct-Turbo');
+export const llm = createLlm('meta-llama/Llama-3.3-70B-Instruct-Turbo');
+function createLlm(model) {
+    return makeLlm(model);
+}
+// const config = loadConfig();
+const tools = [listFilesTool, readFileTool, searchCodeTool, writeFileTool, editFileTool, bashTool, readBackgroundOutputTool, webFetchTool];
+process.on('exit', cleanupAll);
+process.on('SIGINT', () => { cleanupAll(); process.exit(0); });
+process.on('SIGTERM', () => { cleanupAll(); process.exit(0); });
 export const sessionMessages = loadSession();
 export function clearSession() {
     sessionMessages.length = 0;
     saveSession(sessionMessages);
 }
+const MAX_SUMMARY_CHARS = 2_000;
+const MAX_PROJECT_FACTS_CHARS = 3_000;
 function buildSystemPrompt() {
     let summary = loadSummary();
     const project = loadProjectMemory();
@@ -41,41 +52,216 @@ function buildSystemPrompt() {
             summary = loadSummary();
         }
     }
-    // const project = loadProjectMemory();
     let prompt = `You are an expert coding assistant. Be concise and code-focused.
+
+CRITICAL — file operations:
+- When the user asks to read, show, view, or display a file, you MUST call the readFile tool. NEVER answer from memory or guess at file contents.
+- When the user asks if a file exists, you MUST call listFiles or readFile to verify. NEVER claim a file is missing without checking.
+- For "read <name>" prompts, call readFile with the bare name — the tool will search the project automatically.
+
 IMPORTANT: If any tool returns USER_CANCELLED, immediately stop all tool calls and tell the user the operation was cancelled. Never retry a cancelled operation.`;
-    if (summary)
-        prompt += `\n\nPrevious session summary:\n${summary}`;
-    if (project)
-        prompt += `\n\nProject facts:\n${JSON.stringify(project, null, 2)}`;
+    if (summary) {
+        const capped = summary.length > MAX_SUMMARY_CHARS
+            ? summary.slice(0, MAX_SUMMARY_CHARS) + '\n…[summary truncated]'
+            : summary;
+        prompt += `\n\nPrevious session summary:\n${capped}`;
+    }
+    if (project) {
+        const json = JSON.stringify(project, null, 2);
+        const capped = json.length > MAX_PROJECT_FACTS_CHARS
+            ? json.slice(0, MAX_PROJECT_FACTS_CHARS) + '\n…[truncated]'
+            : json;
+        prompt += `\n\nProject facts:\n${capped}`;
+    }
     return prompt;
 }
 const systemPrompt = await buildSystemPrompt();
-const simpleAgent = createReactAgent({
-    llm: simpleLlm,
-    tools,
-    stateModifier: new SystemMessage(buildSystemPrompt())
-});
-const complexAgent = createReactAgent({
-    llm,
-    tools,
-    stateModifier: new SystemMessage(buildSystemPrompt())
-});
-export async function chat(userInput, onToolCall, onStatus, onToken) {
-    const decision = route(userInput);
+async function tryDirectReadShortcut(prompt, onToolCall) {
+    const match = prompt.trim().match(/^(?:read|show|open|cat|view|display|print)\s+(.+?)$/i);
+    if (!match)
+        return null;
+    const target = match[1].trim().replace(/^["']|["']$/g, '');
+    if (!target || target.includes(' '))
+        return null;
+    onToolCall('readFile', { filePath: target });
+    let raw;
+    try {
+        raw = await readFileTool.invoke({ filePath: target });
+    }
+    catch (err) {
+        return `Could not read ${target}: ${err?.message ?? 'unknown error'}`;
+    }
+    if (typeof raw !== 'string')
+        raw = String(raw);
+    // Strip the smart-resolve header if present and remember the real path.
+    let resolvedPath = target;
+    let body = raw;
+    const resolveMatch = raw.match(/^\[resolved ".*?" → (.+?)\]\n\n([\s\S]*)$/);
+    if (resolveMatch) {
+        resolvedPath = resolveMatch[1];
+        body = resolveMatch[2];
+    }
+    const allLines = body.split('\n');
+    const totalLines = allLines.length;
+    const PREVIEW_LINES = 40;
+    const preview = allLines.slice(0, PREVIEW_LINES).join('\n');
+    const more = totalLines > PREVIEW_LINES
+        ? `\n\n[...${totalLines - PREVIEW_LINES} more lines — open ${resolvedPath} in your editor for the full file, or ask me a question about it]`
+        : '';
+    return `Read ${resolvedPath} (${totalLines} lines):\n\n${preview}${more}`;
+}
+function trimHistory(messages) {
+    // Pass 1: keep only well-formed turns (HumanMessage + final non-tool AIMessage).
+    // Drop empty AI messages and any AIMessage that requested a tool — they'd be orphaned without their ToolMessage.
+    const cleaned = [];
+    for (const m of messages) {
+        if (m instanceof HumanMessage) {
+            cleaned.push(m);
+            continue;
+        }
+        if (m instanceof AIMessage) {
+            const hasToolCalls = (Array.isArray(m.tool_calls) && m.tool_calls.length > 0) ||
+                (Array.isArray(m.additional_kwargs?.tool_calls) &&
+                    m.additional_kwargs.tool_calls.length > 0);
+            if (!hasToolCalls && typeof m.content === 'string' && m.content.trim()) {
+                cleaned.push(m);
+            }
+        }
+        // ToolMessage and anything else: drop
+    }
+    // Pass 2: char budget, walking backwards.
+    let totalChars = 0;
+    const kept = [];
+    for (let i = cleaned.length - 1; i >= 0; i--) {
+        const content = typeof cleaned[i].content === 'string'
+            ? cleaned[i].content
+            : JSON.stringify(cleaned[i].content);
+        totalChars += content.length;
+        if (totalChars > MAX_HISTORY_CHARS)
+            break;
+        kept.unshift(cleaned[i]);
+    }
+    return kept;
+}
+const COST_PER_TOKEN = {
+    'gpt-4o-mini': { input: 0.15 / 1_000_000, output: 0.60 / 1_000_000 },
+    'gpt-5.4-mini': { input: 0.75 / 1_000_000, output: 4.50 / 1_000_000 },
+    'gpt-5.4': { input: 2.50 / 1_000_000, output: 15.00 / 1_000_000 },
+    'gpt-5.5': { input: 5.00 / 1_000_000, output: 30.00 / 1_000_000 },
+};
+function estimateCost(model, inputTokens, outputTokens) {
+    const rates = COST_PER_TOKEN[model] ?? COST_PER_TOKEN['gpt-4o-mini'];
+    return inputTokens * rates.input + outputTokens * rates.output;
+}
+function extractTarget(args) {
+    if (!args)
+        return '';
+    const first = Object.values(args)[0];
+    if (typeof first === 'string') {
+        try {
+            const p = JSON.parse(first);
+            return p.command ?? p.filePath ?? p.pattern ?? p.query ?? first;
+        }
+        catch {
+            return first;
+        }
+    }
+    if (typeof first === 'object' && first !== null) {
+        return first.command ?? first.filePath ?? JSON.stringify(first).slice(0, 50);
+    }
+    return String(first ?? '');
+}
+export async function chat(userInput, onToolCall, onStatus, onToken, onEscalation, onUsage, onStageEvent) {
+    const decision = await route(userInput, sessionMessages.slice(-6));
     logRouting(userInput, decision);
-    sessionMessages.push(new HumanMessage(userInput));
-    if (decision.domain === 'coding' || decision.tier === 'complex') {
-        const result = await runAgentGraph(userInput, buildSystemPrompt(), onToolCall, onStatus ?? (() => { }));
-        if (result !== null && result !== undefined) {
-            sessionMessages.push(new AIMessage(result));
+    const cleanedInput = decision.source === 'explicit' ? stripExplicitPrefix(userInput) : userInput;
+    sessionMessages.push(new HumanMessage(cleanedInput));
+    const shortcut = await tryDirectReadShortcut(cleanedInput, onToolCall);
+    if (shortcut !== null) {
+        sessionMessages.push(new AIMessage(shortcut));
+        saveSession(sessionMessages);
+        return shortcut;
+    }
+    if (decision.domain === 'planning') {
+        onStatus?.('Planning...');
+        const result = await runPlanningAgent(cleanedInput, (inputTokens, outputTokens) => {
+            onUsage?.(inputTokens + outputTokens, estimateCost('gpt-5.4', inputTokens, outputTokens));
+        });
+        sessionMessages.push(new AIMessage(result));
+        saveSession(sessionMessages);
+        return result;
+    }
+    if (decision.domain === 'review') {
+        onStageEvent?.({ type: 'stage_start', stage: 'reviewer' });
+        const result = await runReviewer(cleanedInput, (name, args) => {
+            onStageEvent?.({ type: 'tool', stage: 'reviewer', tool: name, target: extractTarget(args) });
+            onToolCall(name, args);
+        }, decision.recommendedModel);
+        onStageEvent?.({ type: 'stage_done', stage: 'reviewer' });
+        sessionMessages.push(new AIMessage(result));
+        saveSession(sessionMessages);
+        return result;
+    }
+    if (decision.domain === 'debugging') {
+        onStageEvent?.({ type: 'stage_start', stage: 'debugger' });
+        const result = await runDebugger(cleanedInput, (name, args) => {
+            onStageEvent?.({ type: 'tool', stage: 'debugger', tool: name, target: extractTarget(args) });
+            onToolCall(name, args);
+        }, decision.recommendedModel);
+        onStageEvent?.({ type: 'stage_done', stage: 'debugger' });
+        sessionMessages.push(new AIMessage(result));
+        saveSession(sessionMessages);
+        return result;
+    }
+    if (decision.domain === 'refactoring') {
+        onStageEvent?.({ type: 'stage_start', stage: 'refactorer' });
+        const result = await runRefactorer(cleanedInput, (name, args) => {
+            onStageEvent?.({ type: 'tool', stage: 'refactorer', tool: name, target: extractTarget(args) });
+            onToolCall(name, args);
+        }, decision.recommendedModel);
+        onStageEvent?.({ type: 'stage_done', stage: 'refactorer' });
+        sessionMessages.push(new AIMessage(result));
+        saveSession(sessionMessages);
+        return result;
+    }
+    if (decision.domain === 'git') {
+        onStageEvent?.({ type: 'stage_start', stage: 'git_agent' });
+        const result = await runGitAgent(cleanedInput, (name, args) => {
+            onStageEvent?.({ type: 'tool', stage: 'git_agent', tool: name, target: extractTarget(args) });
+            onToolCall(name, args);
+        }, decision.recommendedModel);
+        onStageEvent?.({ type: 'stage_done', stage: 'git_agent' });
+        sessionMessages.push(new AIMessage(result));
+        saveSession(sessionMessages);
+        return result;
+    }
+    if (decision.domain === 'coding') {
+        const graphResult = await runAgentGraph(cleanedInput, buildSystemPrompt(), onToolCall, onStatus ?? (() => { }), decision, onStageEvent // ← add this
+        );
+        if (graphResult.escalated && onEscalation) {
+            onEscalation({
+                userMessage: graphResult.userMessage,
+                plan: graphResult.plan,
+                trajectory: graphResult.trajectory,
+                finalOutput: graphResult.finalOutput ?? '',
+            });
+        }
+        if (graphResult.finalOutput) {
+            sessionMessages.push(new AIMessage(graphResult.finalOutput));
             saveSession(sessionMessages);
-            return result;
+            return graphResult.finalOutput;
         }
     }
-    ;
-    const eventStrem = simpleAgent.streamEvents({ messages: sessionMessages }, { version: 'v2' });
+    const simpleAgent = createReactAgent({
+        llm: createLlm(decision.recommendedModel),
+        tools,
+        stateModifier: new SystemMessage(systemPrompt)
+    });
+    const trimmed = trimHistory(sessionMessages);
+    const eventStrem = simpleAgent.streamEvents({ messages: trimmed }, { version: 'v2' });
     let finalResponse = '';
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
     for await (const { event, data, name: eventName } of eventStrem) {
         if (event === 'on_chat_model_stream') {
             const chunk = data.chunk;
@@ -100,6 +286,11 @@ export async function chat(userInput, onToolCall, onStatus, onToken) {
             onToolCall(eventName, data.input);
         }
         if (event === 'on_chat_model_end') {
+            const usage = data.output?.usage_metadata;
+            if (usage) {
+                totalInputTokens += usage.input_tokens ?? 0;
+                totalOutputTokens += usage.output_tokens ?? 0;
+            }
             if (!finalResponse) {
                 const output = data.output;
                 if (typeof output?.content === 'string') {
@@ -112,6 +303,10 @@ export async function chat(userInput, onToolCall, onStatus, onToken) {
     if (finalResponse) {
         sessionMessages.push(new AIMessage(finalResponse));
     }
+    if (onUsage && (totalInputTokens + totalOutputTokens) > 0) {
+        const model = decision.recommendedModel;
+        onUsage(totalInputTokens + totalOutputTokens, estimateCost(model, totalInputTokens, totalOutputTokens));
+    }
     saveSession(sessionMessages);
     return finalResponse;
 }

package/dist/agents/coder.js

@@ -1,54 +1,66 @@
 import { createReactAgent } from "@langchain/langgraph/prebuilt";
-import { ChatOpenAI } from "@langchain/openai";
+import { makeLlm } from '../llm/factory.js';
 import { SystemMessage, HumanMessage, BaseMessage } from "@langchain/core/messages";
 import { StructuredTool } from "@langchain/core/tools";
-import { listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool } from '../tools/index.js';
+import { listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool } from '../tools/index.js';
 import { scoreRisk, getRiskMessage } from "../trust/riskScorer.js";
-import { requestConfirm } from "../confirmHandler.js";
-const coderLlm = new ChatOpenAI({
-    model: 'gpt-5.4-mini',
-    apiKey: process.env.OPENAI_API_KEY
-});
-const coderAgent = createReactAgent({
-    llm: coderLlm,
-    tools: [listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool],
-    stateModifier: new SystemMessage('You are a coding execution agent. Execute the given plan step by step using tools. Be precise and thorough.')
-});
-export async function runCoder(plan, userMessage, onToolCall) {
-    const stream = await coderAgent.stream({
-        messages: [new HumanMessage(`Plan to execute:\n${plan}\n\nOriginal request: ${userMessage}`)]
+import { log } from "../logger.js";
+export async function runCoder(plan, userMessage, onToolCall, model, onReasoning) {
+    const coderLlm = makeLlm(model);
+    const coderAgent = createReactAgent({
+        llm: coderLlm,
+        tools: [listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool],
+        stateModifier: new SystemMessage(`You are a coding execution agent. Execute the given plan step by step using tools.
+
+GROUNDING RULES — these are not optional:
+
+1. BEFORE editing any file, READ it first with readFile to confirm structure.
+2. PREFER searchCode over readFile for navigation. Read whole files only when you'll actually edit them.
+3. For UI features (slash commands, menus, palettes), search src/ui/, src/components/, src/cli/ first — don't trust the plan's filename blindly.
+4. After every editFile, if the tool returned an error, STOP and read the file again. Do not retry with guesses.
+5. You MAY create package.json or tsconfig.json when building a new project from scratch. Never add dependencies to an EXISTING package.json unless explicitly asked. Never run npm install via bash.
+6. Maximum 5 file reads per task. If you need more, you're doing it wrong — use searchCode instead.
+7. If you can't safely complete the task, STOP and return a failure message. Do not invent.
+
+Be surgical, not exhaustive. Most tasks need 2-4 tool calls, not 15. The validator will catch broken output — you don't need to over-verify.`)
     });
+    const stream = await coderAgent.stream({ messages: [new HumanMessage(`Plan to execute:\n${plan}\n\nOriginal request: ${userMessage}`)] }, { recursionLimit: 60, streamMode: 'updates' });
     let result = '';
+    let blocked = false;
     for await (const chunk of stream) {
-        if (chunk.agent?.messages) {
-            const msgs = chunk.agent.messages;
-            const msg = msgs.at(-1);
-            if (msg?.tool_calls?.length > 0) {
-                const toolCall = msg.tool_calls[0];
+        if (blocked)
+            break;
+        // 'updates' mode gives one complete message per graph step.
+        // Agent node = LLM output (reasoning or tool call decision).
+        // Tools node = tool results — no useful trace info, skip.
+        const agentMsgs = chunk.agent?.messages;
+        if (!agentMsgs?.length) {
+            log('coder:chunk', { keys: Object.keys(chunk).join(',') });
+            continue;
+        }
+        for (const msg of agentMsgs) {
+            const toolCalls = msg.tool_calls;
+            const text = typeof msg.content === 'string' ? msg.content.trim() : '';
+            if (toolCalls?.length > 0) {
+                if (text)
+                    onReasoning?.(text);
+                const toolCall = toolCalls[0];
                 const risk = scoreRisk(toolCall.name, toolCall.args);
-                const riskMsg = getRiskMessage(toolCall.name, risk, toolCall.args);
+                getRiskMessage(toolCall.name, risk, toolCall.args);
                 if (risk === 'high') {
                     onToolCall(toolCall.name, toolCall.args);
                     result = `Blocked: I cannot write to sensitive files like ${toolCall.args?.filePath}.`;
+                    blocked = true;
                     break;
                 }
                 onToolCall(toolCall.name, toolCall.args);
             }
-            else if (msg?.content) {
-                result = msg.content;
+            else if (text) {
+                onReasoning?.(text);
+                result = text;
             }
         }
+        log('coder:chunk', { keys: Object.keys(chunk).join(',') });
     }
-    // for await (const chunk of stream){
-    //     if(chunk.agent?.messages){
-    //         const msgs = chunk.agent.messages as BaseMessage[];
-    //         const msg = msgs.at(-1);
-    //         if((msg as any)?.tool_calls?.length > 0){
-    //             onToolCall((msg as any).tool_calls[0].name, (msg as any).tool_calls[0].args);
-    //         }else if (msg?.content){
-    //             result = msg.content as string;
-    //         }
-    //     }
-    // }
     return result;
 }