cliskill 1.1.1 → 1.1.2

package/dist/{chunk-PRO7DR3G.js → chunk-SDHXIBKZ.js}

@@ -28,8 +28,8 @@ var providerSchema = z.object({
   apiKey: z.string().optional(),
   /** Default model to use */
   model: z.string().min(1),
-  /** API format: "openai-compatible" | "messages-compatible" | "glm-compatible" | "custom" */
-  format: z.enum(["openai-compatible", "messages-compatible", "glm-compatible", "custom"]),
+  /** API format: "openai-compatible" | "messages-compatible" | "glm-compatible" | "anthropic-compatible" | "custom" */
+  format: z.enum(["openai-compatible", "messages-compatible", "glm-compatible", "anthropic-compatible", "custom"]),
   /** Custom headers to send with each request */
   headers: z.record(z.string()).optional(),
   /** Request timeout in milliseconds */
@@ -269,6 +269,36 @@ function applyEnvironmentVariables(config) {
       }];
     }
   }
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.CLISKILL_ANTHROPIC_API_KEY;
+  const anthropicBaseUrl = process.env.ANTHROPIC_BASE_URL || process.env.CLISKILL_ANTHROPIC_BASE_URL;
+  const anthropicModel = process.env.CLISKILL_ANTHROPIC_MODEL;
+  if (anthropicApiKey || anthropicBaseUrl) {
+    const existingAnthropic = result.providers.find((p) => p.format === "anthropic-compatible");
+    if (existingAnthropic) {
+      const updated = { ...existingAnthropic };
+      if (anthropicApiKey) updated.apiKey = anthropicApiKey;
+      if (anthropicBaseUrl) updated.baseUrl = anthropicBaseUrl;
+      if (anthropicModel) updated.model = anthropicModel;
+      result.providers = [
+        updated,
+        ...result.providers.filter((p) => p.format !== "anthropic-compatible")
+      ];
+    } else {
+      const anthropicProvider = {
+        name: "anthropic",
+        baseUrl: anthropicBaseUrl ?? "https://api.anthropic.com",
+        model: anthropicModel ?? "claude-sonnet-4-20250514",
+        format: "anthropic-compatible",
+        apiKey: anthropicApiKey,
+        timeout: 18e4,
+        maxTokens: 65536
+      };
+      result.providers = [...result.providers, anthropicProvider];
+      if (!result.defaultProvider) {
+        result.defaultProvider = "anthropic";
+      }
+    }
+  }
   const envAutoMode = process.env.CLISKILL_AUTO_MODE;
   if (envAutoMode) {
     result.autoMode = {
@@ -457,6 +487,81 @@ var BaseAdapter = class {
 
 // src/connect/generic-adapter.ts
 import { randomUUID } from "crypto";
+
+// src/connect/network-errors.ts
+var NETWORK_ERROR_PATTERNS = [
+  "ECONNRESET",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "WSAETIMEDOUT",
+  "WSAECONNRESET",
+  "WSAECONNABORTED",
+  "fetch failed",
+  "network"
+];
+var ABORT_PATTERNS = [
+  "AbortError",
+  "abort",
+  "Abort",
+  "timeout",
+  "Timeout"
+];
+function isAbortOrNetworkError(err) {
+  const name = err.name ?? "";
+  const msg = err.message ?? "";
+  const code = err.code ?? "";
+  if (name === "AbortError") return true;
+  const combined = `${name} ${msg} ${code}`;
+  for (const pattern of ABORT_PATTERNS) {
+    if (combined.includes(pattern)) return true;
+  }
+  for (const pattern of NETWORK_ERROR_PATTERNS) {
+    if (combined.includes(pattern)) return true;
+  }
+  return false;
+}
+
+// src/connect/sse-parser.ts
+async function* readStreamLines(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let scanFrom = 0;
+  try {
+    while (true) {
+      let done;
+      let value;
+      try {
+        const result = await reader.read();
+        done = result.done;
+        value = result.value;
+      } catch (err) {
+        if (isAbortOrNetworkError(err)) break;
+        throw err;
+      }
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nlIdx;
+      while ((nlIdx = buffer.indexOf("\n", scanFrom)) !== -1) {
+        yield buffer.substring(scanFrom, nlIdx);
+        scanFrom = nlIdx + 1;
+      }
+      if (scanFrom > 0) {
+        buffer = buffer.substring(scanFrom);
+        scanFrom = 0;
+      }
+    }
+    if (buffer.length > 0) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/connect/generic-adapter.ts
 var GenericCompatAdapter = class extends BaseAdapter {
   constructor(config, name) {
     super();
@@ -593,38 +698,15 @@ var GenericCompatAdapter = class extends BaseAdapter {
     };
   }
   async *parseSSEStream(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        let done;
-        let value;
-        try {
-          const result = await reader.read();
-          done = result.done;
-          value = result.value;
-        } catch (err) {
-          if (isAbortOrNetworkError(err)) break;
-          throw err;
-        }
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const json = JSON.parse(trimmed.slice(6));
-            yield* this.processChunk(json);
-          } catch {
-          }
-        }
+    for await (const line of readStreamLines(body)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed === "data: [DONE]") continue;
+      if (!trimmed.startsWith("data: ")) continue;
+      try {
+        const json = JSON.parse(trimmed.slice(6));
+        yield* this.processChunk(json);
+      } catch {
       }
-    } finally {
-      reader.releaseLock();
     }
   }
   /** Track active tool calls: index → { id, name, args } for emitting tool_use_end */
@@ -672,11 +754,252 @@ var GenericCompatAdapter = class extends BaseAdapter {
     }
   }
 };
-function isAbortOrNetworkError(err) {
-  const name = err.name ?? "";
-  const msg = err.message ?? "";
-  return name === "AbortError" || msg.includes("abort") || msg.includes("Abort") || msg.includes("timeout") || msg.includes("Timeout") || msg.includes("fetch failed") || msg.includes("ECONNRESET") || msg.includes("network");
-}
+
+// src/connect/anthropic-adapter.ts
+var ANTHROPIC_VERSION = "2023-06-01";
+var MESSAGES_PATH = "/v1/messages";
+var AnthropicAdapter = class extends BaseAdapter {
+  constructor(config, name) {
+    super();
+    this.config = config;
+    this.name = name ?? `anthropic:${config.model}`;
+  }
+  config;
+  name;
+  async complete(request) {
+    const url = this.buildUrl(MESSAGES_PATH);
+    const body = this.buildRequestBody(request, false);
+    const response = await this.fetchWithRetry(url, () => ({
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify(body),
+      signal: this.buildSignal(request.signal)
+    }));
+    if (!response.ok) {
+      const text = await response.text().catch(() => "unknown error");
+      throw new Error(`Anthropic error (${response.status}): ${text}`);
+    }
+    const data = await response.json();
+    return this.mapResponse(data);
+  }
+  async *stream(request) {
+    const url = this.buildUrl(MESSAGES_PATH);
+    const body = this.buildRequestBody(request, true);
+    const response = await this.fetchWithRetry(url, () => ({
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify(body),
+      signal: this.buildStreamingSignal(request.signal)
+    }));
+    if (!response.ok) {
+      const text = await response.text().catch(() => "unknown error");
+      throw new Error(`Anthropic error (${response.status}): ${text}`);
+    }
+    if (!response.body) throw new Error("No response body for streaming");
+    yield* this.parseSSEStream(response.body);
+  }
+  async validate() {
+    try {
+      const url = this.buildUrl("/v1/models");
+      const response = await fetch(url, {
+        headers: this.buildHeaders(),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) return { ok: false, error: `HTTP ${response.status}` };
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+  dispose() {
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "anthropic-version": ANTHROPIC_VERSION,
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["x-api-key"] = this.config.apiKey;
+    }
+    return headers;
+  }
+  buildRequestBody(request, stream) {
+    const messages = [];
+    for (const msg of request.messages) {
+      const mapped = this.mapMessage(msg);
+      if (mapped) messages.push(...mapped);
+    }
+    const body = {
+      model: this.config.model,
+      messages,
+      max_tokens: request.maxTokens ?? this.config.maxTokens,
+      temperature: request.temperature,
+      stream
+    };
+    if (request.systemPrompt) {
+      body.system = request.systemPrompt;
+    }
+    if (request.stopSequences && request.stopSequences.length > 0) {
+      body.stop_sequences = request.stopSequences;
+    }
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map(this.mapTool);
+    }
+    return body;
+  }
+  mapMessage(msg) {
+    const textParts = msg.content.filter((b) => b.type === "text");
+    const toolUseParts = msg.content.filter((b) => b.type === "tool_use");
+    const toolResultParts = msg.content.filter((b) => b.type === "tool_result");
+    if (msg.role === "system") {
+      return null;
+    }
+    if (msg.role === "assistant") {
+      const blocks = [];
+      const textContent2 = textParts.map((t) => t.text).join("");
+      if (textContent2) {
+        blocks.push({ type: "text", text: textContent2 });
+      }
+      for (const tc of toolUseParts) {
+        blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+      }
+      return [{ role: "assistant", content: blocks.length > 0 ? blocks : "" }];
+    }
+    if (toolResultParts.length > 0) {
+      const blocks = [];
+      for (const result of toolResultParts) {
+        const sanitizedContent = result.content.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "") || "(empty output)";
+        blocks.push({ type: "tool_result", tool_use_id: result.toolUseId, content: sanitizedContent });
+      }
+      const textContent2 = textParts.map((t) => t.text).join("");
+      if (textContent2) {
+        blocks.unshift({ type: "text", text: textContent2 });
+      }
+      return [{ role: "user", content: blocks }];
+    }
+    const textContent = textParts.map((t) => t.text).join("");
+    return [{ role: msg.role, content: textContent || "" }];
+  }
+  mapTool(tool) {
+    return {
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    };
+  }
+  mapResponse(data) {
+    const contentBlocks = [];
+    for (const block of data.content) {
+      if (block.type === "text") {
+        contentBlocks.push({ type: "text", text: block.text });
+      } else if (block.type === "tool_use") {
+        contentBlocks.push({
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        });
+      }
+    }
+    return {
+      message: { role: "assistant", content: contentBlocks },
+      stopReason: data.stop_reason ?? "end_turn",
+      usage: {
+        inputTokens: data.usage?.input_tokens ?? 0,
+        outputTokens: data.usage?.output_tokens ?? 0,
+        cacheReadTokens: data.usage?.cache_read_input_tokens,
+        cacheWriteTokens: data.usage?.cache_creation_input_tokens
+      },
+      model: data.model
+    };
+  }
+  async *parseSSEStream(body) {
+    let currentModel = "";
+    let currentToolId = "";
+    let currentToolName = "";
+    let toolInputBuffer = "";
+    for await (const line of readStreamLines(body)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("event:")) continue;
+      if (!trimmed.startsWith("data:")) continue;
+      const jsonStr = trimmed.slice(6).trim();
+      if (!jsonStr) continue;
+      let event;
+      try {
+        event = JSON.parse(jsonStr);
+      } catch {
+        continue;
+      }
+      switch (event.type) {
+        case "message_start": {
+          if (event.message) {
+            currentModel = event.message.model ?? "";
+            yield { type: "message_start", model: currentModel };
+          }
+          break;
+        }
+        case "content_block_start": {
+          const block = event.content_block;
+          if (block?.type === "tool_use") {
+            currentToolId = block.id ?? "";
+            currentToolName = block.name ?? "";
+            toolInputBuffer = "";
+            yield { type: "tool_use_start", id: currentToolId, name: currentToolName };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const delta = event.delta;
+          if (!delta) break;
+          if (delta.type === "text_delta" && delta.text) {
+            yield { type: "text_delta", text: delta.text };
+          } else if (delta.type === "input_json_delta" && delta.partial_json) {
+            toolInputBuffer += delta.partial_json;
+            yield { type: "tool_use_delta", id: currentToolId, inputDelta: delta.partial_json };
+          }
+          break;
+        }
+        case "content_block_stop": {
+          if (currentToolId && currentToolName) {
+            let input = {};
+            try {
+              input = JSON.parse(toolInputBuffer || "{}");
+            } catch {
+            }
+            yield { type: "tool_use_end", id: currentToolId, name: currentToolName, input };
+            currentToolId = "";
+            currentToolName = "";
+            toolInputBuffer = "";
+          }
+          break;
+        }
+        case "message_delta": {
+          const delta = event.delta;
+          if (delta?.stop_reason) {
+            const usage = event.usage ?? { output_tokens: 0 };
+            yield {
+              type: "message_end",
+              stopReason: delta.stop_reason,
+              usage: { inputTokens: 0, outputTokens: usage.output_tokens }
+            };
+          }
+          break;
+        }
+        case "message_stop": {
+          break;
+        }
+        case "ping": {
+          break;
+        }
+        case "error": {
+          const errorData = event;
+          throw new Error(`Anthropic stream error: ${errorData.error?.message ?? "unknown"}`);
+        }
+      }
+    }
+  }
+};
 
 // src/connect/glm-adapter.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -831,38 +1154,15 @@ var GLMAdapter = class extends BaseAdapter {
     };
   }
   async *parseSSEStream(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        let done;
-        let value;
-        try {
-          const result = await reader.read();
-          done = result.done;
-          value = result.value;
-        } catch (err) {
-          if (isAbortOrNetworkError2(err)) break;
-          throw err;
-        }
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const json = JSON.parse(trimmed.slice(6));
-            yield* this.processChunk(json);
-          } catch {
-          }
-        }
+    for await (const line of readStreamLines(body)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed === "data: [DONE]") continue;
+      if (!trimmed.startsWith("data: ")) continue;
+      try {
+        const json = JSON.parse(trimmed.slice(6));
+        yield* this.processChunk(json);
+      } catch {
       }
-    } finally {
-      reader.releaseLock();
     }
   }
   /** Track active tool calls: index → { id, name, args } for emitting tool_use_end */
@@ -917,11 +1217,6 @@ var GLMAdapter = class extends BaseAdapter {
     }
   }
 };
-function isAbortOrNetworkError2(err) {
-  const name = err.name ?? "";
-  const msg = err.message ?? "";
-  return name === "AbortError" || msg.includes("abort") || msg.includes("Abort") || msg.includes("timeout") || msg.includes("Timeout") || msg.includes("fetch failed") || msg.includes("ECONNRESET") || msg.includes("network");
-}
 
 // src/connect/registry.ts
 var AdapterRegistry = class {
@@ -955,6 +1250,8 @@ var AdapterRegistry = class {
         return new GenericCompatAdapter(config);
       case "glm-compatible":
         return new GLMAdapter(config);
+      case "anthropic-compatible":
+        return new AnthropicAdapter(config);
       case "custom":
         throw new Error(`Custom provider format requires a custom adapter for "${config.name}".`);
       default:
@@ -8031,109 +8328,208 @@ function buildSystemPrompt() {
 // src/mcp/client.ts
 import { spawn as spawn2 } from "child_process";
 import { createInterface } from "readline";
-var REQUEST_TIMEOUT = 3e4;
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var CONNECT_TIMEOUT = 3e4;
+var MCP_PROTOCOL_VERSION = "2024-11-05";
 var MCPClient = class {
   config;
   process = null;
   rl = null;
-  connected = false;
+  connectionState = "disconnected";
   nextId = 1;
   pendingRequests = /* @__PURE__ */ new Map();
-  buffer = "";
+  serverCapabilities = {};
+  serverInfo;
+  serverInstructions;
+  connectReject = null;
   constructor(config) {
     this.config = config;
   }
   async connect() {
-    if (this.connected) return;
-    const env = {
-      ...process.env,
-      ...this.config.env
-    };
-    this.process = spawn2(this.config.command, this.config.args, {
-      stdio: ["pipe", "pipe", "pipe"],
-      env
-    });
-    this.process.on("error", (err) => {
-      this.cleanup();
-      throw err;
-    });
-    this.process.on("exit", () => {
-      this.cleanup();
-    });
-    if (!this.process.stdout) {
-      throw new Error("MCP server stdout is not available");
+    if (this.connectionState === "connected") return;
+    if (this.connectionState === "connecting") {
+      throw new Error(`MCP server "${this.config.name}" is already connecting`);
     }
-    this.rl = createInterface({ input: this.process.stdout });
-    this.rl.on("line", (line) => {
-      this.handleLine(line);
-    });
-    if (this.process.stderr) {
-      this.process.stderr.on("data", () => {
-      });
+    this.connectionState = "connecting";
+    try {
+      await this.spawnProcess();
+      await this.performHandshake();
+      this.connectionState = "connected";
+    } catch (error) {
+      this.cleanup();
+      this.connectionState = "failed";
+      throw error;
     }
-    await this.sendRequest("initialize", {
-      protocolVersion: "2024-11-05",
-      capabilities: {},
-      clientInfo: { name: "cliskill", version: "1.0.0" }
-    });
-    this.sendNotification("notifications/initialized", {});
-    this.connected = true;
   }
   async disconnect() {
-    if (!this.process) return;
+    if (this.connectionState === "disconnected") return;
     for (const [, pending] of this.pendingRequests) {
       clearTimeout(pending.timer);
       pending.reject(new Error("Connection closed"));
     }
     this.pendingRequests.clear();
-    this.process.kill("SIGTERM");
+    if (this.process != null && !this.process.killed) {
+      try {
+        this.process.kill("SIGTERM");
+        await new Promise((resolve10) => {
+          if (!this.process) {
+            resolve10();
+            return;
+          }
+          const forceKillTimer = setTimeout(() => {
+            try {
+              this.process?.kill("SIGKILL");
+            } catch {
+            }
+            resolve10();
+          }, 5e3);
+          this.process.once("exit", () => {
+            clearTimeout(forceKillTimer);
+            resolve10();
+          });
+        });
+      } catch {
+      }
+    }
     this.cleanup();
   }
   async listTools() {
     const response = await this.sendRequest("tools/list", {});
+    this.assertNoError(response);
     const result = response.result;
     return result?.tools ?? [];
   }
   async callTool(name, args) {
     const response = await this.sendRequest("tools/call", { name, arguments: args });
-    return response.result;
+    this.assertNoError(response);
+    const result = response.result;
+    return result ?? { content: [{ type: "text", text: "No result from MCP server" }] };
   }
   async listResources() {
     const response = await this.sendRequest("resources/list", {});
+    this.assertNoError(response);
     const result = response.result;
     return result?.resources ?? [];
   }
   async readResource(uri) {
     const response = await this.sendRequest("resources/read", { uri });
+    this.assertNoError(response);
     return response.result;
   }
   async listPrompts() {
     const response = await this.sendRequest("prompts/list", {});
+    this.assertNoError(response);
     const result = response.result;
     return result?.prompts ?? [];
   }
   isConnected() {
-    return this.connected;
+    return this.connectionState === "connected";
+  }
+  getState() {
+    return this.connectionState;
+  }
+  getServerInfo() {
+    return this.serverInfo;
+  }
+  getServerInstructions() {
+    return this.serverInstructions;
+  }
+  getCapabilities() {
+    return this.serverCapabilities;
+  }
+  getConfig() {
+    return this.config;
+  }
+  async spawnProcess() {
+    const env = {
+      ...process.env,
+      ...this.config.env
+    };
+    this.process = spawn2(this.config.command, this.config.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    this.process.on("error", (err) => {
+      this.handleProcessError(err);
+    });
+    this.process.on("exit", (code, signal) => {
+      if (this.connectionState === "connected" || this.connectionState === "connecting") {
+        this.handleProcessExit(code, signal);
+      }
+    });
+    if (!this.process.stdout) {
+      throw new Error(`MCP server "${this.config.name}": stdout is not available`);
+    }
+    if (!this.process.stdin) {
+      throw new Error(`MCP server "${this.config.name}": stdin is not available`);
+    }
+    this.rl = createInterface({ input: this.process.stdout });
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    if (this.process.stderr) {
+      this.process.stderr.on("data", (data) => {
+        const text = data.toString().trim();
+        if (text) {
+          console.error(`[MCP:${this.config.name}:stderr] ${text}`);
+        }
+      });
+    }
+  }
+  async performHandshake() {
+    const connectPromise = this.sendRequest("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: "cliskill", version: "1.0.0" }
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(
+          `MCP server "${this.config.name}" connection timed out after ${CONNECT_TIMEOUT}ms`
+        ));
+      }, CONNECT_TIMEOUT);
+      timer.unref();
+    });
+    const response = await Promise.race([connectPromise, timeoutPromise]);
+    this.assertNoError(response);
+    const initResult = response.result;
+    if (!initResult) {
+      throw new Error(`MCP server "${this.config.name}" returned empty initialize result`);
+    }
+    if (initResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
+      throw new Error(
+        `MCP server "${this.config.name}" uses incompatible protocol version: ${initResult.protocolVersion} (expected ${MCP_PROTOCOL_VERSION})`
+      );
+    }
+    this.serverCapabilities = initResult.capabilities ?? {};
+    this.serverInfo = initResult.serverInfo;
+    this.serverInstructions = initResult.instructions;
+    this.sendNotification("notifications/initialized", {});
   }
   sendRequest(method, params) {
     return new Promise((resolve10, reject) => {
       if (!this.process?.stdin) {
-        reject(new Error("MCP server not connected"));
+        reject(new Error(`MCP server "${this.config.name}" is not connected`));
         return;
       }
       const id = this.nextId++;
       const request = { jsonrpc: "2.0", id, method, params };
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
-        reject(new Error(`Request timeout: ${method} (id=${id})`));
-      }, REQUEST_TIMEOUT);
+        reject(new Error(
+          `Request timeout: ${method} (id=${id}) on server "${this.config.name}"`
+        ));
+      }, DEFAULT_REQUEST_TIMEOUT);
+      timer.unref();
       this.pendingRequests.set(id, { resolve: resolve10, reject, timer });
       const data = JSON.stringify(request) + "\n";
       this.process.stdin.write(data, (err) => {
         if (err) {
           clearTimeout(timer);
           this.pendingRequests.delete(id);
-          reject(err);
+          reject(new Error(
+            `Failed to send request to MCP server "${this.config.name}": ${err.message}`
+          ));
         }
       });
     });
@@ -8142,19 +8538,23 @@ var MCPClient = class {
     if (!this.process?.stdin) return;
     const notification = { jsonrpc: "2.0", method, params };
     const data = JSON.stringify(notification) + "\n";
-    this.process.stdin.write(data);
+    this.process.stdin.write(data, (err) => {
+      if (err) {
+        console.error(
+          `[MCP:${this.config.name}] Failed to send notification "${method}": ${err.message}`
+        );
+      }
+    });
   }
   handleLine(line) {
-    this.buffer += line;
+    if (!line.trim()) return;
     let response;
     try {
-      response = JSON.parse(this.buffer);
+      response = JSON.parse(line);
     } catch {
       return;
-    } finally {
-      this.buffer = "";
     }
-    if (response.id !== void 0 && response.id !== null) {
+    if (response.id != null) {
       const pending = this.pendingRequests.get(response.id);
       if (pending) {
         clearTimeout(pending.timer);
@@ -8163,12 +8563,47 @@ var MCPClient = class {
       }
     }
   }
+  handleProcessError(err) {
+    const message = `MCP server "${this.config.name}" process error: ${err.message}`;
+    console.error(`[MCP] ${message}`);
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    this.pendingRequests.clear();
+    if (this.connectReject) {
+      this.connectReject(new Error(message));
+      this.connectReject = null;
+    }
+    this.cleanup();
+  }
+  handleProcessExit(code, signal) {
+    const reason = signal ? `terminated by signal ${signal}` : `exited with code ${code}`;
+    const message = `MCP server "${this.config.name}" ${reason}`;
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    this.pendingRequests.clear();
+    this.cleanup();
+  }
+  assertNoError(response) {
+    if (response.error) {
+      const { code, message, data } = response.error;
+      const detail = data ? ` | data: ${JSON.stringify(data)}` : "";
+      throw new Error(
+        `MCP server "${this.config.name}" returned error [${code}]: ${message}${detail}`
+      );
+    }
+  }
   cleanup() {
-    this.connected = false;
+    this.connectionState = "disconnected";
     this.rl?.close();
     this.rl = null;
     this.process = null;
-    this.buffer = "";
+    this.serverCapabilities = {};
+    this.serverInfo = void 0;
+    this.serverInstructions = void 0;
   }
 };
 
@@ -8176,28 +8611,51 @@ var MCPClient = class {
 var MCPConnectionManager = class {
   clients = /* @__PURE__ */ new Map();
   async addServer(config) {
+    if (this.clients.has(config.name)) {
+      await this.removeServer(config.name);
+    }
     const client = new MCPClient(config);
-    await client.connect();
-    this.clients.set(config.name, client);
+    try {
+      await client.connect();
+      this.clients.set(config.name, client);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[MCP] Failed to connect server "${config.name}": ${message}`);
+      try {
+        await client.disconnect();
+      } catch {
+      }
+      throw error;
+    }
   }
   async removeServer(name) {
     const client = this.clients.get(name);
-    if (client) {
+    if (!client) return;
+    try {
       await client.disconnect();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[MCP] Error disconnecting server "${name}": ${message}`);
+    } finally {
       this.clients.delete(name);
     }
   }
   getConnectedServers() {
     return Array.from(this.clients.entries()).filter(([, client]) => client.isConnected()).map(([name]) => name);
   }
+  getClient(name) {
+    return this.clients.get(name);
+  }
   async getAllTools() {
     const allTools = [];
-    for (const [, client] of this.clients) {
+    for (const [name, client] of this.clients) {
       if (!client.isConnected()) continue;
       try {
         const tools = await client.listTools();
         allTools.push(...tools);
-      } catch {
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[MCP] Failed to list tools from "${name}": ${message}`);
       }
     }
     return allTools;
@@ -8217,17 +8675,40 @@ var MCPConnectionManager = class {
     if (!client || !client.isConnected()) {
       return [];
     }
-    return client.listTools();
+    try {
+      return await client.listTools();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[MCP] Failed to list tools from "${serverName}": ${message}`);
+      return [];
+    }
   }
   async disconnectAll() {
-    for (const [, client] of this.clients) {
-      try {
-        await client.disconnect();
-      } catch {
+    const disconnectPromises = Array.from(this.clients.entries()).map(
+      async ([name, client]) => {
+        try {
+          await client.disconnect();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`[MCP] Error disconnecting server "${name}": ${message}`);
+        }
       }
-    }
+    );
+    await Promise.allSettled(disconnectPromises);
     this.clients.clear();
   }
+  /** Register graceful shutdown handlers for SIGINT/SIGTERM. */
+  registerShutdownHandlers() {
+    const handler = async () => {
+      await this.disconnectAll();
+    };
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+    return () => {
+      process.off("SIGINT", handler);
+      process.off("SIGTERM", handler);
+    };
+  }
 };
 
 // src/mcp/mcp-tool-adapter.ts
@@ -8236,19 +8717,23 @@ var MCPToolAdapter = class {
   name;
   description;
   inputSchema;
-  riskLevel = "safe";
+  riskLevel;
   concurrencySafe = true;
-  readOnly = true;
+  readOnly;
   serverName;
+  originalToolName;
   mcpManager;
   rawInputSchema;
-  constructor(serverName, toolName, description, inputSchema2, mcpManager) {
+  constructor(serverName, toolName, description, inputSchema2, mcpManager, annotations) {
+    this.serverName = serverName;
+    this.originalToolName = toolName;
     this.name = `mcp_${serverName}_${toolName}`;
     this.description = description;
-    this.serverName = serverName;
     this.mcpManager = mcpManager;
     this.rawInputSchema = inputSchema2;
     this.inputSchema = this.buildZodSchema(inputSchema2);
+    this.readOnly = annotations?.readOnlyHint === true;
+    this.riskLevel = this.deriveRiskLevel(annotations);
   }
   async execute(input, context) {
     const allowed = await context.checkPermission(this.name, JSON.stringify(input));
@@ -8256,8 +8741,16 @@ var MCPToolAdapter = class {
       return `Error: Permission denied for MCP tool: ${this.name}`;
     }
     try {
-      const result = await this.mcpManager.callTool(this.serverName, this.getOriginalName(), input);
-      return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      const result = await this.mcpManager.callTool(
+        this.serverName,
+        this.originalToolName,
+        input
+      );
+      if (result.isError) {
+        const errorText = result.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
+        return `Error from MCP tool ${this.name}: ${errorText || "Unknown error"}`;
+      }
+      return this.formatResult(result);
     } catch (err) {
       return `Error calling MCP tool ${this.name}: ${err.message}`;
     }
@@ -8270,12 +8763,29 @@ var MCPToolAdapter = class {
     };
   }
   getOriginalName() {
-    const parts = this.name.split("_");
-    return parts.slice(2).join("_");
+    return this.originalToolName;
   }
   getServerName() {
     return this.serverName;
   }
+  deriveRiskLevel(annotations) {
+    if (annotations?.destructiveHint === true) return "destructive";
+    if (annotations?.readOnlyHint === true) return "readonly";
+    return "safe";
+  }
+  formatResult(result) {
+    const parts = [];
+    for (const block of result.content) {
+      if (block.type === "text" && block.text != null) {
+        parts.push(block.text);
+      } else if (block.type === "image" && block.data != null) {
+        parts.push(`[Image: ${block.mimeType ?? "unknown"}, ${block.data.length} bytes base64]`);
+      } else if (block.type === "resource" && block.text != null) {
+        parts.push(block.text);
+      }
+    }
+    return parts.length > 0 ? parts.join("\n") : JSON.stringify(result, null, 2);
+  }
   buildZodSchema(jsonSchema) {
     const properties = jsonSchema.properties ?? {};
     const required = new Set(jsonSchema.required ?? []);
@@ -8291,10 +8801,21 @@ var MCPToolAdapter = class {
     switch (type) {
       case "string":
         if (prop.enum) return z25.enum(prop.enum);
+        if (prop.format === "date-time") return z25.string().datetime();
+        if (typeof prop.minLength === "number" || typeof prop.maxLength === "number") {
+          let schema = z25.string();
+          if (typeof prop.minLength === "number") schema = schema.min(prop.minLength);
+          if (typeof prop.maxLength === "number") schema = schema.max(prop.maxLength);
+          return schema;
+        }
         return z25.string();
       case "number":
-      case "integer":
-        return z25.number();
+      case "integer": {
+        let schema = z25.number();
+        if (typeof prop.minimum === "number") schema = schema.min(prop.minimum);
+        if (typeof prop.maximum === "number") schema = schema.max(prop.maximum);
+        return schema;
+      }
       case "boolean":
         return z25.boolean();
       case "array":
@@ -8323,12 +8844,15 @@ async function registerMCPTools(mcpManager, registerFn) {
           tool.name,
           tool.description ?? `MCP tool: ${tool.name}`,
           tool.inputSchema,
-          mcpManager
+          mcpManager,
+          tool.annotations
         );
         registerFn(adapter);
         registered.push(adapter.name);
       }
-    } catch {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[MCP] Failed to register tools from "${serverName}": ${message}`);
     }
   }
   return registered;
@@ -8398,7 +8922,7 @@ async function connectMcpServers(config, toolRegistry) {
       console.error(`MCP server "${serverConfig.name}" connection failed: ${err.message}`);
     }
   }
-  if (connectedCount === 0) return mcpManager;
+  if (connectedCount === 0) return null;
   const registeredTools = await registerMCPTools(mcpManager, (tool) => {
     try {
       toolRegistry.register(tool);
@@ -8408,6 +8932,7 @@ async function connectMcpServers(config, toolRegistry) {
   if (registeredTools.length > 0) {
     console.log(`  MCP: ${connectedCount} server(s) connected, ${registeredTools.length} tool(s) loaded`);
   }
+  mcpManager.registerShutdownHandlers();
   return mcpManager;
 }
 async function runTuiRepl(config) {
@@ -10651,6 +11176,13 @@ var PROVIDER_OPTIONS = [
     requiresApiKey: true,
     format: "openai-compatible"
   },
+  {
+    id: "anthropic",
+    label: "Anthropic Claude",
+    defaultBaseUrl: "https://api.anthropic.com",
+    requiresApiKey: true,
+    format: "anthropic-compatible"
+  },
   {
     id: "ollama",
     label: "Ollama (local)",
@@ -10850,13 +11382,18 @@ import { useState as useState7, useEffect as useEffect2 } from "react";
 import { Box as Box10, Text as Text10, useInput as useInput6 } from "ink";
 
 // src/connect/fetch-models.ts
-async function fetchModelsFromApi(baseUrl, apiKey) {
+async function fetchModelsFromApi(baseUrl, apiKey, format) {
   const url = baseUrl.replace(/\/$/, "") + "/models";
   const headers = {
     "Content-Type": "application/json"
   };
   if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
+    if (format === "anthropic-compatible") {
+      headers["x-api-key"] = apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+    } else {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
   }
   const response = await fetch(url, {
     method: "GET",
@@ -10874,9 +11411,12 @@ async function fetchModelsFromApi(baseUrl, apiKey) {
 }
 var CATEGORY_PATTERNS = [
   { pattern: /o[1-4](?:-|$|-mini)/i, category: "reasoning" },
+  { pattern: /claude-opus|claude-[34]\.(\d)+/i, category: "reasoning" },
   { pattern: /reason|think|deep/i, category: "reasoning" },
+  { pattern: /claude-sonnet/i, category: "code" },
   { pattern: /code|codestral|deepseek-coder|qwen.*coder|starcoder/i, category: "code" },
   { pattern: /mini|flash|fast|turbo|haiku|lite/i, category: "fast" },
+  { pattern: /claude-haiku/i, category: "fast" },
   { pattern: /creative|dall/i, category: "creative" }
 ];
 function classifyModelName(modelName) {
@@ -10952,7 +11492,7 @@ function ModelStep() {
       setPhase("fallback");
       return;
     }
-    fetchModelsFromApi(state.baseUrl, state.apiKey || void 0).then((fetched) => {
+    fetchModelsFromApi(state.baseUrl, state.apiKey || void 0, state.provider?.format).then((fetched) => {
       if (fetched.length === 0) {
         setError("No models found at this endpoint");
         setPhase("fallback");
@@ -11640,4 +12180,4 @@ export {
   MCPConnectionManager,
   runCli
 };
-//# sourceMappingURL=chunk-PRO7DR3G.js.map
+//# sourceMappingURL=chunk-SDHXIBKZ.js.map