@quantish/agent 0.1.19 → 0.1.21

package/dist/index.js

@@ -3261,17 +3261,38 @@ var OpenRouterProvider = class {
     const toolCalls = [];
     for (const [, tc] of toolCallsInProgress) {
       try {
+        if (!tc || !tc.name) {
+          continue;
+        }
         let args = tc.arguments?.trim() || "{}";
-        if (args && !args.endsWith("}")) {
-          args = args + "}";
+        if (args && !args.endsWith("}") && !args.endsWith("]")) {
+          const openBraces = (args.match(/{/g) || []).length;
+          const closeBraces = (args.match(/}/g) || []).length;
+          if (openBraces > closeBraces) {
+            args = args + "}".repeat(openBraces - closeBraces);
+          }
+        }
+        if (!args || args === "" || args === "undefined") {
+          args = "{}";
         }
         const input = JSON.parse(args);
-        toolCalls.push({ id: tc.id, name: tc.name, input });
-        callbacks.onToolCall?.(tc.id, tc.name, input);
+        const toolId = tc.id || `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        toolCalls.push({ id: toolId, name: tc.name, input });
+        callbacks.onToolCall?.(toolId, tc.name, input);
       } catch (e) {
-        console.error(`[OpenRouter] Failed to parse tool call "${tc.name}": ${tc.arguments}`);
-        toolCalls.push({ id: tc.id, name: tc.name, input: {} });
-        callbacks.onToolCall?.(tc.id, tc.name, {});
+        const toolName = tc?.name || "unknown_tool";
+        let parsedInput = {};
+        try {
+          const argsStr = tc?.arguments || "";
+          const matches = argsStr.matchAll(/(\w+):\s*"([^"]+)"/g);
+          for (const match of matches) {
+            parsedInput[match[1]] = match[2];
+          }
+        } catch {
+        }
+        const toolId = tc?.id || `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        toolCalls.push({ id: toolId, name: toolName, input: parsedInput });
+        callbacks.onToolCall?.(toolId, toolName, parsedInput);
       }
     }
     const cost = calculateOpenRouterCost(
@@ -3486,31 +3507,40 @@ function extractTokenInfo(token) {
 }
 var DEFAULT_SYSTEM_PROMPT = `You are Quantish, an AI coding and trading agent.
 
-You have two sets of capabilities:
-
 ## Trading Tools (via MCP)
-You can interact with Polymarket prediction markets:
 - Check wallet balances and positions
 - Place, cancel, and manage orders  
-- Transfer funds and claim winnings
 - Get market prices and orderbook data
+- Search markets on Polymarket, Kalshi, Limitless
 
 ## Coding Tools (local)
-You can work with the local filesystem:
-- Read and write files
-- List directories and search with grep
-- Run shell commands
-- Use git for version control
+- read_file, write_file, edit_file, list_dir
+- grep (search), find_files
+- run_command (blocking), start_background_process (non-blocking)
+- git operations
 
-## Guidelines
-- Be concise and helpful
-- When making trades, always confirm details before proceeding
-- Prices on Polymarket are between 0.01 and 0.99 (probabilities)
-- Minimum order value is $1
-- When writing code, follow existing patterns and conventions
-- For dangerous operations (rm, sudo), explain what you're doing
+## IMPORTANT: Background vs Blocking Commands
+
+Use \`start_background_process\` for:
+- Dev servers: npm start, npm run dev, yarn dev, vite, next dev
+- Watch mode: npm run watch, tsc --watch
+- Any server or long-running process
+- Returns immediately with a process ID
 
-You help users build trading bots and agents by combining coding skills with trading capabilities.`;
+Use \`run_command\` for:
+- Quick commands: ls, cat, npm install, npm run build
+- One-time operations that complete quickly
+- Blocks until command finishes
+
+After starting a background process:
+1. Use \`get_process_output(process_id)\` to check if it started correctly
+2. Use \`list_processes()\` to see all running processes
+3. Use \`stop_process(process_id)\` to stop when done
+
+## Guidelines
+- Be concise
+- Prices on Polymarket are 0.01-0.99 (probabilities)
+- For dangerous operations (rm, sudo), explain first`;
 var Agent = class {
   anthropic;
   llmProvider;
@@ -4157,6 +4187,18 @@ ${userMessage}`;
   setHistory(history) {
     this.conversationHistory = history;
   }
+  /**
+   * Get conversation history (alias for getHistory)
+   */
+  getConversationHistory() {
+    return this.getHistory();
+  }
+  /**
+   * Set conversation history (alias for setHistory)
+   */
+  setConversationHistory(history) {
+    this.setHistory(history);
+  }
 };
 function createAgent(config) {
   return new Agent(config);
@@ -4215,10 +4257,204 @@ function tableRow(label, value, width = 20) {
 }
 
 // src/ui/App.tsx
-import { useState, useCallback, useRef, useEffect } from "react";
+import { useState, useCallback, useRef, useEffect, useMemo } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import TextInput from "ink-text-input";
 import Spinner from "ink-spinner";
+
+// src/config/sessions.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync, readFileSync } from "fs";
+var SESSIONS_DIR = join3(homedir2(), ".quantish", "sessions");
+var INDEX_FILE = join3(SESSIONS_DIR, "index.json");
+function ensureSessionsDir() {
+  if (!existsSync2(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${timestamp}-${random}`;
+}
+function loadIndex() {
+  ensureSessionsDir();
+  if (!existsSync2(INDEX_FILE)) {
+    return { lastSessionId: null, sessions: [] };
+  }
+  try {
+    const data = readFileSync(INDEX_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return { lastSessionId: null, sessions: [] };
+  }
+}
+function saveIndex(index) {
+  ensureSessionsDir();
+  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), "utf-8");
+}
+function getSessionPath(id) {
+  return join3(SESSIONS_DIR, `${id}.json`);
+}
+var SessionManager = class {
+  /**
+   * Save a new session or update an existing one
+   */
+  saveSession(messages, model, provider, name, existingId) {
+    ensureSessionsDir();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = existingId || generateSessionId();
+    const sessionName = name || `Session ${(/* @__PURE__ */ new Date()).toLocaleDateString()} ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
+    const session = {
+      id,
+      name: sessionName,
+      createdAt: existingId ? this.getSession(existingId)?.createdAt || now : now,
+      updatedAt: now,
+      messages,
+      model,
+      provider,
+      tokenCount: this.estimateTokenCount(messages)
+    };
+    const sessionPath = getSessionPath(id);
+    writeFileSync(sessionPath, JSON.stringify(session, null, 2), "utf-8");
+    const index = loadIndex();
+    index.lastSessionId = id;
+    const existingIndex = index.sessions.findIndex((s) => s.id === id);
+    const sessionMeta = {
+      id,
+      name: sessionName,
+      createdAt: session.createdAt,
+      updatedAt: now,
+      messageCount: messages.length
+    };
+    if (existingIndex >= 0) {
+      index.sessions[existingIndex] = sessionMeta;
+    } else {
+      index.sessions.unshift(sessionMeta);
+    }
+    if (index.sessions.length > 50) {
+      const toRemove = index.sessions.splice(50);
+      for (const s of toRemove) {
+        try {
+          unlinkSync(getSessionPath(s.id));
+        } catch {
+        }
+      }
+    }
+    saveIndex(index);
+    return session;
+  }
+  /**
+   * Get a session by ID
+   */
+  getSession(id) {
+    const sessionPath = getSessionPath(id);
+    if (!existsSync2(sessionPath)) {
+      return null;
+    }
+    try {
+      const data = readFileSync(sessionPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get the last session
+   */
+  getLastSession() {
+    const index = loadIndex();
+    if (!index.lastSessionId) {
+      return null;
+    }
+    return this.getSession(index.lastSessionId);
+  }
+  /**
+   * Get a session by name
+   */
+  getSessionByName(name) {
+    const index = loadIndex();
+    const session = index.sessions.find(
+      (s) => s.name.toLowerCase() === name.toLowerCase()
+    );
+    if (!session) {
+      return null;
+    }
+    return this.getSession(session.id);
+  }
+  /**
+   * List all sessions
+   */
+  listSessions() {
+    const index = loadIndex();
+    return index.sessions;
+  }
+  /**
+   * Delete a session
+   */
+  deleteSession(id) {
+    const sessionPath = getSessionPath(id);
+    if (!existsSync2(sessionPath)) {
+      return false;
+    }
+    try {
+      unlinkSync(sessionPath);
+      const index = loadIndex();
+      index.sessions = index.sessions.filter((s) => s.id !== id);
+      if (index.lastSessionId === id) {
+        index.lastSessionId = index.sessions[0]?.id || null;
+      }
+      saveIndex(index);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Clear all sessions
+   */
+  clearAllSessions() {
+    ensureSessionsDir();
+    try {
+      const files = readdirSync(SESSIONS_DIR);
+      for (const file of files) {
+        try {
+          unlinkSync(join3(SESSIONS_DIR, file));
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Estimate token count from messages (rough estimate)
+   */
+  estimateTokenCount(messages) {
+    let totalChars = 0;
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        totalChars += msg.content.length;
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if ("text" in block && typeof block.text === "string") {
+            totalChars += block.text.length;
+          }
+        }
+      }
+    }
+    return Math.ceil(totalChars / 4);
+  }
+};
+var sessionManager = null;
+function getSessionManager() {
+  if (!sessionManager) {
+    sessionManager = new SessionManager();
+  }
+  return sessionManager;
+}
+
+// src/ui/App.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 function formatTokenCount(count) {
   if (count < 1e3) return String(count);
@@ -4270,6 +4506,10 @@ function formatResult(result, maxLength = 200) {
   }
   return String(result);
 }
+function cleanModelOutput(text) {
+  if (!text) return text;
+  return text.replace(/<tool_call>/g, "").replace(/<\/tool_call>/g, "").replace(/<arg_key>/g, "").replace(/<\/arg_key>/g, "").replace(/<function_call>/g, "").replace(/<\/function_call>/g, "").trim();
+}
 function App({ agent, onExit }) {
   const { exit } = useApp();
   const [messages, setMessages] = useState([]);
@@ -4291,6 +4531,10 @@ function App({ agent, onExit }) {
   });
   const completedToolCalls = useRef([]);
   const abortController = useRef(null);
+  const [queuedInput, setQueuedInput] = useState("");
+  const [hasQueuedMessage, setHasQueuedMessage] = useState(false);
+  const sessionManager2 = useMemo(() => getSessionManager(), []);
+  const [currentSessionId, setCurrentSessionId] = useState(null);
   const handleSlashCommand = useCallback((command) => {
     const cmd = command.slice(1).toLowerCase().split(" ")[0];
     const args = command.slice(cmd.length + 2).trim();
@@ -4301,20 +4545,34 @@ function App({ agent, onExit }) {
           content: `\u{1F4DA} Available Commands:
 /clear      - Clear conversation history
 /compact    - Summarize conversation (keeps context, saves tokens)
-/model      - Switch model (opus, sonnet, haiku, minimax, deepseek, etc.)
+/model      - Switch model (opus, sonnet, haiku, minimax, etc.)
 /provider   - Switch LLM provider (anthropic, openrouter)
 /cost       - Show session cost breakdown
 /help       - Show this help message
 /tools      - List available tools
 /config     - Show configuration info
+
+\u{1F5C2}\uFE0F Session Commands:
+/save [name] - Save current session
+/resume      - Resume last session
+/sessions    - List saved sessions
+/load <id>   - Load a saved session
+/forget      - Delete all saved sessions
+
+\u{1F4CB} Process Commands:
 /processes  - List running background processes
 /stop <id>  - Stop a background process by ID
 /stopall    - Stop all background processes
+
 /exit       - Exit the CLI
 
 \u2328\uFE0F Keyboard Shortcuts:
-Esc         - Interrupt current generation
-Ctrl+C      - Exit (stops all processes)`
+Esc         - Interrupt current generation (or send queued message)
+Enter       - Queue message while agent is working
+Ctrl+C      - Exit (stops all processes)
+
+\u{1F4A1} Tip: You can type while the agent is working. Press Enter to queue
+        your message. Press Esc to interrupt and send immediately.`
         }]);
         return true;
       case "clear":
@@ -4564,8 +4822,169 @@ Last API Call Cost:
 \u{1F4A1} Tip: Use /model haiku for cheaper operations, /compact to reduce context.`
         }]);
         return true;
+      case "save":
+        try {
+          const conversationHistory = agent.getConversationHistory();
+          if (conversationHistory.length === 0) {
+            setMessages((prev) => [...prev, {
+              role: "system",
+              content: "\u274C Nothing to save - conversation is empty."
+            }]);
+            return true;
+          }
+          const savedSession = sessionManager2.saveSession(
+            conversationHistory,
+            agent.getModel(),
+            agent.getProvider(),
+            args || void 0,
+            currentSessionId || void 0
+          );
+          setCurrentSessionId(savedSession.id);
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u2705 Session saved: "${savedSession.name}"
+   ID: ${savedSession.id}
+   Messages: ${conversationHistory.length}`
+          }]);
+        } catch (err) {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u274C Failed to save session: ${err instanceof Error ? err.message : String(err)}`
+          }]);
+        }
+        return true;
+      case "resume":
+        try {
+          const lastSession = sessionManager2.getLastSession();
+          if (!lastSession) {
+            setMessages((prev) => [...prev, {
+              role: "system",
+              content: "\u274C No previous session to resume."
+            }]);
+            return true;
+          }
+          agent.setConversationHistory(lastSession.messages);
+          agent.setModel(lastSession.model);
+          if (lastSession.provider) {
+            agent.setProvider(lastSession.provider);
+          }
+          setCurrentSessionId(lastSession.id);
+          setMessages([{
+            role: "system",
+            content: `\u2705 Resumed session: "${lastSession.name}"
+   ${lastSession.messages.length} messages loaded
+   Model: ${lastSession.model} (${lastSession.provider})`
+          }]);
+        } catch (err) {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u274C Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
+          }]);
+        }
+        return true;
+      case "sessions":
+        try {
+          const sessions = sessionManager2.listSessions();
+          if (sessions.length === 0) {
+            setMessages((prev) => [...prev, {
+              role: "system",
+              content: "\u{1F4CB} No saved sessions."
+            }]);
+            return true;
+          }
+          const sessionList = sessions.slice(0, 10).map((s, i) => {
+            const isCurrent = s.id === currentSessionId ? " (current)" : "";
+            const date = new Date(s.updatedAt).toLocaleDateString();
+            return `  ${i + 1}. ${s.name}${isCurrent}
+     ID: ${s.id} | ${s.messageCount} msgs | ${date}`;
+          }).join("\n\n");
+          const moreText = sessions.length > 10 ? `
+
+... and ${sessions.length - 10} more` : "";
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u{1F5C2}\uFE0F Saved Sessions:
+
+${sessionList}${moreText}
+
+Use /load <id> to load a session.`
+          }]);
+        } catch (err) {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u274C Failed to list sessions: ${err instanceof Error ? err.message : String(err)}`
+          }]);
+        }
+        return true;
+      case "load":
+        if (!args) {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: "\u2753 Usage: /load <session_id>\n   Use /sessions to see saved sessions."
+          }]);
+          return true;
+        }
+        try {
+          let loadSession = sessionManager2.getSession(args);
+          if (!loadSession) {
+            loadSession = sessionManager2.getSessionByName(args);
+          }
+          if (!loadSession) {
+            setMessages((prev) => [...prev, {
+              role: "system",
+              content: `\u274C Session not found: "${args}"`
+            }]);
+            return true;
+          }
+          agent.setConversationHistory(loadSession.messages);
+          agent.setModel(loadSession.model);
+          if (loadSession.provider) {
+            agent.setProvider(loadSession.provider);
+          }
+          setCurrentSessionId(loadSession.id);
+          setMessages([{
+            role: "system",
+            content: `\u2705 Loaded session: "${loadSession.name}"
+   ${loadSession.messages.length} messages loaded
+   Model: ${loadSession.model} (${loadSession.provider})`
+          }]);
+        } catch (err) {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u274C Failed to load session: ${err instanceof Error ? err.message : String(err)}`
+          }]);
+        }
+        return true;
+      case "forget":
+        try {
+          sessionManager2.clearAllSessions();
+          setCurrentSessionId(null);
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: "\u2705 All sessions deleted."
+          }]);
+        } catch (err) {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u274C Failed to clear sessions: ${err instanceof Error ? err.message : String(err)}`
+          }]);
+        }
+        return true;
       case "exit":
       case "quit":
+        try {
+          const history = agent.getConversationHistory();
+          if (history.length > 0) {
+            sessionManager2.saveSession(
+              history,
+              agent.getModel(),
+              agent.getProvider(),
+              void 0,
+              currentSessionId || void 0
+            );
+          }
+        } catch {
+        }
         if (processManager.hasRunning()) {
           processManager.killAll();
         }
@@ -4582,7 +5001,18 @@ Last API Call Cost:
   }, [agent, onExit, exit]);
   const handleSubmit = useCallback(async (value) => {
     const trimmed = value.trim();
-    if (!trimmed || isProcessing) return;
+    if (!trimmed) return;
+    if (isProcessing) {
+      setQueuedInput(trimmed);
+      setHasQueuedMessage(true);
+      setInput("");
+      setMessages((prev) => [...prev, {
+        role: "system",
+        content: `\u{1F4E5} Queued: "${trimmed.length > 50 ? trimmed.slice(0, 50) + "..." : trimmed}"
+   Press Esc to interrupt and send now.`
+      }]);
+      return;
+    }
     if (trimmed.startsWith("/")) {
       setInput("");
       handleSlashCommand(trimmed);
@@ -4621,9 +5051,10 @@ Last API Call Cost:
       } else {
         setMessages((prev) => {
           const filtered = prev.filter((m) => !m.isStreaming);
+          const cleanedText = cleanModelOutput(result.text || "");
           return [...filtered, {
             role: "assistant",
-            content: result.text || "(completed)",
+            content: cleanedText || "(completed)",
             toolCalls: result.toolCalls.map((tc) => ({
               name: tc.name,
               args: tc.input,
@@ -4637,21 +5068,25 @@ Last API Call Cost:
       setStreamingText("");
       setCurrentToolCalls([]);
     } catch (err) {
-      const errorMsg = err.message || String(err);
+      const errorMsg = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error occurred";
       let displayError = errorMsg;
-      if (errorMsg.includes("aborted") || errorMsg.includes("AbortError")) {
+      const msgLower = errorMsg.toLowerCase();
+      if (msgLower.includes("aborted") || msgLower.includes("aborterror")) {
         setMessages((prev) => [...prev, {
           role: "system",
           content: "\u26A1 Generation interrupted by user."
         }]);
-      } else if (errorMsg.includes("credits exhausted")) {
-        displayError = "Anthropic API credits exhausted. Please add credits at console.anthropic.com";
+      } else if (msgLower.includes("credits exhausted")) {
+        displayError = "API credits exhausted. Please add credits to your provider.";
+        setError(displayError);
+      } else if (msgLower.includes("invalid_api_key") || msgLower.includes("401") || msgLower.includes("unauthorized")) {
+        displayError = 'Invalid API key. Run "quantish init" to reconfigure.';
         setError(displayError);
-      } else if (errorMsg.includes("invalid_api_key") || errorMsg.includes("401")) {
-        displayError = 'Invalid Anthropic API key. Run "quantish init" to reconfigure.';
+      } else if (msgLower.includes("rate_limit") || msgLower.includes("429")) {
+        displayError = "Rate limited. Please wait a moment and try again.";
         setError(displayError);
-      } else if (errorMsg.includes("rate_limit")) {
-        displayError = "Rate limited by Anthropic API. Please wait a moment and try again.";
+      } else if (msgLower.includes("cannot read properties of undefined") || msgLower.includes("undefined")) {
+        displayError = "Tool call parsing error. The model may have sent malformed output.";
         setError(displayError);
       } else {
         setError(displayError);
@@ -4660,8 +5095,16 @@ Last API Call Cost:
       setIsProcessing(false);
       setThinkingText(null);
       abortController.current = null;
+      if (hasQueuedMessage && queuedInput) {
+        const nextMessage = queuedInput;
+        setQueuedInput("");
+        setHasQueuedMessage(false);
+        setTimeout(() => {
+          handleSubmit(nextMessage);
+        }, 100);
+      }
     }
-  }, [agent, isProcessing, isInterrupted, exit, onExit, handleSlashCommand]);
+  }, [agent, isProcessing, isInterrupted, exit, onExit, handleSlashCommand, hasQueuedMessage, queuedInput]);
   useEffect(() => {
     const originalConfig = agent.config;
     agent.config = {
@@ -4669,7 +5112,10 @@ Last API Call Cost:
       streaming: true,
       onText: (text, isComplete) => {
         if (!isComplete) {
-          setStreamingText((prev) => prev + text);
+          const cleanText = text.replace(/<tool_call>/g, "").replace(/<\/tool_call>/g, "").replace(/<arg_key>/g, "").replace(/<\/arg_key>/g, "");
+          if (cleanText) {
+            setStreamingText((prev) => prev + cleanText);
+          }
         }
       },
       onThinking: (text) => {
@@ -4716,10 +5162,17 @@ Stopped ${count} background process${count > 1 ? "es" : ""}.`);
     if (key.escape && isProcessing) {
       setIsInterrupted(true);
       abortController.current?.abort();
-      setMessages((prev) => [...prev, {
-        role: "system",
-        content: "\u26A1 Interrupting..."
-      }]);
+      if (hasQueuedMessage && queuedInput) {
+        setMessages((prev) => [...prev, {
+          role: "system",
+          content: "\u26A1 Interrupting and sending queued message..."
+        }]);
+      } else {
+        setMessages((prev) => [...prev, {
+          role: "system",
+          content: "\u26A1 Interrupting..."
+        }]);
+      }
     }
   });
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
@@ -4796,22 +5249,29 @@ Stopped ${count} background process${count > 1 ? "es" : ""}.`);
         ] })
       ] }, i))
     ] }),
+    hasQueuedMessage && isProcessing && /* @__PURE__ */ jsxs(Box, { marginBottom: 1, paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs(Text, { color: "blue", children: [
+        "\u{1F4E5} Queued: ",
+        queuedInput.length > 40 ? queuedInput.slice(0, 40) + "..." : queuedInput
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: " (Esc to send now)" })
+    ] }),
     /* @__PURE__ */ jsx(
       Box,
       {
         borderStyle: "round",
-        borderColor: isProcessing ? "gray" : "yellow",
+        borderColor: hasQueuedMessage ? "blue" : isProcessing ? "gray" : "yellow",
         paddingX: 1,
         marginTop: 1,
         children: /* @__PURE__ */ jsxs(Box, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: "\u276F " }),
+          /* @__PURE__ */ jsx(Text, { color: hasQueuedMessage ? "blue" : "yellow", bold: true, children: "\u276F " }),
           /* @__PURE__ */ jsx(
             TextInput,
             {
               value: input,
               onChange: setInput,
               onSubmit: handleSubmit,
-              placeholder: isProcessing ? "Processing..." : "Ask anything or type / for commands"
+              placeholder: hasQueuedMessage ? "Message queued. Type more or press Esc to send now." : isProcessing ? "Type to queue a message..." : "Ask anything or type / for commands"
             }
           )
         ] })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantish/agent",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "AI-powered agent for building trading bots on Polymarket",
   "type": "module",
   "bin": {