@alanwchat/coder 0.1.106 → 0.1.108

package/dist/index.cjs

@@ -23,18 +23,12 @@ __export(config_exports, {
   loadConfig: () => loadConfig,
   resolveApiKey: () => resolveApiKey,
   resolveProviderConfig: () => resolveProviderConfig,
+  resolveTavilyApiKey: () => resolveTavilyApiKey,
   saveConfig: () => saveConfig
 });
 function getConfigDir() {
   const home = (0, import_node_os.homedir)();
-  const p = (0, import_node_os.platform)();
-  if (p === "win32") {
-    return process.env.APPDATA ? (0, import_node_path10.join)(process.env.APPDATA, "Coder", "cli") : (0, import_node_path10.join)(home, ".config", "coder", "cli");
-  }
-  if (process.env.XDG_CONFIG_HOME) {
-    return (0, import_node_path10.join)(process.env.XDG_CONFIG_HOME, "coder", "cli");
-  }
-  return (0, import_node_path10.join)(home, ".config", "coder", "cli");
+  return (0, import_node_path10.join)(home, ".coder", "cli");
 }
 function createDefaultProviderSettings(provider) {
   const isCustom = provider === "custom";
@@ -42,8 +36,7 @@ function createDefaultProviderSettings(provider) {
     apiKeySource: "env",
     apiKey: "",
     apiKeyEnvVar: isCustom ? "CUSTOM_API_KEY" : PRESET_PROVIDERS[provider]?.defaultApiKeyEnvVar ?? "API_KEY",
-    customBaseUrl: isCustom ? "https://api.example.com/v1" : "",
-    showUsage: false
+    customBaseUrl: isCustom ? "https://api.example.com/v1" : ""
   };
 }
 function createDefaultConfig() {
@@ -55,7 +48,7 @@ function createDefaultConfig() {
     activeProvider: "deepseek",
     providers,
     lastModel: "deepseek-v4-flash",
-    showUsage: false
+    tavilyApiKey: ""
   };
 }
 function getConfigFilePath() {
@@ -90,9 +83,12 @@ function mergeWithDefaults(raw) {
     activeProvider: PROVIDER_IDS.includes(String(raw.activeProvider ?? "")) ? raw.activeProvider : defaults.activeProvider,
     providers: mergeProviders(raw.providers, defaults.providers),
     lastModel: typeof raw.lastModel === "string" ? raw.lastModel : defaults.lastModel,
-    showUsage: typeof raw.showUsage === "boolean" ? raw.showUsage : defaults.showUsage
+    tavilyApiKey: typeof raw.tavilyApiKey === "string" ? raw.tavilyApiKey : defaults.tavilyApiKey
   };
 }
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function mergeProviders(raw, defaults) {
   const result = { ...defaults };
   if (!raw || typeof raw !== "object") {
@@ -106,7 +102,9 @@ function mergeProviders(raw, defaults) {
         apiKey: typeof p.apiKey === "string" ? p.apiKey : result[id].apiKey,
         apiKeyEnvVar: typeof p.apiKeyEnvVar === "string" ? p.apiKeyEnvVar : result[id].apiKeyEnvVar,
         customBaseUrl: typeof p.customBaseUrl === "string" ? p.customBaseUrl : result[id].customBaseUrl,
-        showUsage: typeof p.showUsage === "boolean" ? p.showUsage : result[id].showUsage
+        ...typeof p.supportsThinking === "boolean" ? { supportsThinking: p.supportsThinking } : {},
+        ...isPlainObject(p.thinkingEnabledParams) ? { thinkingEnabledParams: p.thinkingEnabledParams } : {},
+        ...isPlainObject(p.thinkingDisabledParams) ? { thinkingDisabledParams: p.thinkingDisabledParams } : {}
       };
     }
   }
@@ -166,6 +164,12 @@ function resolveApiKey(resolved) {
   }
   return envValue;
 }
+function resolveTavilyApiKey(config) {
+  if (config.tavilyApiKey.trim()) {
+    return config.tavilyApiKey.trim();
+  }
+  return process.env.TAVILY_API_KEY?.trim() ?? "";
+}
 function getConfigDirPath() {
   return getConfigDir();
 }
@@ -204,7 +208,7 @@ var init_config = __esm({
       ]
     };
     PROVIDER_IDS = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
-    CONFIG_FILE = "config.json";
+    CONFIG_FILE = "settings.json";
   }
 });
 
@@ -491,7 +495,8 @@ var replaceLinesHandler = async (rawArgs, context) => {
       action: "modified",
       bytesWritten: Buffer.byteLength(newContent, "utf-8"),
       linesAdded: replacementLines.length,
-      linesRemoved: endLine - args.start_line + 1
+      linesRemoved: endLine - args.start_line + 1,
+      warning: "Rows may have shifted \u2014 re-read the file with read_file before your next edit."
     });
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
@@ -990,6 +995,27 @@ function readShellLogs(shellId, stream, offset = 0, limit = 4096) {
     truncated: offset + limit < totalBytes
   };
 }
+function killAllShells() {
+  for (const shell of shells.values()) {
+    if (shell.status === "running") {
+      try {
+        shell.process.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+  shells.clear();
+}
+function killShellsByTask(taskId) {
+  for (const [id, shell] of shells) {
+    if (shell.taskId === taskId && shell.status === "running") {
+      try {
+        shell.process.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+}
 
 // src/handlers/shell.ts
 var shellHandler = async (rawArgs, context) => {
@@ -1073,13 +1099,16 @@ var readShellLogsHandler = async (rawArgs, _context) => {
 };
 
 // src/handlers/web-search.ts
+init_config();
 var webSearchHandler = async (rawArgs, _context) => {
   const args = rawArgs;
   if (!args.search_term?.trim()) {
     return toolFailure("web_search", "invalid_arguments", "search_term is required");
   }
+  const config = loadConfig();
+  const tavilyKey = resolveTavilyApiKey(config);
   try {
-    const results = await performWebSearch(args.search_term, args.max_results ?? 5);
+    const results = await performWebSearch(args.search_term, args.max_results ?? 5, tavilyKey);
     return toolSuccess("web_search", {
       query: args.search_term,
       results
@@ -1089,7 +1118,33 @@ var webSearchHandler = async (rawArgs, _context) => {
     return toolFailure("web_search", "search_error", message);
   }
 };
-async function performWebSearch(query, maxResults) {
+async function performWebSearch(query, maxResults, tavilyKey) {
+  if (tavilyKey) {
+    try {
+      const response = await fetch("https://api.tavily.com/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          api_key: tavilyKey,
+          query,
+          max_results: maxResults,
+          search_depth: "basic"
+        }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.results && data.results.length > 0) {
+          return data.results.map((r) => ({
+            title: r.title,
+            url: r.url,
+            snippet: r.content
+          }));
+        }
+      }
+    } catch {
+    }
+  }
   try {
     const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
     const response = await fetch(url, {
@@ -1116,10 +1171,13 @@ async function performWebSearch(query, maxResults) {
         }
       }
     }
+    if (results.length === 0) {
+      throw new Error("No results");
+    }
     return results.slice(0, maxResults);
   } catch {
     throw new Error(
-      "Web search is currently unavailable. Configure a Tavily API key for web search support, or set the TAVILY_API_KEY environment variable."
+      "Web search is currently unavailable. Configure a Tavily API key via `coder config tavilyApiKey <key>` or set the TAVILY_API_KEY environment variable."
     );
   }
 }
@@ -1248,125 +1306,9 @@ var todoWriteHandler = async (rawArgs, context) => {
   });
 };
 
-// src/handlers/plans.ts
+// src/handlers/workspace-tree.ts
 var import_node_fs11 = require("node:fs");
 var import_node_path12 = require("node:path");
-init_config();
-function getPlansDir() {
-  const dir = (0, import_node_path12.join)(getConfigDirPath(), "plans");
-  if (!(0, import_node_fs11.existsSync)(dir)) {
-    (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
-  }
-  return dir;
-}
-function getPlanFilePath(name) {
-  const safeName = name.replace(/[^a-z0-9-_.]/gi, "").toLowerCase();
-  return (0, import_node_path12.join)(getPlansDir(), `${safeName}.json`);
-}
-function readPlanFile(name) {
-  const filePath = getPlanFilePath(name);
-  if (!(0, import_node_fs11.existsSync)(filePath)) return null;
-  try {
-    return JSON.parse((0, import_node_fs11.readFileSync)(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writePlanFile(name, plan) {
-  (0, import_node_fs11.writeFileSync)(getPlanFilePath(name), JSON.stringify(plan, null, 2), "utf-8");
-}
-function deletePlanFile(name) {
-  const filePath = getPlanFilePath(name);
-  if (!(0, import_node_fs11.existsSync)(filePath)) return false;
-  try {
-    (0, import_node_fs11.writeFileSync)(filePath, JSON.stringify({ deleted: true }), "utf-8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function listPlanFiles() {
-  return (0, import_node_fs11.readdirSync)(getPlansDir()).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
-}
-var planCreateHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.name?.trim() || !args.content?.trim()) {
-    return toolFailure("plan_create", "invalid_arguments", "name and content are required");
-  }
-  const name = args.name.trim().toLowerCase().replace(/[^a-z0-9-_.]/gi, "");
-  if (readPlanFile(name)) {
-    return toolFailure("plan_create", "exists", `Plan already exists: ${name}`);
-  }
-  writePlanFile(name, {
-    name,
-    title: args.title?.trim() ?? name,
-    content: args.content.trim(),
-    createdAt: Date.now(),
-    updatedAt: Date.now()
-  });
-  return toolSuccess("plan_create", { name, title: args.title?.trim() ?? name });
-};
-var planReadHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.name?.trim()) {
-    return toolFailure("plan_read", "invalid_arguments", "name is required");
-  }
-  const plan = readPlanFile(args.name.trim());
-  if (!plan) {
-    return toolFailure("plan_read", "not_found", `Plan not found: ${args.name}`);
-  }
-  return toolSuccess("plan_read", plan);
-};
-var planUpdateHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.name?.trim()) {
-    return toolFailure("plan_update", "invalid_arguments", "name is required");
-  }
-  const existing = readPlanFile(args.name.trim());
-  if (!existing) {
-    return toolFailure("plan_update", "not_found", `Plan not found: ${args.name}`);
-  }
-  writePlanFile(args.name.trim(), {
-    ...existing,
-    title: args.title?.trim() ?? existing.title,
-    content: args.content?.trim() ?? existing.content,
-    updatedAt: Date.now()
-  });
-  return toolSuccess("plan_update", { name: args.name.trim() });
-};
-var planEditHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.name?.trim()) {
-    return toolFailure("plan_edit", "invalid_arguments", "name is required");
-  }
-  const existing = readPlanFile(args.name.trim());
-  if (!existing) {
-    return toolFailure("plan_edit", "not_found", `Plan not found: ${args.name}`);
-  }
-  writePlanFile(args.name.trim(), {
-    ...existing,
-    content: existing.content + "\n\n## Edit Instructions\n\n" + (args.instructions?.trim() ?? ""),
-    updatedAt: Date.now()
-  });
-  return toolSuccess("plan_edit", { name: args.name.trim() });
-};
-var planDeleteHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.name?.trim()) {
-    return toolFailure("plan_delete", "invalid_arguments", "name is required");
-  }
-  deletePlanFile(args.name.trim());
-  return toolSuccess("plan_delete", { name: args.name.trim(), deleted: true });
-};
-var planListHandler = async (_rawArgs, _context) => {
-  const names = listPlanFiles();
-  const plans = names.map((name) => readPlanFile(name)).filter((p) => p !== null).map((p) => ({ name: p.name, title: p.title }));
-  return toolSuccess("plan_list", { plans, total: plans.length });
-};
-
-// src/handlers/workspace-tree.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path13 = require("node:path");
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -1412,13 +1354,13 @@ var getWorkspaceTreeHandler = async (rawArgs, context) => {
 };
 function buildTree(rootDir, currentDir, depth) {
   const lines = [];
-  const relPath = (0, import_node_path13.relative)(rootDir, currentDir);
+  const relPath = (0, import_node_path12.relative)(rootDir, currentDir);
   if (depth === 0) {
-    lines.push((0, import_node_path13.relative)(rootDir, currentDir) || ".");
+    lines.push((0, import_node_path12.relative)(rootDir, currentDir) || ".");
   }
   let entries;
   try {
-    entries = (0, import_node_fs12.readdirSync)(currentDir);
+    entries = (0, import_node_fs11.readdirSync)(currentDir);
   } catch {
     return lines;
   }
@@ -1428,9 +1370,9 @@ function buildTree(rootDir, currentDir, depth) {
     if (name.startsWith(".") && depth === 0 && name === ".git") continue;
     if (EXCLUDED_DIRS.has(name)) continue;
     if (name.startsWith(".") && depth > 0) continue;
-    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
     try {
-      const stats = (0, import_node_fs12.statSync)(fullPath);
+      const stats = (0, import_node_fs11.statSync)(fullPath);
       if (stats.isDirectory()) {
         dirs.push(name);
       } else {
@@ -1447,10 +1389,10 @@ function buildTree(rootDir, currentDir, depth) {
     const isLast = i === allEntries.length - 1;
     const prefix = depth === 0 ? isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : "";
     const childPrefix = depth === 0 ? isLast ? "    " : "\u2502   " : "";
-    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
     lines.push(`${prefix}${name}`);
     try {
-      const stats = (0, import_node_fs12.statSync)(fullPath);
+      const stats = (0, import_node_fs11.statSync)(fullPath);
       if (stats.isDirectory()) {
         const childLines = buildTreeFromDepth(rootDir, fullPath, depth + 1, prefix || "", childPrefix);
         lines.push(...childLines);
@@ -1464,7 +1406,7 @@ function buildTreeFromDepth(rootDir, currentDir, depth, parentPrefix, prefix) {
   const lines = [];
   let entries;
   try {
-    entries = (0, import_node_fs12.readdirSync)(currentDir);
+    entries = (0, import_node_fs11.readdirSync)(currentDir);
   } catch {
     return lines;
   }
@@ -1473,9 +1415,9 @@ function buildTreeFromDepth(rootDir, currentDir, depth, parentPrefix, prefix) {
   for (const name of entries) {
     if (EXCLUDED_DIRS.has(name)) continue;
     if (name.startsWith(".")) continue;
-    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
     try {
-      const stats = (0, import_node_fs12.statSync)(fullPath);
+      const stats = (0, import_node_fs11.statSync)(fullPath);
       if (stats.isDirectory()) {
         dirs.push(name);
       } else {
@@ -1493,9 +1435,9 @@ function buildTreeFromDepth(rootDir, currentDir, depth, parentPrefix, prefix) {
     const linePrefix = `${prefix}${isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}`;
     const childPrefix = `${prefix}${isLast ? "    " : "\u2502   "}`;
     lines.push(`${linePrefix}${name}`);
-    const fullPath = (0, import_node_path13.resolve)(currentDir, name);
+    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
     try {
-      const stats = (0, import_node_fs12.statSync)(fullPath);
+      const stats = (0, import_node_fs11.statSync)(fullPath);
       if (stats.isDirectory()) {
         const childLines = buildTreeFromDepth(rootDir, fullPath, depth + 1, "", childPrefix);
         lines.push(...childLines);
@@ -1600,7 +1542,7 @@ var AGENT_TOOL_DEFINITIONS = [
     type: "function",
     function: {
       name: "write_file",
-      description: "Create a new text file. Fails if the file already exists. Use replace_file or edit_file to modify existing files.",
+      description: "Create a new text file. Fails if the file already exists. Use edit_file or replace_lines to modify existing files.",
       parameters: {
         type: "object",
         properties: {
@@ -1617,7 +1559,7 @@ var AGENT_TOOL_DEFINITIONS = [
     type: "function",
     function: {
       name: "replace_file",
-      description: "Replace the entire contents of an existing text file. Use expected_sha256 from read_file to avoid overwriting concurrent changes.",
+      description: "Replace an existing text file with new content. Use as a last resort \u2014 prefer edit_file or replace_lines first.",
       parameters: {
         type: "object",
         properties: {
@@ -1636,7 +1578,7 @@ var AGENT_TOOL_DEFINITIONS = [
     type: "function",
     function: {
       name: "edit_file",
-      description: "Apply a targeted search-and-replace edit to an existing text file. Prefer this over replace_file for small changes.",
+      description: "Apply a search-and-replace edit to an existing text file. The primary file editing tool \u2014 use this first.",
       parameters: {
         type: "object",
         properties: {
@@ -1943,13 +1885,7 @@ var HANDLER_MAP = {
   todo_write: todoWriteHandler,
   get_workspace_tree: getWorkspaceTreeHandler,
   spawn_subagent: spawnSubAgentHandler,
-  ask_question: askQuestionHandler,
-  plan_create: planCreateHandler,
-  plan_read: planReadHandler,
-  plan_update: planUpdateHandler,
-  plan_edit: planEditHandler,
-  plan_delete: planDeleteHandler,
-  plan_list: planListHandler
+  ask_question: askQuestionHandler
 };
 var ASK_QUESTION_TOOL_NAME = "ask_question";
 var AGENT_MODE_EXCLUDED_TOOL_NAMES = /* @__PURE__ */ new Set([
@@ -1973,9 +1909,6 @@ function getToolDefinitions(agentMode) {
       (t) => ASK_MODE_TOOL_NAMES.has(t.function.name)
     );
   }
-  if (agentMode === "plan") {
-    return AGENT_TOOL_DEFINITIONS;
-  }
   return AGENT_TOOL_DEFINITIONS.filter(
     (t) => !AGENT_MODE_EXCLUDED_TOOL_NAMES.has(t.function.name)
   );
@@ -2011,6 +1944,45 @@ async function executeToolCall(name, rawArguments, context) {
   return handler(parsedArgs, context);
 }
 
+// src/agent/thinking-config.ts
+function resolveThinkingParams(provider, thinkingEnabled, override) {
+  if (override) {
+    return thinkingEnabled ? override.enabled : override.disabled;
+  }
+  const preset = THINKING_PRESETS[provider];
+  if (!preset) return void 0;
+  return thinkingEnabled ? preset.enabled : preset.disabled;
+}
+var THINKING_PRESETS = {
+  deepseek: {
+    // @see https://api-docs.deepseek.com/guides/thinking_mode
+    enabled: {
+      thinking: { type: "enabled" },
+      reasoning_effort: "high"
+    },
+    disabled: { thinking: { type: "disabled" } }
+  },
+  glm: {
+    enabled: { thinking: { type: "enabled" } },
+    disabled: { thinking: { type: "disabled" } }
+  },
+  agnes: {
+    enabled: { chat_template_kwargs: { enable_thinking: true } },
+    disabled: {}
+  },
+  nvidia: {
+    enabled: { chat_template_kwargs: { enable_thinking: true } },
+    disabled: { chat_template_kwargs: { enable_thinking: false } }
+  },
+  minimax: {
+    enabled: {
+      thinking: { type: "adaptive" },
+      reasoning_split: true
+    },
+    disabled: { thinking: { type: "disabled" } }
+  }
+};
+
 // src/agent/llm-stream.ts
 function chatCompletionsUrl(baseUrl) {
   const trimmed = baseUrl.trim().replace(/\/+$/, "");
@@ -2031,6 +2003,16 @@ async function startLLMStream(options, callbacks) {
     body.tools = options.tools;
     body.tool_choice = "auto";
   }
+  if (options.thinkingEnabled !== void 0 && options.thinkingProvider) {
+    const thinkingParams = resolveThinkingParams(
+      options.thinkingProvider,
+      options.thinkingEnabled,
+      options.thinkingOverride
+    );
+    if (thinkingParams) {
+      Object.assign(body, thinkingParams);
+    }
+  }
   try {
     const response = await fetch(url, {
       method: "POST",
@@ -2039,7 +2021,8 @@ async function startLLMStream(options, callbacks) {
         "Content-Type": "application/json",
         Accept: "text/event-stream"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: options.signal
     });
     if (!response.ok) {
       const errorBody = await response.text().catch(() => "");
@@ -2056,8 +2039,22 @@ async function startLLMStream(options, callbacks) {
       }
     });
     let hasToolCalls = false;
+    const onAbort = () => {
+      reader.cancel().catch(() => {
+      });
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
     while (true) {
-      const { done, value } = await reader.read();
+      if (options.signal?.aborted) {
+        break;
+      }
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch {
+        break;
+      }
+      const { done, value } = chunk;
       if (done) break;
       buffer += decoder.decode(value, { stream: true });
       while (true) {
@@ -2181,7 +2178,24 @@ async function runAgentWithTools(input, toolContext, onEvent) {
   let messages = [...input.messages];
   let cumulativeUsage;
   while (true) {
-    const turn = await runSingleAgentTurn(input, messages, onEvent);
+    if (input.signal?.aborted) {
+      killShellsByTask(input.taskId);
+      onEvent({ type: "status", taskId: input.taskId, status: "cancelled" });
+      onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage });
+      return messages;
+    }
+    let turn;
+    try {
+      turn = await runSingleAgentTurn(input, messages, onEvent);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        killShellsByTask(input.taskId);
+        onEvent({ type: "status", taskId: input.taskId, status: "cancelled" });
+        onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage });
+        return messages;
+      }
+      throw err;
+    }
     if (turn.usage) {
       cumulativeUsage = cumulativeUsage ? {
         promptTokens: cumulativeUsage.promptTokens + turn.usage.promptTokens,
@@ -2191,14 +2205,14 @@ async function runAgentWithTools(input, toolContext, onEvent) {
     }
     if (turn.toolCalls.length === 0) {
       if (turn.content || turn.reasoningContent) {
-        messages = [
-          ...messages,
-          {
-            role: "assistant",
-            content: turn.content || void 0,
-            reasoning_content: turn.reasoningContent || void 0
-          }
-        ];
+        const assistantMessage = { role: "assistant" };
+        if (turn.content.trim()) {
+          assistantMessage.content = turn.content;
+        }
+        if (turn.reasoningContent.trim()) {
+          assistantMessage.reasoning_content = turn.reasoningContent;
+        }
+        messages = [...messages, assistantMessage];
       }
       onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage ?? turn.usage });
       onEvent({ type: "status", taskId: input.taskId, status: "completed" });
@@ -2219,7 +2233,11 @@ async function runSingleAgentTurn(input, messages, onEvent) {
         apiKey: input.apiKey,
         model: input.model,
         messages,
-        tools: getToolDefinitions(input.agentMode)
+        tools: getToolDefinitions(input.agentMode),
+        thinkingProvider: input.provider,
+        thinkingEnabled: input.thinkingEnabled,
+        thinkingOverride: input.thinkingParams,
+        signal: input.signal
       },
       {
         onContent: (delta) => {
@@ -2329,31 +2347,434 @@ async function appendToolResults(messages, turn, context, onEvent) {
 // src/agent/environment/index.ts
 var import_node_os2 = require("node:os");
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path13 = require("node:path");
+
+// ../src/features/skills/system/registry.ts
+var OPERATING_PRINCIPLES_CONTENT = `# Agent Operating Principles
+
+Your job is to understand the user's intent, make correct changes, verify the result, and communicate accurately.
+
+### Core rules
+
+- Follow the user's request. Do not expand scope without a clear reason.
+- When the request has multiple valid interpretations, state your assumption
+  explicitly and proceed. Only ask when the decision is costly to reverse.
+- Prefer evidence over confidence. Tool output is more reliable than assumptions.
+- Never present guesses as facts. Mark uncertainty plainly when evidence is incomplete.
+- Optimize for user-visible outcomes, not internal activity.
+- Keep changes correct, readable, maintainable, testable, and secure.
+- Do not push commits, rewrite history, or perform destructive actions unless explicitly instructed.
+
+### Decision order
+
+0. Determine whether this is a question, an exploration, or a change request.
+   Answer questions directly; act only on clear instructions.
+1. Understand the request.
+2. Gather only the context needed to act safely.
+3. Plan when the work has meaningful phases.
+4. Modify the smallest surface that solves the problem.
+5. Verify before claiming success.
+6. Report the outcome, verification, and any remaining risk.
+`;
+var CONTEXT_AND_EVIDENCE_CONTENT = `# Context and Evidence
+
+Treat provided context as useful signal, not guaranteed truth.
+
+Do not assume:
+
+- file contents
+- repository structure
+- command output
+- test results
+- git state
+- API behavior
+- web content
+
+Use tools to confirm facts whenever the answer or change depends on them.
+
+### Evidence handling
+
+- Read the relevant file before editing it.
+- Use search results to decide what to inspect, not as a substitute for inspection.
+- Treat shell output, linter output, test output, and git output as source-of-truth for the current workspace state.
+- If evidence contradicts your expectation, update your understanding immediately.
+- If required evidence is unavailable, say what is missing and avoid pretending the task is fully verified.
+`;
+var TOOL_USAGE_CONTENT = `# Tool Usage
+
+Use tools when they provide evidence that would otherwise be guessed.
+
+### Local tools
+
+- Use glob to find files by name pattern.
+- Use grep to search file contents by unique strings, symbols, paths, routes, config keys, or errors.
+- Use shell for builds, tests, git operations, package commands, and repository inspection.
+- Commands run non-interactively. Avoid commands that require interactive input.
+- For long-running commands such as dev servers or watch mode, run shell with \`block_until_ms=0\`, then await the returned \`shell_id\` when needed.
+- Use \`get_workspace_tree\` for a bird's-eye view of the project structure. It respects \`.gitignore\`, excludes large directories (\`node_modules\`, \`.git\`, \`dist\`, etc.) automatically, and paginates like \`read_file\` via \`start_line\` and \`max_lines\`. Prefer this over manually calling \`list_dir\` on every subdirectory.
+- **File editing workflow:** \`edit_file\` (search-and-replace, text-anchored) is the most common file editing tool \u2014 highest priority. If escaping issues arise, fall back to \`replace_lines\` (by line number, read the file again first to avoid line number drift). Last resort: \`replace_file\` (supports both partial and full replacement, but full replacement consumes many tokens \u2014 use sparingly). Use \`write_file\` to create new files. Use \`read_file\`'s \`sha256\` as \`expected_sha256\` for concurrent safety.
+
+### Web and skills
+
+- Use web_search for current or external information, such as version-specific behavior or recent documentation.
+- Use browse_page to read a specific URL after web_search finds a promising primary source.
+- browse_page may not render JavaScript-heavy pages. Quote retrieved content instead of inventing details.
+- Use list_skills to inspect available skills.
+- Use read_skill before following a skill's instructions.
+- Use create_skill only when the user asks to save reusable instructions.
+
+### Failure handling
+
+When a tool fails:
+
+1. Read the error code and message.
+2. Form a new hypothesis.
+3. Adjust the approach.
+
+Do not repeat the same failing action without learning from the failure.
+
+### Shell tools
+
+You have 5 shell tools. Use them together:
+
+- **shell** \u2014 run a command. Set \`block_until_ms=0\` for background mode; returns a \`shell_id\`.
+- **await** \u2014 poll a background shell to completion. Pass the \`shell_id\` from shell.
+- **list_shells** \u2014 list active shells. Default shows running only; use \`status_filter="all"\` to see all states.
+- **read_shell_logs** \u2014 read stdout/stderr from any shell. Paginate with \`offset\` and \`limit\`.
+- **kill_shell** \u2014 kill a running shell by \`shell_id\`. Cannot kill human terminals.
+
+Workflows:
+1. **background + await**: \`shell(cmd, {block_until_ms: 0})\` \u2192 do other work \u2192 \`await({shell_id})\`
+2. **monitor progress**: \`shell(background)\` \u2192 \`read_shell_logs\` to peek \u2192 \`await\` when done
+3. **clean up**: \`list_shells({status_filter: "all"})\` \u2192 \`read_shell_logs\` \u2192 \`kill_shell\` if stuck
+
+**Remote target limitation:** When using \`shell(target: "<alias>")\`, background mode does NOT return a usable \`shell_id\`, so companion tools (\`await\`, \`list_shells\`, \`kill_shell\`, \`read_shell_logs\`) are not supported. Only blocking mode works for remote commands.
+
+### spawn_subagent
+
+Use spawn_subagent for independent tasks that require multi-step exploration, verification, or research.
+
+Do not use it for simple lookups, single-file reads, or tasks that can be completed with a few direct tool calls.
+
+Before spawning, ask:
+1. Is the task independent?
+2. Does it require significant exploration?
+3. Would delegation improve focus?
+
+If not, do the work yourself.
+
+Provide a clear task description and expected output. Sub-agents should return findings, evidence, and uncertainties.
+`;
+var CODE_NAVIGATION_CONTENT = `# Code Navigation
+
+Prefer direct signals over dependency wandering.
+
+### Default flow
+
+\`\`\`text
+search -> inspect -> modify
+\`\`\`
+
+Avoid manually tracing long chains from entry point to imports unless direct search is insufficient.
+
+### Search signals
+
+Search for the most unique signal the target code would contain:
+
+- function or method names: \`calculateTotal\`, \`handleSubmit\`
+- constants or variables: \`MAX_RETRY_COUNT\`, \`workspaceName\`
+- route strings: \`"/api/users"\`, \`"/login"\`
+- framework annotations: \`@RestController\`, \`@Service\`
+- trait, interface, or class names: \`UserRepository\`, \`impl Iterator\`
+- test descriptions: \`"should return 401"\`, \`testShould\`
+- config keys: \`database.url\`, \`logging.level\`
+- model, table, or schema names: \`users\`, \`class User\`
+- exact error messages from logs, tests, or users
+
+### Reading discipline
+
+- Read only files needed to understand or modify the target behavior.
+- Prefer narrow reads around relevant code when files are large.
+- Expand outward only when the local context is insufficient.
+`;
+var TASK_PLANNING_CONTENT = `# Task Planning
+
+Use the task-progress list to make meaningful multi-step work legible.
+
+### Create a task list when
+
+- implementing a feature across exploration, edits, and verification
+- debugging with multiple hypotheses
+- refactoring or migrating several files or layers
+- finishing work with clear phases such as design, implement, test, polish
+- running long work where the user may return later
+
+### Skip a task list for
+
+- short answers or explanations
+- one-command requests
+- a single obvious edit
+- pure exploration questions
+- trivial follow-ups
+
+When unsure, prefer no list over a noisy one.
+
+### Task design
+
+- Write outcome-oriented tasks: "Add OAuth callback validation", not "Read auth file".
+- Keep tasks coarse enough for the user to follow, usually 3-5 items.
+- Keep at most one task in progress.
+- Mark tasks complete as soon as they are actually complete.
+- Rename, add, cancel, or remove tasks when scope changes.
+`;
+var CODE_MODIFICATION_CONTENT = `# Code Modification
+
+Make changes as a maintainer, not as a patch generator.
+
+### Before editing
+
+1. Locate the relevant implementation.
+2. Understand surrounding context.
+3. Identify the smallest change that solves the requested problem.
+
+### Editing rules
+
+- Prefer minimal, targeted changes.
+- Follow existing naming, architecture, formatting, testing, and error-handling patterns.
+- Do not rewrite working code unnecessarily.
+- Do not change unrelated behavior.
+- Do not introduce style-only edits unless requested.
+- Do not remove functionality without a clear reason.
+- Do not overwrite user changes. If the working tree is dirty, work with existing changes instead of reverting them.
+- Use structured APIs or parsers for structured data when available.
+
+### High-risk areas
+
+Be extra careful with authentication, authorization, persistence, migrations, production configuration, secrets, and destructive operations.
+`;
+var VERIFICATION_CONTENT = `# Verification
+
+Do not claim success solely because code was changed.
+
+### After changing code
+
+1. Re-read the changed area when practical.
+2. Review the diff to confirm only intended changes are included.
+3. Before running any verification command, call list_shells first to check whether the user already has a running dev server or relevant process. If one exists, prefer telling the user to reload over starting a new instance. Only run a new verification command when no relevant process is already running.
+4. Run the most relevant verification available.
+5. Report what was verified and what was not.
+
+### Prefer relevant checks
+
+- TypeScript: \`tsc --noEmit\`, framework type checks, or project scripts.
+- Tests: focused tests first, broader suites when risk is high.
+- Builds: run when the change can affect packaging, routing, generated output, or runtime wiring.
+- Linters: run or inspect diagnostics for changed files.
+
+If verification fails, read the error, fix what is in scope, and rerun the relevant check. If verification cannot be run, state that clearly.
+`;
+var GIT_WORKFLOW_CONTENT = `# Git Workflow
+
+Git operations must reflect actual repository state.
+
+### Before committing
+
+- Review \`git status\`.
+- Review \`git diff\` and \`git diff --staged\` as appropriate.
+- Do not assume staged content matches the current task.
+- Do not commit secrets or credentials.
+
+### Staging
+
+- Stage only files related to the intended change.
+- Avoid \`git add .\` and \`git add -A\` unless the user explicitly wants all changes included.
+- Leave unrelated modifications unstaged.
+
+### Commits
+
+- Generate commit messages from staged changes only.
+- Use Conventional Commits: \`type(scope): summary\`.
+- Keep the subject under 72 characters.
+- Keep commits logically coherent.
+
+### Push behavior
+
+- "commit" means commit only.
+- "push" means push only.
+- "commit and push" means both.
+- Never push unless explicitly instructed.
+`;
+var COMMUNICATION_CONTENT = `# Communication
+
+Communicate conclusions, decisions, blockers, and verification results.
+
+### Style
+
+- Be concise and direct.
+- Do not narrate every tool call.
+- Do not reveal hidden chain-of-thought.
+- Do not frame internal activity as an accomplishment.
+- Explain uncertainty and blockers honestly.
+- When reporting completion, include the user-visible result and verification performed.
+
+### Reviews
+
+When the user asks for a review, prioritize findings first:
+
+- correctness bugs
+- security risks
+- behavioral regressions
+- missing tests for meaningful risk
+
+Order findings by severity. If no issues are found, say so and mention residual risk or unrun checks.
+`;
+var CODE_REVIEW_CONTENT = `# Code Review Workflow
+
+Use this workflow when reviewing code rather than implementing changes.
+
+### Review focus
+
+1. Correctness and edge cases.
+2. Security issues such as injection, XSS, authorization gaps, and leaked secrets.
+3. Behavioral regressions.
+4. Error handling and failure modes.
+5. Test coverage for meaningful behavior.
+6. Readability and maintainability when it affects future correctness.
+
+### Feedback format
+
+- Lead with findings, ordered by severity.
+- Cite the specific file or symbol involved.
+- Explain the impact, not just the preference.
+- Keep summaries brief and secondary.
+- If there are no findings, say that clearly and list any verification gaps.
+`;
+var SYSTEM_SKILLS = [
+  {
+    id: "agent-operating-principles",
+    slug: "agent-operating-principles",
+    name: "Agent Operating Principles",
+    description: "Core identity, priorities, and decision order for software engineering agent work.",
+    content: OPERATING_PRINCIPLES_CONTENT,
+    defaultEnabled: true,
+    category: "core"
+  },
+  {
+    id: "context-and-evidence",
+    slug: "context-and-evidence",
+    name: "Context and Evidence",
+    description: "How to treat workspace context, tool output, uncertainty, and evidence before acting.",
+    content: CONTEXT_AND_EVIDENCE_CONTENT,
+    defaultEnabled: true,
+    category: "core"
+  },
+  {
+    id: "tool-usage",
+    slug: "tool-usage",
+    name: "Tool Usage",
+    description: "When and how to use filesystem, shell, web, and skill tools for reliable evidence.",
+    content: TOOL_USAGE_CONTENT,
+    defaultEnabled: true,
+    category: "core"
+  },
+  {
+    id: "code-navigation",
+    slug: "code-navigation",
+    name: "Code Navigation",
+    description: "Search-first navigation rules for locating relevant code without wasting context.",
+    content: CODE_NAVIGATION_CONTENT,
+    defaultEnabled: true,
+    category: "development"
+  },
+  {
+    id: "task-planning",
+    slug: "task-planning",
+    name: "Task Planning",
+    description: "When and how to use the session task-progress list for multi-step work.",
+    content: TASK_PLANNING_CONTENT,
+    defaultEnabled: true,
+    category: "workflow"
+  },
+  {
+    id: "code-modification",
+    slug: "code-modification",
+    name: "Code Modification",
+    description: "Rules for making minimal, maintainable, and project-consistent code changes.",
+    content: CODE_MODIFICATION_CONTENT,
+    defaultEnabled: true,
+    category: "development"
+  },
+  {
+    id: "verification",
+    slug: "verification",
+    name: "Verification",
+    description: "How to validate changes before claiming success and how to report unverified work.",
+    content: VERIFICATION_CONTENT,
+    defaultEnabled: true,
+    category: "workflow"
+  },
+  {
+    id: "git-workflow",
+    slug: "git-workflow",
+    name: "Git Workflow",
+    description: "Safe staging, commit, and push boundaries based on actual git state.",
+    content: GIT_WORKFLOW_CONTENT,
+    defaultEnabled: true,
+    category: "workflow"
+  },
+  {
+    id: "communication",
+    slug: "communication",
+    name: "Communication",
+    description: "How to communicate outcomes, uncertainty, blockers, verification, and review findings.",
+    content: COMMUNICATION_CONTENT,
+    defaultEnabled: true,
+    category: "core"
+  },
+  {
+    id: "code-review",
+    slug: "code-review",
+    name: "Code Review Workflow",
+    description: "Specialized workflow for reviewing code for correctness, security, regressions, and tests.",
+    content: CODE_REVIEW_CONTENT,
+    defaultEnabled: false,
+    category: "review"
+  }
+];
+var slugSet = /* @__PURE__ */ new Set();
+for (const skill of SYSTEM_SKILLS) {
+  if (slugSet.has(skill.slug)) {
+    throw new Error(`Duplicate system skill slug: ${skill.slug}`);
+  }
+  slugSet.add(skill.slug);
+}
+
+// src/agent/environment/index.ts
 function resolveAgentEnvironment(workspaceDir) {
   const os = `${(0, import_node_os2.platform)()} (${(0, import_node_os2.release)()})`;
   const shell = resolveShell();
   const isGitRepository = workspaceDir ? checkIsGitRepository(workspaceDir) : false;
-  const today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-    timeZone: "UTC"
-  });
+  const today = formatToday(/* @__PURE__ */ new Date());
   let agentsMd = null;
   if (workspaceDir) {
-    const agentsMdPath = (0, import_node_path14.resolve)(workspaceDir, "AGENTS.md");
-    if ((0, import_node_fs13.existsSync)(agentsMdPath)) {
-      const content = (0, import_node_fs13.readFileSync)(agentsMdPath, "utf-8");
+    const agentsMdPath = (0, import_node_path13.resolve)(workspaceDir, "AGENTS.md");
+    if ((0, import_node_fs12.existsSync)(agentsMdPath)) {
+      const content = (0, import_node_fs12.readFileSync)(agentsMdPath, "utf-8");
       agentsMd = {
         path: agentsMdPath,
-        content: content.length > 4e3 ? content.slice(0, 4e3) + "\n... [truncated]" : content,
-        truncated: content.length > 4e3
+        content: content.length > 32e3 ? content.slice(0, 32e3) + "\n... [truncated]" : content,
+        truncated: content.length > 32e3
       };
     }
   }
+  const enabledSystemSkills = SYSTEM_SKILLS.filter(
+    (skill) => skill.defaultEnabled
+  ).map((skill) => ({
+    slug: skill.slug,
+    name: skill.name,
+    content: skill.content
+  }));
   return {
     workspaceDir,
     os,
@@ -2361,9 +2782,104 @@ function resolveAgentEnvironment(workspaceDir) {
     isGitRepository,
     today,
     agentsMd,
-    enabledSystemSkills: []
+    enabledSystemSkills
   };
 }
+function buildSystemPrompt(env, agentMode) {
+  const workspaceLine = env.workspaceDir ?? "not selected";
+  const gitLine = env.isGitRepository ? "yes" : env.workspaceDir ? "no" : "unknown";
+  const modeLine = buildModeLine(agentMode);
+  const modeGuidance = buildModeGuidance(agentMode, env.workspaceDir);
+  const allBlocks = [];
+  allBlocks.push(
+    [
+      "You are Coder, a helpful terminal AI assistant.",
+      "",
+      "## Environment",
+      "",
+      `- workspaceDir: ${workspaceLine}`,
+      `- os: ${env.os}`,
+      `- shell: ${env.shell}`,
+      `- gitRepository: ${gitLine}`,
+      `- date: ${env.today}`,
+      `- mode: ${modeLine}`
+    ].join("\n")
+  );
+  allBlocks.push(
+    [
+      "## Communication Rules",
+      "",
+      "1. Reply in the same language the user uses. Be concise, accurate, and friendly.",
+      "2. Do not act unless the user has clearly asked you to. Answering questions, explaining, and analyzing do not require action \u2014 stop before reaching for tools."
+    ].join("\n")
+  );
+  for (const skill of env.enabledSystemSkills) {
+    allBlocks.push(
+      `## ${skill.name}
+
+${stripLeadingMarkdownH1(skill.content)}`
+    );
+  }
+  if (env.agentsMd?.content.trim()) {
+    allBlocks.push(buildProjectInstructionsSection(env.agentsMd));
+  }
+  if (modeGuidance.length > 0) {
+    allBlocks.push(modeGuidance.join("\n"));
+  }
+  return allBlocks.join("\n\n---\n\n");
+}
+function buildModeLine(agentMode) {
+  switch (agentMode) {
+    case "ask":
+      return "ask (read-only: can read files, search code, browse the web, and list skills \u2014 cannot modify files or run shell commands)";
+    default:
+      return "agent (full tool access)";
+  }
+}
+function buildModeGuidance(agentMode, _workspaceDir) {
+  if (agentMode === "ask") {
+    return buildAskModeGuidance();
+  }
+  return [];
+}
+function buildAskModeGuidance() {
+  return [
+    "## Mode Guidance",
+    "",
+    "You are in Ask mode \u2014 you can only read files, search, and browse.",
+    "When the user asks you to modify files, run commands, or perform any write operation:",
+    "  - Explain that the task requires write access.",
+    "  - Tell the user they can switch to Agent mode by using `coder run` instead of `coder ask` to give you full tool access.",
+    `Do NOT silently refuse or just say "I can't do that." Always provide a clear path forward.`
+  ];
+}
+function buildProjectInstructionsSection(agentsMd) {
+  const lines = [
+    "## Project instructions (AGENTS.md)",
+    "",
+    "Follow these project-specific rules when they do not conflict with the user's current message.",
+    agentsMd.content.trimEnd()
+  ];
+  if (agentsMd.truncated) {
+    lines.push(
+      "",
+      `Note: ${agentsMd.path} was truncated to 32 KB. Use read_file on ${agentsMd.path} to read the full file if needed.`
+    );
+  }
+  return lines.join("\n");
+}
+function stripLeadingMarkdownH1(content) {
+  return content.replace(/^#\s+[^\n]+\n+/, "").trim();
+}
+function formatToday(date) {
+  return new Intl.DateTimeFormat("en-CA", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    weekday: "long",
+    timeZoneName: "longOffset"
+  }).format(date);
+}
 function resolveShell() {
   const p = (0, import_node_os2.platform)();
   if (p === "win32") {
@@ -2383,39 +2899,6 @@ function checkIsGitRepository(dir) {
     return false;
   }
 }
-function buildSystemPrompt(env) {
-  const workspaceLine = env.workspaceDir ?? "not selected";
-  const gitLine = env.isGitRepository ? "yes" : env.workspaceDir ? "no" : "unknown";
-  const lines = [
-    "You are Coder, a helpful terminal AI assistant.",
-    "",
-    "## Environment",
-    `- Workspace: ${workspaceLine}`,
-    `- OS: ${env.os}`,
-    `- Shell: ${env.shell}`,
-    `- Git repository: ${gitLine}`,
-    `- Date: ${env.today}`,
-    "",
-    "## Available Tools",
-    "You have access to all standard tools: file operations, shell commands, web search, skills, and more.",
-    "",
-    "## Guidelines",
-    "- Always read files before editing them.",
-    "- Prefer targeted edits over full file replacements.",
-    "- Use shell commands only for builds, tests, git, and non-interactive CLI tasks.",
-    "- When a task requires multiple steps, create a plan first using todo_write.",
-    "- After completing a task, summarize what was done.",
-    "- Use ask_question when you need clarification from the user.",
-    ""
-  ];
-  if (env.agentsMd) {
-    lines.push("## Project Instructions (AGENTS.md)");
-    lines.push("");
-    lines.push(env.agentsMd.content);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
 
 // src/agent/session.ts
 init_config();
@@ -2478,12 +2961,28 @@ async function runAgentSession(prompt, options) {
   const resolvedConfig = resolveProviderConfig(config, providerId);
   const apiKey = resolveApiKey(resolvedConfig);
   const modelId = options.model ?? config.lastModel;
+  const modelDef = resolvedConfig.models.find((m) => m.id === modelId);
+  const supportsThinking = modelDef?.supportsThinking === true || config.providers[resolvedConfig.provider]?.supportsThinking === true;
+  const thinkingEnabled = options.thinking !== void 0 && supportsThinking ? options.thinking : void 0;
+  let thinkingParamsOverride;
+  if (thinkingEnabled !== void 0) {
+    const settings = config.providers[resolvedConfig.provider];
+    if (settings?.thinkingEnabledParams && settings?.thinkingDisabledParams) {
+      thinkingParamsOverride = {
+        enabled: settings.thinkingEnabledParams,
+        disabled: settings.thinkingDisabledParams
+      };
+    }
+  }
   let messages;
   if (options.existingMessages && options.existingMessages.length > 0) {
-    messages = [...options.existingMessages, { role: "user", content: prompt }];
+    messages = [
+      ...sanitizeMessages(options.existingMessages),
+      { role: "user", content: prompt }
+    ];
   } else {
     const env = resolveAgentEnvironment(workspaceDir);
-    const systemPrompt = buildSystemPrompt(env);
+    const systemPrompt = buildSystemPrompt(env, options.agentMode);
     messages = [
       { role: "system", content: systemPrompt },
       { role: "user", content: prompt }
@@ -2494,6 +2993,7 @@ async function runAgentSession(prompt, options) {
   let currentContent = "";
   let currentThinking = "";
   let hasContent = false;
+  let streamStarted = false;
   const toolContext = {
     workspaceDir,
     sessionId: taskId,
@@ -2514,7 +3014,11 @@ async function runAgentSession(prompt, options) {
         apiKeyEnvVar: resolvedConfig.apiKeyEnvVar,
         model: modelId,
         messages,
-        agentMode: options.agentMode
+        agentMode: options.agentMode,
+        provider: providerId,
+        thinkingEnabled,
+        thinkingParams: thinkingParamsOverride,
+        signal: options.signal
       },
       toolContext,
       (event) => {
@@ -2522,25 +3026,34 @@ async function runAgentSession(prompt, options) {
           case "thinking_delta": {
             currentThinking += event.delta;
             if (isStreaming && !hasContent) {
+              if (!streamStarted) {
+                streamStarted = true;
+                writeLine("");
+              }
               writeStream(dim(event.delta));
             }
             break;
           }
           case "content_delta": {
-            if (!hasContent && currentThinking && isStreaming) {
-              writeLine("");
-              hasContent = true;
-            }
-            hasContent = true;
-            currentContent += event.delta;
             if (isStreaming) {
+              if (!streamStarted) {
+                streamStarted = true;
+              }
+              if (!hasContent && currentThinking) {
+                writeLine("");
+              }
+              hasContent = true;
+              currentContent += event.delta;
               writeStream(event.delta);
             }
             break;
           }
           case "tool_call_started": {
             if (isStreaming) {
-              if (hasContent || currentThinking) {
+              if (!streamStarted) {
+                streamStarted = true;
+                writeLine("");
+              } else if (hasContent || currentThinking) {
                 writeLine("");
               }
               writeLine(`${dim("\u{1F527}")} ${bold(event.name)}${dim("...")}`);
@@ -2559,34 +3072,25 @@ async function runAgentSession(prompt, options) {
             if (event.status === "completed") {
               if (isStreaming) {
                 writeLine("");
-                writeLine(success(`
-\u2713 Task completed`));
+                writeLine(success("\u2713 Task completed"));
               } else {
-                writeLine(success(`\u2713 Task completed`));
+                writeLine(success("\u2713 Task completed"));
                 if (currentContent) {
                   writeLine("\n" + currentContent);
                 }
               }
             } else if (event.status === "failed") {
-              writeLine(error(`
-\u2717 Task failed`));
+              writeLine(error(`\u2717 Task failed`));
             } else if (event.status === "cancelled") {
-              writeLine(warning(`
-\u26A0 Task cancelled`));
+              writeLine(warning(`\u26A0 Task cancelled`));
             }
             break;
           }
           case "done": {
-            if (event.usage && config.showUsage) {
-              writeLine(dim(
-                `  Tokens: ${event.usage.promptTokens}\u2191 ${event.usage.completionTokens}\u2193 ${event.usage.totalTokens}\u2211`
-              ));
-            }
             break;
           }
           case "error": {
-            writeLine(error(`
-\u2717 Error: ${event.message}`));
+            writeLine(error(`\u2717 Error: ${event.message}`));
             break;
           }
         }
@@ -2594,11 +3098,19 @@ async function runAgentSession(prompt, options) {
     );
     return finalMessages;
   } catch (err) {
+    killAllShells();
     const message = err instanceof Error ? err.message : String(err);
     writeError(error(`Fatal error: ${message}`));
     process.exit(1);
   }
 }
+function sanitizeMessages(messages) {
+  return messages.filter((msg) => {
+    if (msg.role !== "assistant") return true;
+    const text = typeof msg.content === "string" ? msg.content : void 0;
+    return Boolean(text?.trim()) || Boolean(msg.reasoning_content?.trim()) || Boolean(msg.tool_calls?.length);
+  });
+}
 
 // src/commands/run.ts
 async function runCommand(prompt, options) {
@@ -2620,16 +3132,6 @@ async function askCommand(prompt, options) {
   });
 }
 
-// src/commands/plan.ts
-async function planCommand(prompt, options) {
-  await runAgentSession(prompt, {
-    ...options,
-    agentMode: "plan",
-    workspaceDir: options.workspace ?? process.cwd(),
-    interactive: false
-  });
-}
-
 // src/commands/repl.ts
 var import_node_readline2 = require("node:readline");
 init_config();
@@ -2642,10 +3144,13 @@ async function replCommand(options) {
   writeLine(dim(`  Model: ${config.lastModel || "not set"}`));
   writeLine(dim(`  Provider: ${config.activeProvider}`));
   writeLine(dim(`  Workspace: ${workspaceDir}`));
-  writeLine(dim(`  Type 'exit' or Ctrl+C to quit`));
+  writeLine(dim(`  Type '/help' for commands, '/exit' or Ctrl+C to quit`));
   writeLine(dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   writeLine("");
   let conversationMessages;
+  let thinkingEnabled = true;
+  let abortController = new AbortController();
+  let agentRunning = false;
   const rl = (0, import_node_readline2.createInterface)({
     input: process.stdin,
     output: process.stdout,
@@ -2659,28 +3164,41 @@ async function replCommand(options) {
       rl.prompt();
       return;
     }
-    if (trimmed === "exit" || trimmed === "quit") {
+    if (agentRunning) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "/exit" || trimmed === "/quit") {
       rl.close();
       return;
     }
-    if (trimmed === "clear") {
+    if (trimmed === "/clear") {
       console.clear();
       rl.prompt();
       return;
     }
-    if (trimmed === "help") {
+    if (trimmed === "/new") {
+      conversationMessages = void 0;
+      abortController = new AbortController();
+      writeLine(info("Started a new session. Context has been cleared."));
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "/help") {
       writeLine(bold("\nREPL Commands:"));
-      writeLine("  <prompt>          Ask the agent anything");
-      writeLine("  exit / quit       Exit REPL");
-      writeLine("  clear             Clear screen");
-      writeLine("  help              Show this help");
-      writeLine("  model <id>        Switch model");
+      writeLine("  <prompt>             Ask the agent anything");
+      writeLine("  /exit, /quit         Exit REPL");
+      writeLine("  /clear               Clear screen");
+      writeLine("  /new                 Clear context, start a new session");
+      writeLine("  /help                Show this help");
+      writeLine("  /model <id>          Switch model");
+      writeLine(`  /thinking <on|off>   Toggle deep thinking (currently: ${thinkingEnabled ? "on" : "off"})`);
       writeLine("");
       rl.prompt();
       return;
     }
-    if (trimmed.startsWith("model ")) {
-      const modelId = trimmed.slice(6).trim();
+    if (trimmed.startsWith("/model ")) {
+      const modelId = trimmed.slice(7).trim();
       if (modelId) {
         config.lastModel = modelId;
         const { saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -2690,109 +3208,52 @@ async function replCommand(options) {
       rl.prompt();
       return;
     }
-    rl.pause();
+    if (trimmed.startsWith("/thinking ")) {
+      const value = trimmed.slice(10).trim().toLowerCase();
+      if (value === "on" || value === "true") {
+        thinkingEnabled = true;
+        writeLine(info("Deep thinking: on"));
+      } else if (value === "off" || value === "false") {
+        thinkingEnabled = false;
+        writeLine(info("Deep thinking: off"));
+      } else {
+        writeLine(error(`Usage: /thinking <on|off>  (currently: ${thinkingEnabled ? "on" : "off"})`));
+      }
+      rl.prompt();
+      return;
+    }
+    agentRunning = true;
     try {
       conversationMessages = await runAgentSession(trimmed, {
         agentMode: "agent",
         workspaceDir,
         interactive: true,
-        model: options.model,
-        provider: options.provider,
-        existingMessages: conversationMessages
+        thinking: thinkingEnabled,
+        existingMessages: conversationMessages,
+        signal: abortController.signal
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       writeError(error(`Error: ${message}`));
     }
+    agentRunning = false;
+    abortController = new AbortController();
     writeLine("");
     rl.prompt();
-    rl.resume();
   });
   rl.on("close", () => {
+    killAllShells();
     writeLine(dim("\nGoodbye! \u{1F44B}"));
     process.exit(0);
   });
   rl.on("SIGINT", () => {
-    rl.close();
-  });
-}
-
-// src/commands/init.ts
-init_config();
-var import_node_readline3 = require("node:readline");
-async function initCommand() {
-  writeLine(bold("\nCoder CLI \u2014 Initialization"));
-  writeLine(dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  writeLine(`Config directory: ${getConfigDirPath()}`);
-  writeLine("");
-  const config = loadConfig();
-  writeLine(info("Select your AI provider:"));
-  const providers = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
-  for (let i = 0; i < providers.length; i++) {
-    writeLine(`  ${i + 1}. ${providers[i]}`);
-  }
-  writeLine("");
-  const providerIndex = await askQuestion("Provider number [1]: ");
-  const providerChoice = parseInt(providerIndex || "1", 10);
-  const selectedProvider = providers[Math.max(0, Math.min(providerChoice - 1, providers.length - 1))];
-  config.activeProvider = selectedProvider;
-  writeLine(`  Selected: ${bold(selectedProvider)}`);
-  writeLine("");
-  const providerSettings = config.providers[selectedProvider];
-  const envVar = providerSettings.apiKeyEnvVar;
-  writeLine(info(`API Key Configuration for "${selectedProvider}":`));
-  writeLine(`  You can set the ${bold(envVar)} environment variable,`);
-  writeLine(`  or enter the key directly (stored in config file).`);
-  writeLine("");
-  const source = await askQuestion("Use environment variable? [Y/n]: ");
-  const useEnv = source.toLowerCase() !== "n";
-  if (useEnv) {
-    providerSettings.apiKeySource = "env";
-    writeLine(`  Using ${bold(envVar)} environment variable.`);
-    writeLine(`  Make sure to set it: export ${envVar}=<your-api-key>`);
-  } else {
-    providerSettings.apiKeySource = "manual";
-    const key = await askQuestion("Enter API key: ");
-    if (key.trim()) {
-      providerSettings.apiKey = key.trim();
-      writeLine("  API key saved to config.");
+    if (agentRunning) {
+      abortController.abort();
+      writeLine("");
+      writeLine(warning("\u26A0 Cancelled"));
     } else {
-      writeLine(`  ${error("No key entered. Set it later with: coder config")}`);
-    }
-  }
-  writeLine("");
-  if (selectedProvider === "custom") {
-    const baseUrl = await askQuestion("Custom API base URL: ");
-    if (baseUrl.trim()) {
-      providerSettings.customBaseUrl = baseUrl.trim();
-    }
-  } else {
-    const customUrl = await askQuestion(`Custom base URL (leave empty for default): `);
-    if (customUrl.trim()) {
-      providerSettings.customBaseUrl = customUrl.trim();
-    }
-    writeLine("");
-  }
-  saveConfig(config);
-  writeLine(success("\n\u2713 Configuration saved!"));
-  writeLine(`  Config file: ${getConfigFilePathExplicit()}`);
-  writeLine("");
-  writeLine(info("Quick start:"));
-  writeLine('  coder "What is in this directory?"');
-  writeLine('  coder ask "Explain this code"');
-  writeLine("  coder repl");
-  writeLine("");
-}
-function askQuestion(query) {
-  const rl = (0, import_node_readline3.createInterface)({
-    input: process.stdin,
-    output: process.stderr
-  });
-  return new Promise((resolve12) => {
-    rl.question(query, (answer) => {
       rl.close();
-      resolve12(answer);
-    });
+    }
   });
 }
 
@@ -2820,7 +3281,8 @@ function showConfig(config) {
   writeLine(bold("Active Settings:"));
   writeLine(`  Active provider: ${config.activeProvider}`);
   writeLine(`  Last model:      ${config.lastModel}`);
-  writeLine(`  Show usage:      ${config.showUsage}`);
+  const tavilyKey = resolveTavilyApiKey(config);
+  writeLine(`  Web search:      ${tavilyKey ? "configured" : "not configured (set via coder config tavilyApiKey <key> or TAVILY_API_KEY env var)"}`);
   writeLine("");
   for (const providerId of PROVIDER_IDS2) {
     const p = config.providers[providerId];
@@ -2829,13 +3291,38 @@ function showConfig(config) {
     writeLine(`  API Key Env Var: ${p.apiKeyEnvVar}`);
     writeLine(`  API Key (stored): ${p.apiKey ? "***" : "(not set)"}`);
     writeLine(`  Custom Base URL: ${p.customBaseUrl || "(default)"}`);
+    if (providerId === "custom") {
+      writeLine(`  Deep Thinking:   ${p.supportsThinking ? "supported" : "not declared"}`);
+      if (p.thinkingEnabledParams) {
+        writeLine(`  Thinking (on):   ${JSON.stringify(p.thinkingEnabledParams)}`);
+      }
+      if (p.thinkingDisabledParams) {
+        writeLine(`  Thinking (off):  ${JSON.stringify(p.thinkingDisabledParams)}`);
+      }
+    }
     writeLine("");
   }
   writeLine(dim("To change a value: coder config <key> <value>"));
-  writeLine(dim("Examples:"));
-  writeLine(dim('  coder config activeProvider "deepseek"'));
-  writeLine(dim('  coder config lastModel "deepseek-v4-flash"'));
-  writeLine(dim('  coder config providers.deepseek.apiKeySource "env"'));
+  writeLine(dim(""));
+  writeLine(dim("Quick start \u2014 custom provider:"));
+  writeLine(dim("  coder config activeProvider custom"));
+  writeLine(dim('  coder config providers.custom.customBaseUrl "https://api.openai.com/v1"'));
+  writeLine(dim("  coder config providers.custom.supportsThinking true"));
+  writeLine(dim('  coder config lastModel "gpt-4o"'));
+  writeLine(dim(""));
+  writeLine(dim("  # Way 1: env var (recommended)"));
+  writeLine(dim("  coder config providers.custom.apiKeySource env"));
+  writeLine(dim('  coder config providers.custom.apiKeyEnvVar "OPENAI_API_KEY"'));
+  writeLine(dim("  export OPENAI_API_KEY=sk-xxx"));
+  writeLine(dim(""));
+  writeLine(dim("  # Way 2: stored in config"));
+  writeLine(dim("  coder config providers.custom.apiKeySource manual"));
+  writeLine(dim('  coder config providers.custom.apiKey "sk-xxx"'));
+  writeLine(dim(""));
+  writeLine(dim("View a value:"));
+  writeLine(dim("  coder config activeProvider"));
+  writeLine(dim("  coder config providers.deepseek.customBaseUrl"));
+  writeLine(dim("  coder config providers.custom.thinkingEnabledParams"));
   writeLine("");
 }
 function showConfigValue(config, key) {
@@ -2847,6 +3334,16 @@ function showConfigValue(config, key) {
   writeLine(String(value));
 }
 async function setConfigValue(config, key, value) {
+  if (key === "activeProvider" && !PROVIDER_IDS2.includes(value)) {
+    writeLine(error(`Invalid provider "${value}". Valid providers: ${PROVIDER_IDS2.join(", ")}`));
+    return;
+  }
+  if (key.endsWith(".apiKeySource") || key === "apiKeySource") {
+    if (value !== "env" && value !== "manual") {
+      writeLine(error(`Invalid apiKeySource "${value}". Must be "env" or "manual".`));
+      return;
+    }
+  }
   setNestedValue(config, key, parseValue(value));
   saveConfig(config);
   writeLine(info(`Config updated: ${key} = ${value}`));
@@ -2888,42 +3385,30 @@ function setGlobalOptions(opts) {
 }
 
 // src/index.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path15 = require("node:path");
-var import_node_url = require("node:url");
-var import_meta = {};
-var __dirname = (0, import_node_path15.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-var pkg = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path15.join)(__dirname, "../package.json"), "utf-8"));
-var VERSION = pkg.version;
+var VERSION = "0.1.108";
 async function main() {
   const rawArgs = process.argv.slice(2);
   if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
     printHelp();
     return;
   }
-  if (rawArgs.includes("--version") || rawArgs.includes("-V")) {
+  if (rawArgs.includes("--version") || rawArgs.includes("-v")) {
     console.log(VERSION);
     return;
   }
+  const globalOpts = extractGlobalOptions(rawArgs);
+  setGlobalOptions(globalOpts);
   if (rawArgs.length === 0) {
     await replCommand({});
     return;
   }
-  const globalOpts = extractGlobalOptions(rawArgs);
-  setGlobalOptions(globalOpts);
   const firstNonFlag = rawArgs.find((a) => !a.startsWith("-"));
   const knownSubcommands = {
     ask: async (args, opts) => {
       await askCommand(args.join(" "), opts);
     },
-    plan: async (args, opts) => {
-      await planCommand(args.join(" "), opts);
-    },
-    repl: async () => {
-      await replCommand(globalOpts);
-    },
-    init: async () => {
-      await initCommand();
+    run: async (args, opts) => {
+      await runCommand(args.join(" "), opts);
     },
     config: async (args) => {
       await configCommand(args[0], args[1]);
@@ -2934,54 +3419,47 @@ async function main() {
     await knownSubcommands[firstNonFlag](cmdArgs, globalOpts);
     return;
   }
-  const promptParts = rawArgs.filter((a) => !a.startsWith("-"));
-  const prompt = promptParts.join(" ");
-  if (!prompt.trim()) {
-    await replCommand(globalOpts);
-    return;
-  }
-  await runCommand(prompt, globalOpts);
+  writeLine(error(`Unknown subcommand "${firstNonFlag}".`));
+  writeLine("");
+  writeLine(info("Usage: coder <command> [options] [prompt...]"));
+  writeLine(info("Run 'coder --help' for available commands."));
+  process.exit(1);
 }
 function extractGlobalOptions(args) {
   const opts = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === "-m" || arg === "--model") {
-      opts.model = args[++i] ?? "";
-    } else if (arg === "-p" || arg === "--provider") {
-      opts.provider = args[++i] ?? "";
-    } else if (arg === "-w" || arg === "--workspace") {
+    if (arg === "-w" || arg === "--workspace") {
       opts.workspace = args[++i] ?? "";
-    } else if (arg === "-y" || arg === "--yes") {
-      opts.yes = true;
     } else if (arg === "--no-stream") {
       opts.stream = false;
     } else if (arg === "--stream") {
       opts.stream = true;
+    } else if (arg === "--thinking") {
+      opts.thinking = true;
+    } else if (arg === "--no-thinking") {
+      opts.thinking = false;
     }
   }
   return opts;
 }
 function printHelp() {
   console.log(`
-Usage: coder [options] [prompt...]
+Usage: coder <command> [options] [prompt...]
 
 Coder CLI \u2014 AI-powered coding assistant in the terminal
 
 Options:
-  -V, --version              output the version number
-  -m, --model <model>        Model ID to use
-  -p, --provider <provider>  Provider ID (deepseek, glm, agnes, nvidia, minimax, custom)
+  -v, --version              output the version number
   -w, --workspace <path>     Workspace directory
-  -y, --yes                  Auto-confirm prompts (unattended mode)
-  --no-stream                Disable streaming output
+      --no-stream            Disable streaming output
+      --thinking             Enable deep thinking (for supported models)
+      --no-thinking          Disable deep thinking
   -h, --help                 display help for command
 
 Commands:
   ask [prompt...]            Ask a question (read-only mode)
-  plan [prompt...]           Create or work on a plan
-  repl                       Start interactive REPL session
-  init                       Initialize Coder CLI configuration
+  run [prompt...]            Run in full agent mode (can modify files, run commands)
   config [key] [value]       View or edit configuration
 `);
 }