open-agents-ai 0.11.2 → 0.11.4

package/dist/index.js

@@ -1164,7 +1164,7 @@ var init_shell = __esm({
         const timeout = args["timeout"] ?? this.defaultTimeout;
         const stdinInput = args["stdin"];
         const start = performance.now();
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1217,7 +1217,7 @@ var init_shell = __esm({
               const combined = stdout + stderr;
               const looksInteractive = /\? .+[›>]|y\/n|yes\/no|\(Y\/n\)|\[y\/N\]/i.test(combined);
               const hint = looksInteractive ? " The command appears to be waiting for interactive input. Use non-interactive flags (e.g., --yes, --no-input) or provide input via the stdin parameter." : "";
-              resolve13({
+              resolve14({
                 success: false,
                 output: stdout,
                 error: `Command timed out after ${timeout}ms.${hint}`,
@@ -1226,7 +1226,7 @@ var init_shell = __esm({
               return;
             }
             const success = code === 0;
-            resolve13({
+            resolve14({
               success,
               output: stdout + (stderr && success ? `
 STDERR:
@@ -1237,7 +1237,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve13({
+            resolve14({
               success: false,
               output: stdout,
               error: err.message,
@@ -2919,11 +2919,11 @@ var init_diagnostic = __esm({
         }
         return steps;
       }
-      runStep(step, command, cwd3) {
+      runStep(step, command, cwd4) {
         const start = performance.now();
         try {
           const output = execSync5(command, {
-            cwd: cwd3,
+            cwd: cwd4,
             encoding: "utf8",
             timeout: 12e4,
             stdio: ["pipe", "pipe", "pipe"],
@@ -3066,10 +3066,10 @@ var init_git_info = __esm({
           durationMs: performance.now() - start
         };
       }
-      git(cwd3, cmd) {
+      git(cwd4, cmd) {
         try {
           return execSync6(`git ${cmd}`, {
-            cwd: cwd3,
+            cwd: cwd4,
             encoding: "utf8",
             timeout: 1e4,
             stdio: ["pipe", "pipe", "pipe"]
@@ -3103,10 +3103,10 @@ var init_background_task = __esm({
     BackgroundTaskManager = class {
       tasks = /* @__PURE__ */ new Map();
       nextId = 1;
-      spawn(command, cwd3, timeoutMs = 6e5) {
+      spawn(command, cwd4, timeoutMs = 6e5) {
         const id = `task-${this.nextId++}`;
         const child = spawn2("bash", ["-c", command], {
-          cwd: cwd3,
+          cwd: cwd4,
           env: { ...process.env, CI: "true", NONINTERACTIVE: "1", NO_COLOR: "1" },
           stdio: ["ignore", "pipe", "pipe"],
           detached: false
@@ -6587,7 +6587,8 @@ Commands run non-interactively (CI=true). When running scaffolding tools:
           requestTimeoutMs: options?.requestTimeoutMs ?? 3e5,
           taskTimeoutMs: options?.taskTimeoutMs ?? 12e5,
           compactionThreshold: options?.compactionThreshold ?? 4e4,
-          dynamicContext: options?.dynamicContext ?? ""
+          dynamicContext: options?.dynamicContext ?? "",
+          streamEnabled: options?.streamEnabled ?? false
         };
       }
       /** Register a tool for the agent to use */
@@ -6683,13 +6684,14 @@ Integrate this guidance into your current approach. Continue working on the task
             });
           }
           const compacted = this.compactMessages(messages);
-          const response = await this.backend.chatCompletion({
+          const chatRequest = {
             messages: compacted,
             tools: toolDefs,
             temperature: this.options.temperature,
             maxTokens: this.options.maxTokens,
             timeoutMs: this.options.requestTimeoutMs
-          });
+          };
+          const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           totalTokens += response.usage?.totalTokens ?? 0;
           const choice = response.choices[0];
           if (!choice)
@@ -6916,6 +6918,90 @@ ${summary}
           }
         }));
       }
+      // -------------------------------------------------------------------------
+      // Streaming support — parallel path that emits token events
+      // -------------------------------------------------------------------------
+      /** Check whether the backend supports SSE streaming */
+      hasStreamingSupport() {
+        return typeof this.backend.chatCompletionStream === "function";
+      }
+      /**
+       * Streaming request: calls the SSE endpoint, emits stream events,
+       * assembles and returns the same response format as chatCompletion().
+       * The non-streaming chatCompletion path is NEVER touched by this code.
+       */
+      async streamingRequest(request, turn) {
+        const backend = this.backend;
+        let content = "";
+        let inThinkTag = false;
+        const toolCallAccumulators = /* @__PURE__ */ new Map();
+        this.emit({ type: "stream_start", turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        for await (const chunk of backend.chatCompletionStream(request)) {
+          if (this.aborted)
+            break;
+          if (chunk.type === "content" && chunk.content) {
+            content += chunk.content;
+            let kind = inThinkTag ? "thinking" : "content";
+            const fragment = chunk.content;
+            if (fragment.includes("<think>")) {
+              inThinkTag = true;
+              kind = "thinking";
+            }
+            if (fragment.includes("</think>")) {
+              inThinkTag = false;
+              kind = "content";
+            }
+            this.emit({
+              type: "stream_token",
+              content: fragment,
+              streamKind: kind,
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          if (chunk.type === "tool_call_delta") {
+            const idx = chunk.toolCallIndex ?? 0;
+            if (!toolCallAccumulators.has(idx)) {
+              toolCallAccumulators.set(idx, {
+                id: chunk.toolCallId ?? crypto.randomUUID(),
+                name: chunk.toolCallName ?? "",
+                args: ""
+              });
+            }
+            const acc = toolCallAccumulators.get(idx);
+            if (chunk.toolCallName)
+              acc.name = chunk.toolCallName;
+            if (chunk.toolCallId)
+              acc.id = chunk.toolCallId;
+            if (chunk.toolCallArgs) {
+              acc.args += chunk.toolCallArgs;
+              this.emit({
+                type: "stream_token",
+                content: chunk.toolCallArgs,
+                streamKind: "tool_args",
+                turn,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
+        }
+        this.emit({ type: "stream_end", content, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        const cleanContent = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+        const toolCalls = toolCallAccumulators.size > 0 ? Array.from(toolCallAccumulators.values()).map((tc) => {
+          let args;
+          try {
+            args = JSON.parse(tc.args);
+          } catch {
+            args = { _raw: tc.args };
+          }
+          return { id: tc.id, name: tc.name, arguments: args };
+        }) : void 0;
+        return {
+          choices: [{ message: { content: cleanContent || null, toolCalls } }],
+          usage: void 0
+          // SSE responses typically don't include usage in chunks
+        };
+      }
     };
     OllamaAgenticBackend = class {
       baseUrl;
@@ -6941,7 +7027,9 @@ ${summary}
         });
         if (!resp.ok) {
           const text = await resp.text().catch(() => "");
-          throw new Error(`Ollama HTTP ${resp.status}: ${text.slice(0, 200)}`);
+          const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
+          const detail = isHtml ? `(received HTML error page \u2014 backend may be behind a proxy/CDN that is timing out)` : text.slice(0, 200);
+          throw new Error(`Backend HTTP ${resp.status}: ${detail}`);
         }
         const data = await resp.json();
         const choices = data.choices ?? [];
@@ -6973,6 +7061,79 @@ ${summary}
           usage: usage ? { totalTokens: usage.total_tokens ?? 0 } : void 0
         };
       }
+      /**
+       * SSE streaming variant — yields StreamChunks as tokens arrive.
+       * Uses `stream: true` and `think: true` so thinking tokens are visible.
+       * The existing chatCompletion() method is completely unmodified.
+       */
+      async *chatCompletionStream(request) {
+        const body = {
+          model: this.model,
+          messages: request.messages,
+          tools: request.tools,
+          temperature: request.temperature,
+          max_tokens: request.maxTokens,
+          stream: true,
+          think: true
+        };
+        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(request.timeoutMs)
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
+          const detail = isHtml ? `(received HTML error page \u2014 backend may be behind a proxy/CDN that is timing out)` : text.slice(0, 200);
+          throw new Error(`Backend HTTP ${resp.status}: ${detail}`);
+        }
+        let sseBuffer = "";
+        const decoder = new TextDecoder();
+        for await (const rawChunk of resp.body) {
+          sseBuffer += decoder.decode(rawChunk, { stream: true });
+          const parts = sseBuffer.split("\n\n");
+          sseBuffer = parts.pop();
+          for (const part of parts) {
+            const line = part.trim();
+            if (!line)
+              continue;
+            if (line === "data: [DONE]")
+              return;
+            if (!line.startsWith("data: "))
+              continue;
+            try {
+              const data = JSON.parse(line.slice(6));
+              const choices = data.choices ?? [];
+              const choice = choices[0];
+              if (!choice)
+                continue;
+              const delta = choice.delta;
+              const finishReason = choice.finish_reason;
+              if (delta?.content) {
+                yield { type: "content", content: delta.content };
+              }
+              const tcDeltas = delta?.tool_calls;
+              if (tcDeltas) {
+                for (const tcd of tcDeltas) {
+                  const fn = tcd.function;
+                  yield {
+                    type: "tool_call_delta",
+                    toolCallIndex: tcd.index ?? 0,
+                    toolCallId: tcd.id || void 0,
+                    toolCallName: fn?.name || void 0,
+                    toolCallArgs: fn?.arguments || void 0
+                  };
+                }
+              }
+              if (finishReason) {
+                yield { type: "finish", finishReason };
+              }
+            } catch {
+            }
+          }
+        }
+      }
     };
   }
 });
@@ -7230,6 +7391,7 @@ function renderSlashHelp() {
     ["/update", "Check for updates and auto-install"],
     ["/voice", "Toggle TTS voice feedback (GLaDOS)"],
     ["/voice <model>", "Set voice: glados, overwatch"],
+    ["/stream", "Toggle real-time token streaming (pastel syntax highlighting)"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
     ["/help", "Show this help"],
@@ -7243,6 +7405,14 @@ function renderSlashHelp() {
     process.stdout.write(`  ${c2.cyan(cmd.padEnd(30))} ${c2.dim(desc)}
 `);
   }
+  process.stdout.write(`
+  ${c2.bold("Project-local overrides:")}
+
+`);
+  process.stdout.write(`  ${c2.dim("Append")} ${c2.yellow("--local")} ${c2.dim("to save settings to .oa/settings.json (this project only).")}
+`);
+  process.stdout.write(`  ${c2.dim("Example:")} ${c2.cyan("/model qwen3:32b --local")}  ${c2.dim("/endpoint http://remote:8000/v1 --local")}
+`);
   process.stdout.write(`
   ${c2.bold("Mid-task steering:")}
 
@@ -7499,6 +7669,7 @@ var init_render = __esm({
       "/config",
       "/update",
       "/voice",
+      "/stream",
       "/verbose",
       "/clear",
       "/help",
@@ -7513,7 +7684,9 @@ async function handleSlashCommand(input, ctx) {
   if (!trimmed.startsWith("/"))
     return "not_a_command";
   const [cmd, ...rest] = trimmed.slice(1).split(/\s+/);
-  const arg = rest.join(" ").trim();
+  const hasLocal = rest.includes("--local");
+  const filteredRest = rest.filter((r) => r !== "--local");
+  const arg = filteredRest.join(" ").trim();
   switch (cmd) {
     case "help":
     case "h":
@@ -7531,8 +7704,13 @@ async function handleSlashCommand(input, ctx) {
     case "verbose":
     case "v":
       ctx.setVerbose(!ctx.config.verbose);
-      ctx.saveSettings({ verbose: ctx.config.verbose });
-      renderInfo(`Verbose mode: ${ctx.config.verbose ? "on" : "off"}`);
+      if (hasLocal) {
+        ctx.saveLocalSettings({ verbose: ctx.config.verbose });
+        renderInfo(`Verbose mode: ${ctx.config.verbose ? "on" : "off"} (project-local)`);
+      } else {
+        ctx.saveSettings({ verbose: ctx.config.verbose });
+        renderInfo(`Verbose mode: ${ctx.config.verbose ? "on" : "off"}`);
+      }
       return "handled";
     case "config":
     case "cfg":
@@ -7548,7 +7726,7 @@ async function handleSlashCommand(input, ctx) {
       return "handled";
     case "model":
       if (arg) {
-        await switchModel(arg, ctx);
+        await switchModel(arg, ctx, hasLocal);
       } else {
         await showModelPicker(ctx);
       }
@@ -7558,25 +7736,33 @@ async function handleSlashCommand(input, ctx) {
       return "handled";
     case "endpoint":
     case "ep":
-      await handleEndpoint(arg, ctx);
+      await handleEndpoint(arg, ctx, hasLocal);
       return "handled";
     case "update":
     case "upgrade":
       await handleUpdate();
       return "handled";
     case "voice": {
+      const save = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
       if (arg) {
         const msg = await ctx.voiceSetModel(arg);
-        ctx.saveSettings({ voice: true, voiceModel: arg });
-        renderInfo(msg);
+        save({ voice: true, voiceModel: arg });
+        renderInfo(msg + (hasLocal ? " (project-local)" : ""));
       } else {
         const msg = await ctx.voiceToggle();
         const isOn = msg.toLowerCase().includes("enabled") || msg.toLowerCase().includes("on");
-        ctx.saveSettings({ voice: isOn });
-        renderInfo(msg);
+        save({ voice: isOn });
+        renderInfo(msg + (hasLocal ? " (project-local)" : ""));
       }
       return "handled";
     }
+    case "stream": {
+      const isOn = ctx.streamToggle();
+      const save = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
+      save({ stream: isOn });
+      renderInfo(`Token streaming: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 thinking tokens in grey italics, responses with pastel syntax highlighting" : ""));
+      return "handled";
+    }
     default:
       renderWarning(`Unknown command: /${cmd}. Type /help for available commands.`);
       return "handled";
@@ -7602,7 +7788,7 @@ async function showModelPicker(ctx) {
     renderError(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-async function handleEndpoint(arg, ctx) {
+async function handleEndpoint(arg, ctx, local = false) {
   if (!arg) {
     process.stdout.write(`
   ${c2.bold("Current endpoint:")}
@@ -7665,14 +7851,19 @@ async function handleEndpoint(arg, ctx) {
     renderInfo("Setting endpoint anyway \u2014 it may come online later.");
   }
   ctx.setEndpoint(url, backendType, apiKey);
-  setConfigValue("backendUrl", url);
-  setConfigValue("backendType", backendType);
-  if (apiKey) {
-    setConfigValue("apiKey", apiKey);
+  const endpointSettings = { backendUrl: url, backendType, ...apiKey ? { apiKey } : {} };
+  if (local) {
+    ctx.saveLocalSettings(endpointSettings);
+  } else {
+    setConfigValue("backendUrl", url);
+    setConfigValue("backendType", backendType);
+    if (apiKey) {
+      setConfigValue("apiKey", apiKey);
+    }
+    ctx.saveSettings(endpointSettings);
   }
-  ctx.saveSettings({ backendUrl: url, backendType, ...apiKey ? { apiKey } : {} });
   process.stdout.write(`
-  ${c2.green("\u2714")} Endpoint updated and saved:
+  ${c2.green("\u2714")} Endpoint updated and saved${local ? " (project-local)" : ""}:
 `);
   process.stdout.write(`    ${c2.cyan("URL".padEnd(8))} ${url}
 `);
@@ -7738,7 +7929,7 @@ async function handleUpdate() {
 `);
   restartProcess();
 }
-async function switchModel(query, ctx) {
+async function switchModel(query, ctx, local = false) {
   try {
     const models = await fetchOllamaModels(ctx.config.backendUrl);
     const match = findModel(models, query);
@@ -7752,8 +7943,15 @@ async function switchModel(query, ctx) {
     }
     const oldModel = ctx.config.model;
     ctx.setModel(match.name);
-    ctx.saveSettings({ model: match.name });
+    if (local) {
+      ctx.saveLocalSettings({ model: match.name });
+    } else {
+      ctx.saveSettings({ model: match.name });
+    }
     renderModelSwitch(oldModel, match.name);
+    if (local) {
+      renderInfo("Saved as project-local override.");
+    }
   } catch (err) {
     renderError(`Failed to switch model: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -7856,8 +8054,8 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve13) => {
-    rl.question(question, (answer) => resolve13(answer.trim()));
+  return new Promise((resolve14) => {
+    rl.question(question, (answer) => resolve14(answer.trim()));
   });
 }
 function pullModelWithAutoUpdate(tag) {
@@ -9284,7 +9482,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -9293,16 +9491,16 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve13();
+            resolve14();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve13();
+            resolve14();
           });
           setTimeout(() => {
             this.killPlayback();
-            resolve13();
+            resolve14();
           }, 15e3);
         });
       }
@@ -9472,6 +9670,266 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
   }
 });
 
+// packages/cli/dist/tui/stream-renderer.js
+function fg256(code, text) {
+  return isTTY4 ? `\x1B[38;5;${code}m${text}\x1B[0m` : text;
+}
+function dimText(text) {
+  return isTTY4 ? `\x1B[2m${text}\x1B[0m` : text;
+}
+function dimItalic(text) {
+  return isTTY4 ? `\x1B[2;3m${text}\x1B[0m` : text;
+}
+var isTTY4, PASTEL, StreamRenderer;
+var init_stream_renderer = __esm({
+  "packages/cli/dist/tui/stream-renderer.js"() {
+    "use strict";
+    isTTY4 = process.stdout.isTTY ?? false;
+    PASTEL = {
+      key: 222,
+      // light gold — JSON keys
+      string: 183,
+      // light lavender — "string values"
+      number: 156,
+      // soft green — 42, 3.14
+      boolean: 114,
+      // mint green — true, false
+      null: 109,
+      // grey-blue — null
+      bracket: 75,
+      // soft blue — { } [ ]
+      colon: 245,
+      // neutral grey — : ,
+      keyword: 117,
+      // sky blue — function, return, if, else
+      comment: 243,
+      // dim grey — // comments
+      thinking: 245,
+      // neutral grey for thinking tokens
+      toolArg: 111
+      // dim periwinkle for tool arg tokens
+    };
+    StreamRenderer = class {
+      lineBuffer = "";
+      inThinkBlock = false;
+      inCodeBlock = false;
+      codeLang = "";
+      lineStarted = false;
+      flushTimer = null;
+      enabled = false;
+      tokenCount = 0;
+      startTime = 0;
+      /** Track if we're mid-tool-arg display */
+      inToolArgs = false;
+      /** Called when a new model response starts streaming */
+      onStreamStart() {
+        this.lineBuffer = "";
+        this.inThinkBlock = false;
+        this.inCodeBlock = false;
+        this.codeLang = "";
+        this.lineStarted = false;
+        this.inToolArgs = false;
+        this.enabled = true;
+        this.tokenCount = 0;
+        this.startTime = Date.now();
+        this.cancelFlush();
+      }
+      /**
+       * Feed a streamed token into the renderer.
+       * Tokens are buffered per-line and flushed with syntax highlighting.
+       */
+      write(token, kind) {
+        if (!this.enabled)
+          return;
+        this.tokenCount++;
+        if (kind === "tool_args" && !this.inToolArgs) {
+          this.flushPartial(kind);
+          this.inToolArgs = true;
+        } else if (kind !== "tool_args" && this.inToolArgs) {
+          this.flushPartial(kind);
+          this.inToolArgs = false;
+        }
+        for (const char of token) {
+          this.lineBuffer += char;
+          if (char === "\n") {
+            this.flushLine(kind);
+          }
+        }
+        this.scheduleFlush(kind);
+      }
+      /** Called when streaming ends for this response */
+      onStreamEnd() {
+        if (!this.enabled)
+          return;
+        this.cancelFlush();
+        if (this.lineBuffer.length > 0) {
+          const kind = this.inThinkBlock ? "thinking" : this.inToolArgs ? "tool_args" : "content";
+          this.writeHighlighted(this.lineBuffer, kind);
+          this.lineBuffer = "";
+        }
+        if (this.lineStarted) {
+          process.stdout.write("\n");
+          this.lineStarted = false;
+        }
+        this.enabled = false;
+      }
+      /** Get streaming stats */
+      getStats() {
+        return {
+          tokens: this.tokenCount,
+          durationMs: Date.now() - this.startTime
+        };
+      }
+      // -------------------------------------------------------------------------
+      // Internal rendering
+      // -------------------------------------------------------------------------
+      /**
+       * Flush a complete line (ending with \n) with full syntax highlighting.
+       */
+      flushLine(kind) {
+        const line = this.lineBuffer;
+        this.lineBuffer = "";
+        if (!line || line === "\n") {
+          if (this.lineStarted) {
+            process.stdout.write("\n");
+            this.lineStarted = false;
+          } else {
+            process.stdout.write("\n");
+          }
+          return;
+        }
+        if (line.includes("<think>")) {
+          this.inThinkBlock = true;
+          const after = line.replace(/<think>/g, "");
+          if (after.trim()) {
+            this.writeHighlighted(after, "thinking");
+          }
+          return;
+        }
+        if (line.includes("</think>")) {
+          this.inThinkBlock = false;
+          const after = line.replace(/<\/think>/g, "");
+          if (after.trim()) {
+            this.writeHighlighted(after, "content");
+          }
+          return;
+        }
+        const trimmedLine = line.replace(/\n$/, "");
+        if (trimmedLine.trimStart().startsWith("```")) {
+          if (this.inCodeBlock) {
+            this.writeRaw(dimText("  \u23BF  ") + dimText("```") + "\n");
+            this.inCodeBlock = false;
+            this.codeLang = "";
+            this.lineStarted = false;
+          } else {
+            this.codeLang = trimmedLine.replace(/```/g, "").trim();
+            this.writeRaw(dimText("  \u23BF  ") + dimText("```" + this.codeLang) + "\n");
+            this.inCodeBlock = true;
+            this.lineStarted = false;
+          }
+          return;
+        }
+        const effectiveKind = this.inThinkBlock ? "thinking" : kind;
+        this.writeHighlighted(line, effectiveKind);
+      }
+      /**
+       * Write a highlighted line/fragment to stdout.
+       */
+      writeHighlighted(text, kind) {
+        const raw = text.replace(/\n$/, "");
+        if (!raw)
+          return;
+        const prefix = this.lineStarted ? "" : "  \u23BF  ";
+        let rendered;
+        switch (kind) {
+          case "thinking":
+            rendered = dimItalic(raw);
+            break;
+          case "tool_args":
+            rendered = this.highlightJson(raw, true);
+            break;
+          case "content":
+            if (this.inCodeBlock) {
+              rendered = this.highlightCode(raw);
+            } else if (this.looksLikeJson(raw)) {
+              rendered = this.highlightJson(raw, false);
+            } else {
+              rendered = raw;
+            }
+            break;
+        }
+        const hasNewline = text.endsWith("\n");
+        this.writeRaw(dimText(prefix) + rendered + (hasNewline ? "\n" : ""));
+        this.lineStarted = !hasNewline;
+      }
+      /** Write raw ANSI text to stdout */
+      writeRaw(text) {
+        process.stdout.write(text);
+      }
+      /** Flush partial buffer (non-newline-terminated tokens) */
+      flushPartial(kind) {
+        if (this.lineBuffer.length === 0)
+          return;
+        const effectiveKind = this.inThinkBlock ? "thinking" : kind;
+        this.writeHighlighted(this.lineBuffer, effectiveKind);
+        this.lineBuffer = "";
+      }
+      /** Schedule a timer to flush partial buffer (for streaming smoothness) */
+      scheduleFlush(kind) {
+        this.cancelFlush();
+        this.flushTimer = setTimeout(() => {
+          if (this.lineBuffer.length > 0) {
+            this.flushPartial(kind);
+          }
+        }, 80);
+      }
+      cancelFlush() {
+        if (this.flushTimer) {
+          clearTimeout(this.flushTimer);
+          this.flushTimer = null;
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Syntax highlighting — pastel palette
+      // -------------------------------------------------------------------------
+      /** Check if a string looks like JSON (starts with { [ " or has key: patterns) */
+      looksLikeJson(text) {
+        const trimmed = text.trimStart();
+        return trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.startsWith("}") || trimmed.startsWith("]") || /^\s*"[^"]+"\s*:/.test(trimmed);
+      }
+      /**
+       * Highlight a JSON line with pastel colors.
+       * @param dim If true, apply dimmer colors (for tool args)
+       */
+      highlightJson(line, dim) {
+        const colorKey = dim ? PASTEL.toolArg : PASTEL.key;
+        const colorStr = dim ? PASTEL.toolArg : PASTEL.string;
+        let result = line;
+        result = result.replace(/"([^"]*)"(\s*:)/g, (_m, key, colon) => fg256(colorKey, `"${key}"`) + fg256(PASTEL.colon, colon));
+        result = result.replace(/(:\s*)"([^"]*)"/g, (_m, prefix, val) => fg256(PASTEL.colon, prefix) + fg256(colorStr, `"${val}"`));
+        result = result.replace(/(:\s*)(\d+\.?\d*)/g, (_m, prefix, num) => fg256(PASTEL.colon, prefix) + fg256(PASTEL.number, num));
+        result = result.replace(/(:\s*)(true|false)/g, (_m, prefix, bool) => fg256(PASTEL.colon, prefix) + fg256(PASTEL.boolean, bool));
+        result = result.replace(/(:\s*)(null)/g, (_m, prefix, n) => fg256(PASTEL.colon, prefix) + fg256(PASTEL.null, n));
+        result = result.replace(/([{}[\]])/g, (_m, b) => fg256(PASTEL.bracket, b));
+        return dim ? dimText(result) : result;
+      }
+      /**
+       * Highlight a code line with basic pastel syntax coloring.
+       */
+      highlightCode(line) {
+        let result = line;
+        result = result.replace(/"([^"]*)"/g, (_m, s) => fg256(PASTEL.string, `"${s}"`));
+        result = result.replace(/'([^']*)'/g, (_m, s) => fg256(PASTEL.string, `'${s}'`));
+        result = result.replace(/\b(\d+\.?\d*)\b/g, (_m, n) => fg256(PASTEL.number, n));
+        result = result.replace(/\b(true|false|null|undefined|None|True|False)\b/g, (_m, kw) => fg256(PASTEL.boolean, kw));
+        result = result.replace(/\b(function|const|let|var|return|if|else|for|while|import|export|from|class|async|await|def|self|try|catch|finally|throw|new|typeof|instanceof)\b/g, (_m, kw) => fg256(PASTEL.keyword, kw));
+        result = result.replace(/(\/\/.*$|#.*$)/gm, (_m, c3) => fg256(PASTEL.comment, c3));
+        return result;
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/interactive.js
 import * as readline2 from "node:readline";
 import { cwd } from "node:process";
@@ -9639,7 +10097,7 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice) {
+function startTask(task, config, repoRoot, voice, stream) {
   const projectCtx = buildProjectContext(repoRoot);
   const dynamicContext = formatContextForPrompt(projectCtx);
   const backend = new OllamaAgenticBackend(config.backendUrl.replace(/\/$/, ""), config.model);
@@ -9650,7 +10108,8 @@ function startTask(task, config, repoRoot, voice) {
     requestTimeoutMs: config.timeoutMs,
     taskTimeoutMs: config.timeoutMs * 4,
     compactionThreshold: 4e4,
-    dynamicContext
+    dynamicContext,
+    streamEnabled: stream?.enabled ?? false
   });
   runner.registerTools(buildTools(repoRoot, config));
   runner.onEvent((event) => {
@@ -9674,10 +10133,23 @@ function startTask(task, config, repoRoot, voice) {
         }
         break;
       case "model_response":
-        if (config.verbose && event.content) {
+        if (config.verbose && !stream?.enabled && event.content) {
           renderAssistantText(event.content);
         }
         break;
+      case "stream_start":
+        if (stream?.enabled)
+          stream.renderer.onStreamStart();
+        break;
+      case "stream_token":
+        if (stream?.enabled) {
+          stream.renderer.write(event.content ?? "", event.streamKind ?? "content");
+        }
+        break;
+      case "stream_end":
+        if (stream?.enabled)
+          stream.renderer.onStreamEnd();
+        break;
       case "user_interrupt":
         break;
       case "compaction":
@@ -9739,6 +10211,15 @@ async function startInteractive(config, repoPath) {
     config = { ...config, apiKey: savedSettings.apiKey };
   if (savedSettings.verbose !== void 0)
     config = { ...config, verbose: savedSettings.verbose };
+  if (savedSettings.maxRetries !== void 0)
+    config = { ...config, maxRetries: savedSettings.maxRetries };
+  if (savedSettings.timeoutMs !== void 0)
+    config = { ...config, timeoutMs: savedSettings.timeoutMs };
+  if (savedSettings.dryRun !== void 0)
+    config = { ...config, dryRun: savedSettings.dryRun };
+  if (savedSettings.dbPath)
+    config = { ...config, dbPath: savedSettings.dbPath };
+  let streamEnabled = savedSettings.stream ?? false;
   if (!isResumed) {
     const needsSetup = isFirstRun() || !await isModelAvailable(config);
     if (needsSetup && config.backendType === "ollama") {
@@ -9782,6 +10263,7 @@ async function startInteractive(config, repoPath) {
 `);
   }
   const voiceEngine = new VoiceEngine();
+  const streamRenderer = new StreamRenderer();
   if (savedSettings.voice) {
     voiceEngine.toggle().catch(() => {
     });
@@ -9856,12 +10338,22 @@ async function startInteractive(config, repoPath) {
     async voiceSetModel(id) {
       return voiceEngine.setModel(id);
     },
+    streamToggle() {
+      streamEnabled = !streamEnabled;
+      return streamEnabled;
+    },
     saveSettings(settings) {
       try {
         saveProjectSettings(repoRoot, settings);
         saveGlobalSettings(settings);
       } catch {
       }
+    },
+    saveLocalSettings(settings) {
+      try {
+        saveProjectSettings(repoRoot, settings);
+      } catch {
+      }
     }
   };
   showPrompt();
@@ -9926,7 +10418,10 @@ ${c2.dim("Goodbye!")}
     }
     renderUserMessage(isImage ? `[Image: ${cleanPath}]` : fullInput);
     try {
-      const task = startTask(fullInput, currentConfig, repoRoot, voiceEngine);
+      const task = startTask(fullInput, currentConfig, repoRoot, voiceEngine, {
+        enabled: streamEnabled,
+        renderer: streamRenderer
+      });
       activeTask = task;
       showPrompt();
       await task.promise;
@@ -10022,6 +10517,7 @@ var init_interactive = __esm({
     init_render();
     init_carousel();
     init_voice();
+    init_stream_renderer();
     taskManager = new BackgroundTaskManager();
   }
 });
@@ -10489,8 +10985,17 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join19 } from "node:path";
+import { join as join19, resolve as resolve13 } from "node:path";
 import { homedir as homedir7 } from "node:os";
+import { cwd as cwd3 } from "node:process";
+function coerceForSettings(key, value) {
+  if (INT_KEYS.has(key))
+    return parseInt(value, 10);
+  if (BOOL_KEYS.has(key)) {
+    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+  }
+  return value;
+}
 async function configCommand(opts, config) {
   if (opts.subCommand === "set") {
     return handleSet(opts, config);
@@ -10501,9 +11006,11 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
+  const repoRoot = resolve13(opts.repoPath ?? cwd3());
   printHeader("Configuration");
-  printSection("Active Settings");
+  printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
+  printKeyValue("backendType", config.backendType, 2);
   printKeyValue("model", config.model, 2);
   printKeyValue("apiKey", config.apiKey ? "[set]" : "[not set]", 2);
   printKeyValue("maxRetries", String(config.maxRetries), 2);
@@ -10511,18 +11018,34 @@ function handleShow(opts, config) {
   printKeyValue("dryRun", String(config.dryRun), 2);
   printKeyValue("verbose", String(config.verbose), 2);
   printKeyValue("dbPath", config.dbPath, 2);
+  const projectSettings = loadProjectSettings(repoRoot);
+  const projectKeys = Object.entries(projectSettings).filter(([, v]) => v !== void 0);
+  if (projectKeys.length > 0) {
+    printSection(`Project Overrides (.oa/settings.json)`);
+    for (const [k, v] of projectKeys) {
+      printKeyValue(k, String(v), 2);
+    }
+  } else {
+    printSection("Project Overrides");
+    printInfo("  (none \u2014 use 'config set KEY VALUE --local' to add)");
+  }
+  const globalSettings = loadGlobalSettings();
+  const globalKeys = Object.entries(globalSettings).filter(([, v]) => v !== void 0);
+  if (globalKeys.length > 0) {
+    printSection("Global Settings (~/.open-agents/settings.json)");
+    for (const [k, v] of globalKeys) {
+      printKeyValue(k, String(v), 2);
+    }
+  }
   printSection("Config File");
   printInfo(`~/.open-agents/config.json (${join19(homedir7(), ".open-agents", "config.json")})`);
-  printSection("Environment Variables");
-  printInfo("OPEN_AGENTS_BACKEND_URL  \u2014 override backendUrl");
-  printInfo("OPEN_AGENTS_MODEL        \u2014 override model");
-  printInfo("OPEN_AGENTS_API_KEY      \u2014 override apiKey");
-  printInfo("OPEN_AGENTS_MAX_RETRIES  \u2014 override maxRetries");
-  printInfo("OPEN_AGENTS_TIMEOUT_MS   \u2014 override timeoutMs");
-  printInfo("OPEN_AGENTS_DRY_RUN      \u2014 override dryRun (true/false)");
-  printInfo("OPEN_AGENTS_VERBOSE      \u2014 override verbose (true/false)");
-  printInfo("OPEN_AGENTS_DB_PATH      \u2014 override dbPath");
-  printInfo("VLLM_BASE_URL            \u2014 fallback for backendUrl");
+  printSection("Priority Chain");
+  printInfo("  1. CLI flags (--model, --backend-url, etc.)");
+  printInfo("  2. Project .oa/settings.json (--local)");
+  printInfo("  3. Global ~/.open-agents/settings.json");
+  printInfo("  4. Environment variables (OPEN_AGENTS_*)");
+  printInfo("  5. Global ~/.open-agents/config.json");
+  printInfo("  6. Built-in defaults");
   if (opts.verbose) {
     printSection("All Settable Keys");
     for (const [key, desc] of Object.entries(CONFIG_KEYS)) {
@@ -10533,7 +11056,7 @@ function handleShow(opts, config) {
 function handleSet(opts, _config) {
   const { key, value } = opts;
   if (!key) {
-    printError("Usage: open-agents config set KEY VALUE");
+    printError("Usage: open-agents config set KEY VALUE [--local]");
     printInfo("Run 'open-agents config keys' to see available keys");
     process.exit(1);
   }
@@ -10547,37 +11070,64 @@ function handleSet(opts, _config) {
     printInfo("Run 'open-agents config keys' to see available keys");
     process.exit(1);
   }
-  try {
-    setConfigValue(key, value);
-    printSuccess(`Config updated: ${key} = ${value}`);
-    printInfo(`Saved to ~/.open-agents/config.json`);
-  } catch (err) {
-    printError(`Failed to save config: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
+  if (opts.local) {
+    const repoRoot = resolve13(opts.repoPath ?? cwd3());
+    try {
+      initOaDirectory(repoRoot);
+      const coerced = coerceForSettings(key, value);
+      saveProjectSettings(repoRoot, { [key]: coerced });
+      printSuccess(`Project override set: ${key} = ${value}`);
+      printInfo(`Saved to ${join19(repoRoot, ".oa", "settings.json")}`);
+      printInfo("This override applies only when running in this workspace.");
+    } catch (err) {
+      printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  } else {
+    try {
+      setConfigValue(key, value);
+      printSuccess(`Config updated: ${key} = ${value}`);
+      printInfo(`Saved to ~/.open-agents/config.json`);
+      printInfo("Tip: Use --local to set project-specific overrides.");
+    } catch (err) {
+      printError(`Failed to save config: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
   }
 }
 function handleKeys() {
   printHeader("Config Keys");
+  printInfo("All keys can be set globally or per-project (--local):\n");
   for (const [key, desc] of Object.entries(CONFIG_KEYS)) {
     printKeyValue(key, desc, 2);
   }
+  printInfo("\nUsage:");
+  printInfo("  oa config set model qwen3.5:122b          # global default");
+  printInfo("  oa config set model qwen3.5:122b --local  # this project only");
 }
-var CONFIG_KEYS;
+var CONFIG_KEYS, INT_KEYS, BOOL_KEYS;
 var init_config3 = __esm({
   "packages/cli/dist/commands/config.js"() {
     "use strict";
     init_config();
+    init_oa_directory();
     init_output();
     CONFIG_KEYS = {
-      backendUrl: "vLLM backend base URL",
-      model: "Model name served by vLLM",
+      backendUrl: "Backend base URL (Ollama or OpenAI-compatible)",
+      backendType: "Backend type: ollama, vllm, fake",
+      model: "Model name to use",
       apiKey: "Bearer token for authenticated deployments",
       maxRetries: "Maximum HTTP retries (integer)",
       timeoutMs: "Per-request timeout in milliseconds (integer)",
       dryRun: "Dry-run mode - patches not written (true/false)",
       verbose: "Verbose output (true/false)",
-      dbPath: "Path to SQLite memory database"
+      dbPath: "Path to SQLite memory database",
+      voice: "Enable TTS voice feedback (true/false)",
+      voiceModel: "TTS voice model: glados, overwatch",
+      stream: "Enable real-time token streaming with pastel syntax highlighting (true/false)"
     };
+    INT_KEYS = /* @__PURE__ */ new Set(["maxRetries", "timeoutMs"]);
+    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice", "stream"]);
   }
 });
 
@@ -10678,7 +11228,7 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     const child = spawn3("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
@@ -10713,10 +11263,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve13();
+        resolve14();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve13();
+        resolve14();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -11060,6 +11610,7 @@ function parseCliArgs(argv) {
       "max-retries": { type: "string" },
       "timeout-ms": { type: "string" },
       offline: { type: "boolean" },
+      local: { type: "boolean", short: "l" },
       port: { type: "string" },
       suite: { type: "string" },
       help: { type: "boolean", short: "h" },
@@ -11081,6 +11632,7 @@ function parseCliArgs(argv) {
     maxRetries: typeof values["max-retries"] === "string" ? parseInt(values["max-retries"], 10) : void 0,
     timeoutMs: typeof values["timeout-ms"] === "string" ? parseInt(values["timeout-ms"], 10) : void 0,
     offline: values.offline === true,
+    local: values.local === true,
     help: values.help === true,
     version: values.version === true
   };
@@ -11145,6 +11697,7 @@ Flags:
   -r, --repo <path>          Repository root (default: cwd)
       --dry-run              Validate patches, don't write to disk
       --offline              Use FakeBackend, no backend connection needed
+  -l, --local                Save settings to .oa/settings.json (project-local)
   -v, --verbose              Verbose output
       --max-retries <n>      Max retries per model request
       --timeout-ms <ms>      Overall task timeout
@@ -11239,7 +11792,9 @@ async function main() {
           subCommand: parsed.configSubCommand,
           key: parsed.configKey,
           value: parsed.configValue,
-          verbose: parsed.verbose
+          verbose: parsed.verbose,
+          local: parsed.local,
+          repoPath: parsed.repoPath
         }, config);
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",