formagent-sdk 0.2.0 → 0.3.3

package/dist/cli/index.js

@@ -7,6 +7,7 @@ import * as readline from "node:readline";
 import { homedir as homedir4 } from "node:os";
 import { join as join8 } from "node:path";
 import { existsSync as existsSync10 } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 
 // src/utils/id.ts
 var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -1678,8 +1679,18 @@ class SessionImpl {
   async executeToolCall(block, abortSignal) {
     let toolInput = block.input;
     let systemMessage;
+    let tool = this.tools.get(block.name);
+    let effectiveToolName = block.name;
+    if (!tool && this.enableToolRepair) {
+      const lowerName = block.name.toLowerCase();
+      const originalName = this.toolNameLookup.get(lowerName);
+      if (originalName) {
+        tool = this.tools.get(originalName);
+        effectiveToolName = originalName;
+      }
+    }
     if (this.hooksManager) {
-      const preResult = await this.hooksManager.runPreToolUse(block.name, block.input, block.id, abortSignal);
+      const preResult = await this.hooksManager.runPreToolUse(effectiveToolName, block.input, block.id, abortSignal);
       if (!preResult.continue) {
         return {
           type: "tool_result",
@@ -1693,7 +1704,7 @@ class SessionImpl {
         return {
           type: "tool_result",
           tool_use_id: block.id,
-          content: preResult.reason ?? `Tool "${block.name}" was denied by hook`,
+          content: preResult.reason ?? `Tool "${effectiveToolName}" was denied by hook`,
           is_error: true,
           _hookSystemMessage: preResult.systemMessage
         };
@@ -1703,16 +1714,6 @@ class SessionImpl {
       }
       systemMessage = preResult.systemMessage;
     }
-    let tool = this.tools.get(block.name);
-    let effectiveToolName = block.name;
-    if (!tool && this.enableToolRepair) {
-      const lowerName = block.name.toLowerCase();
-      const originalName = this.toolNameLookup.get(lowerName);
-      if (originalName) {
-        tool = this.tools.get(originalName);
-        effectiveToolName = originalName;
-      }
-    }
     if (!tool) {
       const availableTools = Array.from(this.tools.keys()).slice(0, 10);
       const suffix = this.tools.size > 10 ? ` (and ${this.tools.size - 10} more)` : "";
@@ -1734,7 +1735,8 @@ class SessionImpl {
       const toolResult = await tool.execute(toolInput, context);
       let content = typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content);
       if (needsTruncation(content)) {
-        content = await truncateToolOutput(content);
+        const truncationConfig = this.config.tempDir ? { tempDir: this.config.tempDir } : undefined;
+        content = await truncateToolOutput(content, truncationConfig);
       }
       toolResponse = toolResult;
       result = {
@@ -1753,7 +1755,7 @@ class SessionImpl {
       };
     }
     if (this.hooksManager) {
-      const postResult = await this.hooksManager.runPostToolUse(block.name, toolInput, toolResponse, block.id, abortSignal);
+      const postResult = await this.hooksManager.runPostToolUse(effectiveToolName, toolInput, toolResponse, block.id, abortSignal);
       if (postResult.systemMessage) {
         systemMessage = postResult.systemMessage;
       }
@@ -2395,7 +2397,7 @@ class OpenAIProvider {
     }
     this.config = {
       apiKey,
-      baseUrl: config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+      baseUrl: this.normalizeBaseUrl(config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1"),
       organization: config.organization,
       defaultMaxTokens: config.defaultMaxTokens ?? 4096
     };
@@ -2404,8 +2406,23 @@ class OpenAIProvider {
     return this.supportedModels.some((pattern) => pattern.test(model));
   }
   async complete(request) {
+    if (this.usesResponsesApi(request.config.model)) {
+      const openaiRequest2 = this.buildResponsesRequest(request, false);
+      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(openaiRequest2),
+        signal: request.abortSignal
+      });
+      if (!response2.ok) {
+        const error = await response2.text();
+        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
+      }
+      const data2 = await response2.json();
+      return this.convertResponsesResponse(data2);
+    }
     const openaiRequest = this.buildRequest(request, false);
-    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
@@ -2413,14 +2430,43 @@ class OpenAIProvider {
     });
     if (!response.ok) {
       const error = await response.text();
+      if (this.shouldFallbackToResponses(response.status, error)) {
+        const fallbackRequest = this.buildResponsesRequest(request, false);
+        response = await fetch(`${this.config.baseUrl}/responses`, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(fallbackRequest),
+          signal: request.abortSignal
+        });
+        if (!response.ok) {
+          const fallbackError = await response.text();
+          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
+        }
+        const data2 = await response.json();
+        return this.convertResponsesResponse(data2);
+      }
       throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     const data = await response.json();
     return this.convertResponse(data);
   }
   async stream(request, options) {
+    if (this.usesResponsesApi(request.config.model)) {
+      const openaiRequest2 = this.buildResponsesRequest(request, true);
+      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(openaiRequest2),
+        signal: request.abortSignal
+      });
+      if (!response2.ok) {
+        const error = await response2.text();
+        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
+      }
+      return this.createResponsesStreamIterator(response2.body, options);
+    }
     const openaiRequest = this.buildRequest(request, true);
-    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
@@ -2428,6 +2474,20 @@ class OpenAIProvider {
     });
     if (!response.ok) {
       const error = await response.text();
+      if (this.shouldFallbackToResponses(response.status, error)) {
+        const fallbackRequest = this.buildResponsesRequest(request, true);
+        response = await fetch(`${this.config.baseUrl}/responses`, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(fallbackRequest),
+          signal: request.abortSignal
+        });
+        if (!response.ok) {
+          const fallbackError = await response.text();
+          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
+        }
+        return this.createResponsesStreamIterator(response.body, options);
+      }
       throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     return this.createStreamIterator(response.body, options);
@@ -2435,10 +2495,10 @@ class OpenAIProvider {
   buildRequest(request, stream) {
     const messages = this.convertMessages(request.messages, request.systemPrompt);
     const tools = request.tools ? this.convertTools(request.tools) : undefined;
-    return {
+    const maxTokens = request.config.maxTokens ?? this.config.defaultMaxTokens;
+    const openaiRequest = {
       model: request.config.model,
       messages,
-      max_tokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
       temperature: request.config.temperature,
       top_p: request.config.topP,
       stop: request.config.stopSequences,
@@ -2446,6 +2506,162 @@ class OpenAIProvider {
       stream_options: stream ? { include_usage: true } : undefined,
       tools
     };
+    if (this.usesMaxCompletionTokens(request.config.model)) {
+      openaiRequest.max_completion_tokens = maxTokens;
+    } else {
+      openaiRequest.max_tokens = maxTokens;
+    }
+    return openaiRequest;
+  }
+  buildResponsesRequest(request, stream) {
+    const input = this.convertResponsesInput(request.messages, request.systemPrompt);
+    const tools = request.tools ? this.convertResponsesTools(request.tools) : undefined;
+    return {
+      model: request.config.model,
+      input,
+      max_output_tokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
+      temperature: request.config.temperature,
+      top_p: request.config.topP,
+      stop: request.config.stopSequences,
+      stream,
+      tools
+    };
+  }
+  usesMaxCompletionTokens(model) {
+    return /^gpt-5/.test(model) || /^o1/.test(model);
+  }
+  usesResponsesApi(model) {
+    return /^gpt-5/.test(model) || /^o1/.test(model);
+  }
+  shouldFallbackToResponses(status, errorText) {
+    if (status !== 404) {
+      return false;
+    }
+    const normalized = errorText.toLowerCase();
+    return normalized.includes("/chat/completions") && normalized.includes("not found");
+  }
+  convertResponsesInput(messages, systemPrompt) {
+    const input = [];
+    if (systemPrompt) {
+      input.push({ role: "system", content: systemPrompt });
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        input.push({
+          role: "system",
+          content: typeof msg.content === "string" ? msg.content : ""
+        });
+        continue;
+      }
+      if (typeof msg.content === "string") {
+        if (msg.role === "user") {
+          input.push({
+            role: "user",
+            content: [{ type: "input_text", text: msg.content }]
+          });
+        } else {
+          input.push({
+            role: "assistant",
+            content: [{ type: "output_text", text: msg.content }]
+          });
+        }
+        continue;
+      }
+      const userContent = [];
+      const assistantContent = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          if (msg.role === "user") {
+            userContent.push({ type: "input_text", text: block.text });
+          } else if (msg.role === "assistant") {
+            assistantContent.push({ type: "output_text", text: block.text });
+          }
+        } else if (block.type === "image" && msg.role === "user") {
+          if (block.source.type === "base64") {
+            userContent.push({
+              type: "input_image",
+              image_url: `data:${block.source.media_type};base64,${block.source.data}`
+            });
+          } else if (block.source.type === "url") {
+            userContent.push({
+              type: "input_image",
+              image_url: block.source.url
+            });
+          }
+        } else if (block.type === "tool_use") {
+          input.push({
+            type: "function_call",
+            call_id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          });
+        } else if (block.type === "tool_result") {
+          input.push({
+            type: "function_call_output",
+            call_id: block.tool_use_id,
+            output: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+          });
+        }
+      }
+      if (msg.role === "user" && userContent.length > 0) {
+        input.push({ role: "user", content: userContent });
+      } else if (msg.role === "assistant" && assistantContent.length > 0) {
+        input.push({ role: "assistant", content: assistantContent });
+      }
+    }
+    return input;
+  }
+  convertResponsesResponse(data) {
+    const content = [];
+    for (const item of data.output ?? []) {
+      if (item.type === "message" && item.content) {
+        for (const part of item.content) {
+          if (part.type === "output_text") {
+            content.push({ type: "text", text: part.text });
+          }
+        }
+      } else if (item.type === "function_call" && item.call_id && item.name) {
+        content.push({
+          type: "tool_use",
+          id: item.call_id,
+          name: item.name,
+          input: item.arguments ? JSON.parse(item.arguments) : {}
+        });
+      }
+    }
+    return {
+      id: data.id,
+      model: data.model,
+      content,
+      stopReason: "end_turn",
+      stopSequence: null,
+      usage: {
+        input_tokens: data.usage?.input_tokens ?? 0,
+        output_tokens: data.usage?.output_tokens ?? 0
+      }
+    };
+  }
+  normalizeBaseUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, "");
+    try {
+      const url = new URL(trimmed);
+      const path2 = url.pathname.replace(/\/+$/, "");
+      if (path2 === "" || path2 === "/") {
+        url.pathname = "/v1";
+        return url.toString().replace(/\/+$/, "");
+      }
+      if (path2.endsWith("/openai")) {
+        url.pathname = `${path2}/v1`;
+        return url.toString().replace(/\/+$/, "");
+      }
+      if (!/\/v\d/.test(path2)) {
+        url.pathname = `${path2}/v1`;
+        return url.toString().replace(/\/+$/, "");
+      }
+      return url.toString().replace(/\/+$/, "");
+    } catch {
+      return trimmed;
+    }
   }
   convertMessages(messages, systemPrompt) {
     const result = [];
@@ -2528,6 +2744,14 @@ class OpenAIProvider {
       }
     }));
   }
+  convertResponsesTools(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+  }
   convertResponse(data) {
     const choice = data.choices[0];
     const content = [];
@@ -2640,115 +2864,924 @@ class OpenAIProvider {
                     const textEvent = {
                       type: "content_block_delta",
                       index: 0,
-                      delta: {
-                        type: "text_delta",
-                        text: delta.content
-                      }
+                      delta: {
+                        type: "text_delta",
+                        text: delta.content
+                      }
+                    };
+                    options?.onText?.(delta.content);
+                    options?.onEvent?.(textEvent);
+                    yield textEvent;
+                  }
+                  if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                      const index = tc.index;
+                      const blockIndex = 1 + index;
+                      if (!toolCalls.has(index)) {
+                        toolCalls.set(index, {
+                          id: tc.id || "",
+                          name: tc.function?.name || "",
+                          arguments: tc.function?.arguments || ""
+                        });
+                        const startEvent = {
+                          type: "content_block_start",
+                          index: blockIndex,
+                          content_block: {
+                            type: "tool_use",
+                            id: tc.id || "",
+                            name: tc.function?.name || "",
+                            input: {}
+                          }
+                        };
+                        options?.onEvent?.(startEvent);
+                        yield startEvent;
+                      } else {
+                        const existing = toolCalls.get(index);
+                        if (tc.id)
+                          existing.id = tc.id;
+                        if (tc.function?.name)
+                          existing.name = tc.function.name;
+                        if (tc.function?.arguments)
+                          existing.arguments += tc.function.arguments;
+                      }
+                      if (tc.function?.arguments) {
+                        const deltaEvent = {
+                          type: "content_block_delta",
+                          index: blockIndex,
+                          delta: {
+                            type: "input_json_delta",
+                            partial_json: tc.function.arguments
+                          }
+                        };
+                        options?.onEvent?.(deltaEvent);
+                        yield deltaEvent;
+                      }
+                    }
+                  }
+                  if (finishReason) {
+                    finished = true;
+                    if (textBlockStarted) {
+                      const stopText = { type: "content_block_stop", index: 0 };
+                      options?.onEvent?.(stopText);
+                      yield stopText;
+                    }
+                    for (const [index, tc] of toolCalls) {
+                      const stopEvent2 = {
+                        type: "content_block_stop",
+                        index: 1 + index
+                      };
+                      options?.onEvent?.(stopEvent2);
+                      yield stopEvent2;
+                      try {
+                        const input = JSON.parse(tc.arguments);
+                        options?.onToolUse?.({ id: tc.id, name: tc.name, input });
+                      } catch {}
+                    }
+                    const messageDelta = {
+                      type: "message_delta",
+                      delta: {
+                        stop_reason: self.convertStopReason(finishReason),
+                        stop_sequence: null
+                      },
+                      usage: {
+                        output_tokens: json.usage?.completion_tokens ?? 0,
+                        input_tokens: json.usage?.prompt_tokens ?? 0
+                      }
+                    };
+                    options?.onEvent?.(messageDelta);
+                    yield messageDelta;
+                    const stopEvent = { type: "message_stop" };
+                    options?.onEvent?.(stopEvent);
+                    yield stopEvent;
+                  }
+                } catch {}
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+    };
+  }
+  createResponsesStreamIterator(body, options) {
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let emittedMessageStart = false;
+        let textBlockStarted = false;
+        let finished = false;
+        const toolCalls = new Map;
+        let nextToolBlockIndex = 1;
+        const ensureMessageStart = (id, model) => {
+          if (emittedMessageStart)
+            return;
+          emittedMessageStart = true;
+          const startEvent = {
+            type: "message_start",
+            message: {
+              id: id ?? "",
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: model ?? "",
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          };
+          options?.onEvent?.(startEvent);
+          return startEvent;
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.startsWith("data: "))
+                continue;
+              const data = line.slice(6).trim();
+              if (!data)
+                continue;
+              if (data === "[DONE]") {
+                if (!finished) {
+                  const stopEvent = { type: "message_stop" };
+                  options?.onEvent?.(stopEvent);
+                  yield stopEvent;
+                }
+                finished = true;
+                continue;
+              }
+              let payload;
+              try {
+                payload = JSON.parse(data);
+              } catch {
+                continue;
+              }
+              const type = payload?.type;
+              if (type === "response.created") {
+                const startEvent = ensureMessageStart(payload.response?.id, payload.response?.model);
+                if (startEvent)
+                  yield startEvent;
+                continue;
+              }
+              if (!emittedMessageStart) {
+                const startEvent = ensureMessageStart(payload?.response?.id, payload?.response?.model);
+                if (startEvent)
+                  yield startEvent;
+              }
+              if (type === "response.output_text.delta") {
+                if (!textBlockStarted) {
+                  textBlockStarted = true;
+                  const startText = {
+                    type: "content_block_start",
+                    index: 0,
+                    content_block: { type: "text", text: "" }
+                  };
+                  options?.onEvent?.(startText);
+                  yield startText;
+                }
+                const textDelta = payload.delta ?? "";
+                if (textDelta) {
+                  const textEvent = {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "text_delta", text: textDelta }
+                  };
+                  options?.onText?.(textDelta);
+                  options?.onEvent?.(textEvent);
+                  yield textEvent;
+                }
+              } else if (type === "response.output_item.added") {
+                const item = payload.item;
+                if (item?.type === "function_call") {
+                  const blockIndex = nextToolBlockIndex++;
+                  const callId = item.call_id ?? item.id ?? "";
+                  toolCalls.set(item.id, {
+                    callId,
+                    name: item.name ?? "",
+                    arguments: item.arguments ?? "",
+                    blockIndex,
+                    done: false
+                  });
+                  const startEvent = {
+                    type: "content_block_start",
+                    index: blockIndex,
+                    content_block: {
+                      type: "tool_use",
+                      id: callId,
+                      name: item.name ?? "",
+                      input: {}
+                    }
+                  };
+                  options?.onEvent?.(startEvent);
+                  yield startEvent;
+                  if (item.arguments) {
+                    const deltaEvent = {
+                      type: "content_block_delta",
+                      index: blockIndex,
+                      delta: {
+                        type: "input_json_delta",
+                        partial_json: item.arguments
+                      }
+                    };
+                    options?.onEvent?.(deltaEvent);
+                    yield deltaEvent;
+                  }
+                }
+              } else if (type === "response.function_call_arguments.delta") {
+                const entry = toolCalls.get(payload.item_id);
+                if (entry && payload.delta) {
+                  entry.arguments += payload.delta;
+                  const deltaEvent = {
+                    type: "content_block_delta",
+                    index: entry.blockIndex,
+                    delta: { type: "input_json_delta", partial_json: payload.delta }
+                  };
+                  options?.onEvent?.(deltaEvent);
+                  yield deltaEvent;
+                }
+              } else if (type === "response.output_item.done") {
+                const item = payload.item;
+                if (item?.type === "function_call") {
+                  const entry = toolCalls.get(item.id);
+                  if (entry && !entry.done) {
+                    entry.done = true;
+                    const stopEvent = {
+                      type: "content_block_stop",
+                      index: entry.blockIndex
+                    };
+                    options?.onEvent?.(stopEvent);
+                    yield stopEvent;
+                    try {
+                      const input = entry.arguments ? JSON.parse(entry.arguments) : {};
+                      options?.onToolUse?.({ id: entry.callId, name: entry.name, input });
+                    } catch {
+                      options?.onToolUse?.({ id: entry.callId, name: entry.name, input: {} });
+                    }
+                  }
+                }
+              } else if (type === "response.completed" || type === "response.incomplete") {
+                finished = true;
+                if (textBlockStarted) {
+                  const stopText = { type: "content_block_stop", index: 0 };
+                  options?.onEvent?.(stopText);
+                  yield stopText;
+                }
+                for (const entry of toolCalls.values()) {
+                  if (entry.done)
+                    continue;
+                  entry.done = true;
+                  const stopEvent2 = {
+                    type: "content_block_stop",
+                    index: entry.blockIndex
+                  };
+                  options?.onEvent?.(stopEvent2);
+                  yield stopEvent2;
+                  try {
+                    const input = entry.arguments ? JSON.parse(entry.arguments) : {};
+                    options?.onToolUse?.({ id: entry.callId, name: entry.name, input });
+                  } catch {
+                    options?.onToolUse?.({ id: entry.callId, name: entry.name, input: {} });
+                  }
+                }
+                const finishReason = payload.response?.incomplete_details?.reason;
+                const messageDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: self.convertResponsesStopReason(finishReason),
+                    stop_sequence: null
+                  },
+                  usage: {
+                    output_tokens: payload.response?.usage?.output_tokens ?? 0,
+                    input_tokens: payload.response?.usage?.input_tokens ?? 0
+                  }
+                };
+                options?.onEvent?.(messageDelta);
+                yield messageDelta;
+                const stopEvent = { type: "message_stop" };
+                options?.onEvent?.(stopEvent);
+                yield stopEvent;
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+    };
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`
+    };
+    if (this.config.organization) {
+      headers["OpenAI-Organization"] = this.config.organization;
+    }
+    return headers;
+  }
+  convertResponsesStopReason(reason) {
+    if (reason === "max_output_tokens") {
+      return "max_tokens";
+    }
+    return "end_turn";
+  }
+}
+
+// src/llm/gemini.ts
+class GeminiProvider {
+  id = "gemini";
+  name = "Gemini";
+  supportedModels = [/^gemini-/, /^models\/gemini-/];
+  config;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+      throw new Error("Gemini API key is required. Set GEMINI_API_KEY/GOOGLE_API_KEY or pass apiKey in config.");
+    }
+    this.config = {
+      apiKey,
+      baseUrl: config.baseUrl ?? process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta",
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+    };
+  }
+  supportsModel(model) {
+    return this.supportedModels.some((pattern) => pattern.test(model));
+  }
+  async complete(request) {
+    const geminiRequest = this.buildRequest(request);
+    const url = this.buildUrl(this.getModelPath(request.config.model) + ":generateContent");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(geminiRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gemini API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return this.convertResponse(data, request.config.model);
+  }
+  async stream(request, options) {
+    const geminiRequest = this.buildRequest(request);
+    const url = this.buildUrl(this.getModelPath(request.config.model) + ":streamGenerateContent", {
+      alt: "sse"
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(geminiRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gemini API error: ${response.status} ${error}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("text/event-stream")) {
+      const data = await response.json();
+      return this.createResponseIterator(data, options, request.config.model);
+    }
+    return this.createStreamIterator(response.body, options, request.config.model);
+  }
+  buildRequest(request) {
+    const { contents, systemInstruction } = this.convertMessages(request.messages, request.systemPrompt);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    return {
+      contents,
+      systemInstruction,
+      generationConfig: {
+        temperature: request.config.temperature,
+        topP: request.config.topP,
+        maxOutputTokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
+        stopSequences: request.config.stopSequences
+      },
+      tools,
+      toolConfig: tools ? { functionCallingConfig: { mode: "AUTO" } } : undefined
+    };
+  }
+  convertMessages(messages, systemPrompt) {
+    const contents = [];
+    const systemTexts = [];
+    const toolNameById = new Map;
+    for (const msg of messages) {
+      if (typeof msg.content !== "string") {
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            toolNameById.set(block.id, block.name);
+          }
+        }
+      }
+    }
+    if (systemPrompt) {
+      systemTexts.push(systemPrompt);
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        if (typeof msg.content === "string") {
+          systemTexts.push(msg.content);
+        } else {
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              systemTexts.push(block.text);
+            }
+          }
+        }
+        continue;
+      }
+      if (typeof msg.content === "string") {
+        contents.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts: [{ text: msg.content }]
+        });
+        continue;
+      }
+      const parts = [];
+      const toolResponses = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "image") {
+          if (block.source.type === "base64") {
+            parts.push({
+              inlineData: {
+                mimeType: block.source.media_type ?? "image/jpeg",
+                data: block.source.data ?? ""
+              }
+            });
+          } else if (block.source.type === "url") {
+            parts.push({
+              fileData: {
+                mimeType: block.source.media_type ?? "image/jpeg",
+                fileUri: block.source.url ?? ""
+              }
+            });
+          }
+        } else if (block.type === "tool_result") {
+          const toolName = toolNameById.get(block.tool_use_id) ?? "tool";
+          const output = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+          toolResponses.push({
+            functionResponse: {
+              name: toolName,
+              response: { output }
+            }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts
+        });
+      }
+      if (toolResponses.length > 0) {
+        contents.push({
+          role: "user",
+          parts: toolResponses
+        });
+      }
+    }
+    const systemInstruction = systemTexts.length > 0 ? { parts: [{ text: systemTexts.join(`
+
+`) }] } : undefined;
+    return { contents, systemInstruction };
+  }
+  convertTools(tools) {
+    return [
+      {
+        functionDeclarations: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: this.sanitizeSchema(tool.inputSchema)
+        }))
+      }
+    ];
+  }
+  sanitizeSchema(schema) {
+    const visited = new WeakMap;
+    const scrub = (value) => {
+      if (value === null || typeof value !== "object") {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => scrub(item));
+      }
+      const existing = visited.get(value);
+      if (existing) {
+        return existing;
+      }
+      const result = {};
+      visited.set(value, result);
+      for (const [key, inner] of Object.entries(value)) {
+        if (key === "additionalProperties") {
+          continue;
+        }
+        result[key] = scrub(inner);
+      }
+      return result;
+    };
+    return scrub(schema);
+  }
+  convertResponse(data, model) {
+    const candidate = data.candidates?.[0];
+    const content = [];
+    const parts = candidate?.content?.parts ?? [];
+    let toolIndex = 0;
+    for (const part of parts) {
+      if ("text" in part && part.text) {
+        content.push({ type: "text", text: part.text });
+      } else if ("functionCall" in part && part.functionCall) {
+        const callId = `${part.functionCall.name}_${toolIndex++}`;
+        content.push({
+          type: "tool_use",
+          id: callId,
+          name: part.functionCall.name,
+          input: part.functionCall.args ?? {}
+        });
+      }
+    }
+    return {
+      id: "",
+      model: data.model ?? model,
+      content,
+      stopReason: this.convertStopReason(candidate?.finishReason),
+      stopSequence: null,
+      usage: this.convertUsage(data.usageMetadata)
+    };
+  }
+  convertUsage(usage) {
+    return {
+      input_tokens: usage?.promptTokenCount ?? 0,
+      output_tokens: usage?.candidatesTokenCount ?? 0
+    };
+  }
+  convertStopReason(reason) {
+    switch (reason) {
+      case "MAX_TOKENS":
+        return "max_tokens";
+      case "STOP":
+        return "end_turn";
+      default:
+        return "end_turn";
+    }
+  }
+  createStreamIterator(body, options, model) {
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let emittedMessageStart = false;
+        let textBlockStarted = false;
+        let finished = false;
+        let toolIndex = 0;
+        let emittedAny = false;
+        const emitMessageStart = (modelId) => {
+          if (emittedMessageStart)
+            return;
+          emittedMessageStart = true;
+          const startEvent = {
+            type: "message_start",
+            message: {
+              id: "",
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: modelId,
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          };
+          options?.onEvent?.(startEvent);
+          return startEvent;
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed)
+                continue;
+              let jsonText = trimmed;
+              if (trimmed.startsWith("data:")) {
+                jsonText = trimmed.slice(5).trim();
+              }
+              let payload;
+              try {
+                payload = JSON.parse(jsonText);
+              } catch {
+                continue;
+              }
+              const startEvent = emitMessageStart(payload.model ?? model);
+              if (startEvent) {
+                yield startEvent;
+                emittedAny = true;
+              }
+              const candidate = payload.candidates?.[0];
+              const parts = candidate?.content?.parts ?? [];
+              for (const part of parts) {
+                if ("text" in part && part.text) {
+                  if (!textBlockStarted) {
+                    textBlockStarted = true;
+                    const startText = {
+                      type: "content_block_start",
+                      index: 0,
+                      content_block: { type: "text", text: "" }
+                    };
+                    options?.onEvent?.(startText);
+                    yield startText;
+                    emittedAny = true;
+                  }
+                  const textEvent = {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "text_delta", text: part.text }
+                  };
+                  options?.onText?.(part.text);
+                  options?.onEvent?.(textEvent);
+                  yield textEvent;
+                  emittedAny = true;
+                } else if ("functionCall" in part && part.functionCall) {
+                  const callId = `${part.functionCall.name}_${toolIndex}`;
+                  const blockIndex = 1 + toolIndex;
+                  toolIndex += 1;
+                  const startTool = {
+                    type: "content_block_start",
+                    index: blockIndex,
+                    content_block: {
+                      type: "tool_use",
+                      id: callId,
+                      name: part.functionCall.name,
+                      input: {}
+                    }
+                  };
+                  options?.onEvent?.(startTool);
+                  yield startTool;
+                  emittedAny = true;
+                  const args = JSON.stringify(part.functionCall.args ?? {});
+                  if (args) {
+                    const deltaEvent = {
+                      type: "content_block_delta",
+                      index: blockIndex,
+                      delta: { type: "input_json_delta", partial_json: args }
+                    };
+                    options?.onEvent?.(deltaEvent);
+                    yield deltaEvent;
+                    emittedAny = true;
+                  }
+                  const stopTool = {
+                    type: "content_block_stop",
+                    index: blockIndex
+                  };
+                  options?.onEvent?.(stopTool);
+                  yield stopTool;
+                  emittedAny = true;
+                  options?.onToolUse?.({
+                    id: callId,
+                    name: part.functionCall.name,
+                    input: part.functionCall.args ?? {}
+                  });
+                  emittedAny = true;
+                }
+              }
+              if (candidate?.finishReason && !finished) {
+                finished = true;
+                if (textBlockStarted) {
+                  const stopText = { type: "content_block_stop", index: 0 };
+                  options?.onEvent?.(stopText);
+                  yield stopText;
+                }
+                const messageDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: self.convertStopReason(candidate.finishReason),
+                    stop_sequence: null
+                  },
+                  usage: self.convertUsage(payload.usageMetadata)
+                };
+                options?.onEvent?.(messageDelta);
+                yield messageDelta;
+                emittedAny = true;
+                const stopEvent = { type: "message_stop" };
+                options?.onEvent?.(stopEvent);
+                yield stopEvent;
+                emittedAny = true;
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        if (!emittedAny) {
+          const trimmed = buffer.trim();
+          if (trimmed) {
+            try {
+              const parsed = JSON.parse(trimmed);
+              const responses = Array.isArray(parsed) ? parsed : [parsed];
+              for (const payload of responses) {
+                const startEvent = emitMessageStart(payload.model ?? model);
+                if (startEvent) {
+                  yield startEvent;
+                }
+                const candidate = payload.candidates?.[0];
+                const parts = candidate?.content?.parts ?? [];
+                for (const part of parts) {
+                  if ("text" in part && part.text) {
+                    if (!textBlockStarted) {
+                      textBlockStarted = true;
+                      const startText = {
+                        type: "content_block_start",
+                        index: 0,
+                        content_block: { type: "text", text: "" }
+                      };
+                      options?.onEvent?.(startText);
+                      yield startText;
+                    }
+                    const textEvent = {
+                      type: "content_block_delta",
+                      index: 0,
+                      delta: { type: "text_delta", text: part.text }
                     };
-                    options?.onText?.(delta.content);
+                    options?.onText?.(part.text);
                     options?.onEvent?.(textEvent);
                     yield textEvent;
                   }
-                  if (delta?.tool_calls) {
-                    for (const tc of delta.tool_calls) {
-                      const index = tc.index;
-                      const blockIndex = 1 + index;
-                      if (!toolCalls.has(index)) {
-                        toolCalls.set(index, {
-                          id: tc.id || "",
-                          name: tc.function?.name || "",
-                          arguments: tc.function?.arguments || ""
-                        });
-                        const startEvent = {
-                          type: "content_block_start",
-                          index: blockIndex,
-                          content_block: {
-                            type: "tool_use",
-                            id: tc.id || "",
-                            name: tc.function?.name || "",
-                            input: {}
-                          }
-                        };
-                        options?.onEvent?.(startEvent);
-                        yield startEvent;
-                      } else {
-                        const existing = toolCalls.get(index);
-                        if (tc.id)
-                          existing.id = tc.id;
-                        if (tc.function?.name)
-                          existing.name = tc.function.name;
-                        if (tc.function?.arguments)
-                          existing.arguments += tc.function.arguments;
-                      }
-                      if (tc.function?.arguments) {
-                        const deltaEvent = {
-                          type: "content_block_delta",
-                          index: blockIndex,
-                          delta: {
-                            type: "input_json_delta",
-                            partial_json: tc.function.arguments
-                          }
-                        };
-                        options?.onEvent?.(deltaEvent);
-                        yield deltaEvent;
-                      }
-                    }
-                  }
-                  if (finishReason) {
-                    finished = true;
-                    if (textBlockStarted) {
-                      const stopText = { type: "content_block_stop", index: 0 };
-                      options?.onEvent?.(stopText);
-                      yield stopText;
-                    }
-                    for (const [index, tc] of toolCalls) {
-                      const stopEvent2 = {
-                        type: "content_block_stop",
-                        index: 1 + index
-                      };
-                      options?.onEvent?.(stopEvent2);
-                      yield stopEvent2;
-                      try {
-                        const input = JSON.parse(tc.arguments);
-                        options?.onToolUse?.({ id: tc.id, name: tc.name, input });
-                      } catch {}
-                    }
-                    const messageDelta = {
-                      type: "message_delta",
-                      delta: {
-                        stop_reason: self.convertStopReason(finishReason),
-                        stop_sequence: null
-                      },
-                      usage: {
-                        output_tokens: json.usage?.completion_tokens ?? 0,
-                        input_tokens: json.usage?.prompt_tokens ?? 0
-                      }
-                    };
-                    options?.onEvent?.(messageDelta);
-                    yield messageDelta;
-                    const stopEvent = { type: "message_stop" };
-                    options?.onEvent?.(stopEvent);
-                    yield stopEvent;
-                  }
-                } catch {}
+                }
+                if (textBlockStarted) {
+                  const stopText = { type: "content_block_stop", index: 0 };
+                  options?.onEvent?.(stopText);
+                  yield stopText;
+                }
+                const messageDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: self.convertStopReason(candidate?.finishReason),
+                    stop_sequence: null
+                  },
+                  usage: self.convertUsage(payload.usageMetadata)
+                };
+                options?.onEvent?.(messageDelta);
+                yield messageDelta;
+                const stopEvent = { type: "message_stop" };
+                options?.onEvent?.(stopEvent);
+                yield stopEvent;
+              }
+              return;
+            } catch {}
+          }
+        }
+        if (!finished) {
+          if (textBlockStarted) {
+            const stopText = { type: "content_block_stop", index: 0 };
+            options?.onEvent?.(stopText);
+            yield stopText;
+          }
+          const stopEvent = { type: "message_stop" };
+          options?.onEvent?.(stopEvent);
+          yield stopEvent;
+        }
+      }
+    };
+  }
+  createResponseIterator(data, options, model) {
+    const responses = Array.isArray(data) ? data : [data];
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        for (const payload of responses) {
+          const candidate = payload.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          let textIndex = 0;
+          let toolIndex = 0;
+          const startEvent = {
+            type: "message_start",
+            message: {
+              id: "",
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: payload.model ?? model,
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          };
+          options?.onEvent?.(startEvent);
+          yield startEvent;
+          for (const part of parts) {
+            if ("text" in part && part.text) {
+              const startText = {
+                type: "content_block_start",
+                index: textIndex,
+                content_block: { type: "text", text: "" }
+              };
+              options?.onEvent?.(startText);
+              yield startText;
+              const textEvent = {
+                type: "content_block_delta",
+                index: textIndex,
+                delta: { type: "text_delta", text: part.text }
+              };
+              options?.onText?.(part.text);
+              options?.onEvent?.(textEvent);
+              yield textEvent;
+              const stopText = { type: "content_block_stop", index: textIndex };
+              options?.onEvent?.(stopText);
+              yield stopText;
+              textIndex += 1;
+            } else if ("functionCall" in part && part.functionCall) {
+              const callId = `${part.functionCall.name}_${toolIndex}`;
+              const blockIndex = textIndex + toolIndex + 1;
+              toolIndex += 1;
+              const startTool = {
+                type: "content_block_start",
+                index: blockIndex,
+                content_block: {
+                  type: "tool_use",
+                  id: callId,
+                  name: part.functionCall.name,
+                  input: {}
+                }
+              };
+              options?.onEvent?.(startTool);
+              yield startTool;
+              const args = JSON.stringify(part.functionCall.args ?? {});
+              if (args) {
+                const deltaEvent = {
+                  type: "content_block_delta",
+                  index: blockIndex,
+                  delta: { type: "input_json_delta", partial_json: args }
+                };
+                options?.onEvent?.(deltaEvent);
+                yield deltaEvent;
               }
+              const stopTool = { type: "content_block_stop", index: blockIndex };
+              options?.onEvent?.(stopTool);
+              yield stopTool;
+              options?.onToolUse?.({
+                id: callId,
+                name: part.functionCall.name,
+                input: part.functionCall.args ?? {}
+              });
             }
           }
-        } finally {
-          reader.releaseLock();
+          const messageDelta = {
+            type: "message_delta",
+            delta: {
+              stop_reason: self.convertStopReason(candidate?.finishReason),
+              stop_sequence: null
+            },
+            usage: self.convertUsage(payload.usageMetadata)
+          };
+          options?.onEvent?.(messageDelta);
+          yield messageDelta;
+          const stopEvent = { type: "message_stop" };
+          options?.onEvent?.(stopEvent);
+          yield stopEvent;
         }
       }
     };
   }
   getHeaders() {
-    const headers = {
+    return {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${this.config.apiKey}`
+      "x-goog-api-key": this.config.apiKey
     };
-    if (this.config.organization) {
-      headers["OpenAI-Organization"] = this.config.organization;
+  }
+  buildUrl(path2, params) {
+    const base = this.config.baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/${path2.replace(/^\/+/, "")}`);
+    if (!url.searchParams.has("key")) {
+      url.searchParams.set("key", this.config.apiKey);
     }
-    return headers;
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  getModelPath(model) {
+    return model.startsWith("models/") ? model : `models/${model}`;
   }
 }
 
@@ -2766,8 +3799,13 @@ function getGlobalManager() {
           apiKey: process.env.OPENAI_API_KEY,
           baseUrl: process.env.OPENAI_BASE_URL
         });
+      } else if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+        defaultProvider = new GeminiProvider({
+          apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+          baseUrl: process.env.GEMINI_BASE_URL
+        });
       } else {
-        throw new Error("No default provider set. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
+        throw new Error("No default provider set. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
       }
     }
     globalManager = new SessionManagerImpl({
@@ -2788,8 +3826,13 @@ async function createSession(options) {
           apiKey: process.env.OPENAI_API_KEY,
           baseUrl: process.env.OPENAI_BASE_URL
         });
+      } else if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+        provider = new GeminiProvider({
+          apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+          baseUrl: process.env.GEMINI_BASE_URL
+        });
       } else {
-        throw new Error("No provider available. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
+        throw new Error("No provider available. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
       }
     }
     const customManager = new SessionManagerImpl({
@@ -3220,6 +4263,7 @@ function checkDirAccess(dirPath, options) {
 
 // src/tools/builtin/bash.ts
 var DEFAULT_TIMEOUT = 120000;
+var DEFAULT_IDLE_TIMEOUT = 30000;
 var MAX_OUTPUT_LENGTH = 1e5;
 var DEFAULT_BLOCKED_PATTERNS = [
   "\\bsudo\\b",
@@ -3286,21 +4330,39 @@ function createBashTool(options = {}) {
         }
       }
       const actualTimeout = Math.min(timeout, 600000);
+      const idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
       return new Promise((resolve2) => {
         let stdout = "";
         let stderr = "";
         let killed = false;
+        let killedReason = null;
+        let lastOutputTime = Date.now();
         const proc = spawn("bash", ["-c", command], {
           cwd: cwdAccess.resolved,
           env: process.env,
-          shell: false
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"]
         });
         const timer = setTimeout(() => {
           killed = true;
+          killedReason = "timeout";
           proc.kill("SIGTERM");
           setTimeout(() => proc.kill("SIGKILL"), 1000);
         }, actualTimeout);
+        const idleChecker = setInterval(() => {
+          const idleTime = Date.now() - lastOutputTime;
+          if (idleTime >= idleTimeout && !killed) {
+            killed = true;
+            killedReason = "idle";
+            proc.kill("SIGTERM");
+            setTimeout(() => proc.kill("SIGKILL"), 1000);
+          }
+        }, 1000);
+        const updateLastOutputTime = () => {
+          lastOutputTime = Date.now();
+        };
         proc.stdout?.on("data", (data) => {
+          updateLastOutputTime();
           stdout += data.toString();
           if (stdout.length > MAX_OUTPUT_LENGTH) {
             stdout = stdout.slice(0, MAX_OUTPUT_LENGTH) + `
@@ -3309,6 +4371,7 @@ function createBashTool(options = {}) {
           }
         });
         proc.stderr?.on("data", (data) => {
+          updateLastOutputTime();
           stderr += data.toString();
           if (stderr.length > MAX_OUTPUT_LENGTH) {
             stderr = stderr.slice(0, MAX_OUTPUT_LENGTH) + `
@@ -3317,17 +4380,31 @@ function createBashTool(options = {}) {
         });
         proc.on("close", (code) => {
           clearTimeout(timer);
+          clearInterval(idleChecker);
           if (killed) {
-            resolve2({
-              content: `Command timed out after ${actualTimeout}ms
+            if (killedReason === "idle") {
+              resolve2({
+                content: `Command terminated: no output for ${idleTimeout / 1000} seconds (likely waiting for input)
 
 Partial output:
 ${stdout}
 
 Stderr:
 ${stderr}`,
-              isError: true
-            });
+                isError: true
+              });
+            } else {
+              resolve2({
+                content: `Command timed out after ${actualTimeout}ms
+
+Partial output:
+${stdout}
+
+Stderr:
+${stderr}`,
+                isError: true
+              });
+            }
             return;
           }
           const output = stdout + (stderr ? `
@@ -3348,6 +4425,7 @@ ${output}`,
         });
         proc.on("error", (error) => {
           clearTimeout(timer);
+          clearInterval(idleChecker);
           resolve2({
             content: `Failed to execute command: ${error.message}`,
             isError: true
@@ -4987,7 +6065,7 @@ ${responseText}`;
           metadata: {
             status: response.status,
             statusText: response.statusText,
-            headers: Object.fromEntries(response.headers.entries()),
+            headers: Object.fromEntries(response.headers),
             body: responseBody
           }
         };
@@ -5063,7 +6141,17 @@ function loadEnvOverride(cwd) {
 
 // src/cli/cli.ts
 loadEnvOverride();
-var VERSION = "0.1.0";
+function getCliVersion() {
+  try {
+    const pkgUrl = new URL("../../package.json", import.meta.url);
+    const raw = readFileSync2(pkgUrl, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getCliVersion();
 var SKILLS_PATH = join8(homedir4(), ".claude");
 var colors = {
   reset: "\x1B[0m",
@@ -5092,6 +6180,8 @@ var session = null;
 var totalInputTokens = 0;
 var totalOutputTokens = 0;
 var messageCount = 0;
+var currentProviderId = null;
+var currentModelOverride = null;
 function isGitRepo(dir) {
   return existsSync10(join8(dir, ".git"));
 }
@@ -5139,6 +6229,7 @@ ${c.bold("Interactive Commands:")}
   ${c.cyan("/clear")}    Clear conversation history
   ${c.cyan("/tools")}    List available tools
   ${c.cyan("/skills")}   List available skills
+  ${c.cyan("/models")}   Show or switch provider/model
   ${c.cyan("/todos")}    Show current todo list
   ${c.cyan("/usage")}    Show token usage statistics
   ${c.cyan("/debug")}    Show debug info (prompt, model, env)
@@ -5147,8 +6238,11 @@ ${c.bold("Interactive Commands:")}
 ${c.bold("Environment:")}
   ${c.cyan("ANTHROPIC_API_KEY")}   Anthropic API key (for Claude models)
   ${c.cyan("ANTHROPIC_MODEL")}     Optional. Claude model (default: claude-sonnet-4-20250514)
+  ${c.cyan("GEMINI_API_KEY")}      Gemini API key (for Gemini models)
+  ${c.cyan("GEMINI_MODEL")}        Optional. Gemini model (default: gemini-1.5-pro)
+  ${c.cyan("GEMINI_BASE_URL")}     Optional. Custom Gemini API base URL
   ${c.cyan("OPENAI_API_KEY")}      OpenAI API key (for GPT models)
-  ${c.cyan("OPENAI_MODEL")}        Optional. OpenAI model (default: gpt-4o)
+  ${c.cyan("OPENAI_MODEL")}        Optional. OpenAI model (default: gpt-5.2)
   ${c.cyan("OPENAI_BASE_URL")}     Optional. Custom OpenAI-compatible API URL
 
 ${c.bold("Examples:")}
@@ -5166,7 +6260,7 @@ function printVersion() {
   console.log(`formagent-sdk v${VERSION}`);
 }
 function printBanner() {
-  const model = getDefaultModel();
+  const model = getActiveModel();
   console.log();
   console.log(c.cyan("╔═══════════════════════════════════════════════════════════╗"));
   console.log(c.cyan("║") + c.bold("              FormAgent CLI v" + VERSION + "                     ") + c.cyan("║"));
@@ -5174,6 +6268,7 @@ function printBanner() {
   console.log(c.cyan("╚═══════════════════════════════════════════════════════════╝"));
   console.log();
   console.log(c.dim("  Model: ") + c.green(model));
+  console.log(c.dim("  Provider: ") + c.green(getActiveProviderId() ?? "auto"));
   console.log(c.dim("  Type your message and press Enter to chat."));
   console.log(c.dim("  Use /help for commands, /exit to quit."));
   console.log();
@@ -5186,6 +6281,7 @@ function printInteractiveHelp() {
   console.log(`  ${c.cyan("/clear")}    Clear conversation history`);
   console.log(`  ${c.cyan("/tools")}    List available tools`);
   console.log(`  ${c.cyan("/skills")}   List available skills`);
+  console.log(`  ${c.cyan("/models")}   Show or switch provider/model`);
   console.log(`  ${c.cyan("/todos")}    Show current todo list`);
   console.log(`  ${c.cyan("/usage")}    Show token usage statistics`);
   console.log(`  ${c.cyan("/debug")}    Show debug info (prompt, model, env)`);
@@ -5259,8 +6355,238 @@ function printUsage() {
   console.log(`  ${c.cyan("Est. cost:")}     $${(inputCost + outputCost).toFixed(4)}`);
   console.log();
 }
+async function resetSessionForModelChange() {
+  if (session) {
+    await session.close();
+    session = null;
+  }
+  totalInputTokens = 0;
+  totalOutputTokens = 0;
+  messageCount = 0;
+}
+function printModelsHelp() {
+  const provider = getActiveProviderId() ?? "auto";
+  const model = getActiveModel();
+  console.log();
+  console.log(c.bold("Model Selection:"));
+  console.log();
+  console.log(`  ${c.cyan("Current provider:")} ${provider}`);
+  console.log(`  ${c.cyan("Current model:")}    ${model}`);
+  console.log();
+  console.log(c.bold("Usage:"));
+  console.log(`  ${c.cyan("/models")}`);
+  console.log(c.dim("    List models for the active provider"));
+  console.log(`  ${c.cyan("/models")} openai gpt-5-mini`);
+  console.log(`  ${c.cyan("/models")} anthropic claude-sonnet-4-20250514`);
+  console.log(`  ${c.cyan("/models")} gemini gemini-1.5-pro`);
+  console.log(`  ${c.cyan("/models")} gpt-5.2`);
+  console.log(`  ${c.cyan("/models")} reset`);
+  console.log();
+}
+async function handleModelsCommand(args) {
+  if (args.length === 0) {
+    await listModelsSummary();
+    return;
+  }
+  if (args[0].toLowerCase() === "reset") {
+    currentProviderId = null;
+    currentModelOverride = null;
+    await resetSessionForModelChange();
+    console.log(c.green(`
+  ✓ Model selection reset to environment defaults.
+`));
+    return;
+  }
+  if (args.length === 1) {
+    const provider2 = parseProvider(args[0]);
+    if (provider2) {
+      currentProviderId = provider2;
+      currentModelOverride = null;
+      await resetSessionForModelChange();
+      console.log(c.green(`
+  ✓ Provider set to ${provider2}. Model: ${getActiveModel()}.
+`));
+      return;
+    }
+    currentModelOverride = args[0];
+    currentProviderId = inferProviderFromModel(args[0]) ?? currentProviderId;
+    await resetSessionForModelChange();
+    console.log(c.green(`
+  ✓ Model set to ${currentModelOverride} (provider: ${getActiveProviderId() ?? "auto"}).
+`));
+    return;
+  }
+  const provider = parseProvider(args[0]);
+  if (!provider) {
+    console.log(c.yellow(`
+  Unknown provider: ${args[0]}. Use "openai", "anthropic", or "gemini".
+`));
+    return;
+  }
+  const model = args.slice(1).join(" ");
+  if (!model) {
+    console.log(c.yellow(`
+  Missing model name. Example: /models openai gpt-5-mini
+`));
+    return;
+  }
+  currentProviderId = provider;
+  currentModelOverride = model;
+  await resetSessionForModelChange();
+  console.log(c.green(`
+  ✓ Provider set to ${provider}, model set to ${model}.
+`));
+}
+function normalizeOpenAIBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    return trimmed;
+  }
+  return `${trimmed}/v1`;
+}
+function getOpenAIApiType(baseUrl) {
+  const normalized = baseUrl.toLowerCase();
+  return normalized.includes("api.openai.com") ? "openai" : "openai-compatible";
+}
+function isGoogleGeminiBaseUrl(baseUrl) {
+  const normalized = baseUrl.toLowerCase();
+  return normalized.includes("generativelanguage.googleapis.com") || normalized.includes("/v1beta");
+}
+async function listAnthropicModels() {
+  const baseUrlRaw = (process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\/+$/, "");
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  const baseUrl = baseUrlRaw.endsWith("/v1") ? baseUrlRaw : `${baseUrlRaw}/v1`;
+  console.log(c.bold("Anthropic Models:"));
+  console.log(c.dim("  API Type: anthropic (official)"));
+  console.log(c.dim(`  Base URL: ${baseUrl}`));
+  if (!apiKey) {
+    console.log(c.red("  ✗ ANTHROPIC_API_KEY not set"));
+    console.log();
+    return;
+  }
+  const res = await fetch(`${baseUrl}/models`, {
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${baseUrl}/models`));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const name = item.display_name ? ` (${item.display_name})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${name}`);
+  }
+  console.log();
+}
+async function listOpenAIModels() {
+  const baseUrl = normalizeOpenAIBaseUrl(process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1");
+  const apiFlavor = getOpenAIApiType(baseUrl);
+  const apiKey = process.env.OPENAI_API_KEY;
+  console.log(c.bold("OpenAI Models:"));
+  console.log(c.dim(`  API Type: ${apiFlavor}`));
+  console.log(c.dim(`  Base URL: ${baseUrl}`));
+  if (!apiKey) {
+    console.log(c.red("  ✗ OPENAI_API_KEY not set"));
+    console.log();
+    return;
+  }
+  const res = await fetch(`${baseUrl}/models`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${baseUrl}/models`));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const owner = item.owned_by ? ` (${item.owned_by})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${owner}`);
+  }
+  console.log();
+}
+async function listGeminiModels() {
+  const baseUrlRaw = (process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta").replace(/\/+$/, "");
+  const apiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+  console.log(c.bold("Gemini Models:"));
+  console.log(c.dim(`  Base URL: ${baseUrlRaw}`));
+  if (!apiKey) {
+    console.log(c.red("  ✗ GEMINI_API_KEY not set"));
+    console.log();
+    return;
+  }
+  if (isGoogleGeminiBaseUrl(baseUrlRaw)) {
+    console.log(c.dim("  API Type: gemini"));
+    const url = `${baseUrlRaw}/models`;
+    const res2 = await fetch(url, {
+      headers: { "x-goog-api-key": apiKey }
+    });
+    if (!res2.ok) {
+      console.log(c.red(`  ✗ Failed to fetch models (${res2.status})`));
+      console.log(c.dim(`  URL: ${url}`));
+      console.log();
+      return;
+    }
+    const payload2 = await res2.json();
+    const items2 = payload2.models ?? [];
+    for (const item of items2) {
+      console.log(`  ${c.green("●")} ${item.name}`);
+    }
+    console.log();
+    return;
+  }
+  const openaiBase = normalizeOpenAIBaseUrl(baseUrlRaw);
+  console.log(c.dim("  API Type: openai-compatible"));
+  console.log(c.dim("  Auth: Bearer (GEMINI_API_KEY)"));
+  const res = await fetch(`${openaiBase}/models`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${openaiBase}/models`));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const owner = item.owned_by ? ` (${item.owned_by})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${owner}`);
+  }
+  console.log();
+}
+async function listModelsSummary() {
+  const provider = getActiveProviderId();
+  const apiType = provider ?? "auto";
+  console.log();
+  console.log(c.bold("Available Models:"));
+  console.log(c.dim(`  Active Provider: ${apiType}`));
+  console.log();
+  printModelsHelp();
+  try {
+    await listOpenAIModels();
+  } catch (error) {
+    console.log(c.red(`  ✗ OpenAI: ${error instanceof Error ? error.message : String(error)}`));
+    console.log();
+  }
+  try {
+    await listGeminiModels();
+  } catch (error) {
+    console.log(c.red(`  ✗ Gemini: ${error instanceof Error ? error.message : String(error)}`));
+    console.log();
+  }
+  await listAnthropicModels();
+}
 function printDebug() {
-  const model = getDefaultModel();
+  const model = getActiveModel();
   const tools = getAllTools();
   const systemPrompt = buildSystemPrompt();
   const cwd = process.cwd();
@@ -5271,14 +6597,20 @@ function printDebug() {
   console.log();
   console.log(c.bold("Model:"));
   console.log(`  ${c.cyan("Current:")}        ${model}`);
+  console.log(`  ${c.cyan("Provider:")}       ${getActiveProviderId() ?? "auto"}`);
+  console.log(`  ${c.cyan("Override:")}       ${currentModelOverride ?? c.dim("(not set)")}`);
   console.log(`  ${c.cyan("ANTHROPIC_MODEL:")} ${process.env.ANTHROPIC_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("GEMINI_MODEL:")}    ${process.env.GEMINI_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("GEMINI_BASE_URL:")} ${process.env.GEMINI_BASE_URL || c.dim("(not set)")}`);
   console.log(`  ${c.cyan("OPENAI_MODEL:")}    ${process.env.OPENAI_MODEL || c.dim("(not set)")}`);
   console.log(`  ${c.cyan("OPENAI_BASE_URL:")} ${process.env.OPENAI_BASE_URL || c.dim("(not set)")}`);
   console.log();
   console.log(c.bold("API Keys:"));
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  const geminiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
   const openaiKey = process.env.OPENAI_API_KEY;
   console.log(`  ${c.cyan("ANTHROPIC_API_KEY:")} ${anthropicKey ? c.green("✓ set") + c.dim(` (${anthropicKey.slice(0, 8)}...${anthropicKey.slice(-4)})`) : c.red("✗ not set")}`);
+  console.log(`  ${c.cyan("GEMINI_API_KEY:")}    ${geminiKey ? c.green("✓ set") + c.dim(` (${geminiKey.slice(0, 8)}...${geminiKey.slice(-4)})`) : c.red("✗ not set")}`);
   console.log(`  ${c.cyan("OPENAI_API_KEY:")}    ${openaiKey ? c.green("✓ set") + c.dim(` (${openaiKey.slice(0, 8)}...${openaiKey.slice(-4)})`) : c.red("✗ not set")}`);
   console.log();
   console.log(c.bold("Environment:"));
@@ -5342,19 +6674,94 @@ function formatToolInput(name, input) {
       return JSON.stringify(input).slice(0, 50);
   }
 }
-function getDefaultModel() {
+function getDefaultProviderFromEnv() {
   if (process.env.ANTHROPIC_API_KEY) {
-    return process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
+    return "anthropic";
   }
   if (process.env.OPENAI_API_KEY) {
-    return process.env.OPENAI_MODEL || "gpt-4o";
+    return "openai";
+  }
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+    return "gemini";
+  }
+  return null;
+}
+function inferProviderFromModel(model) {
+  const normalized = model.toLowerCase();
+  if (normalized.startsWith("claude")) {
+    return "anthropic";
+  }
+  if (normalized.startsWith("gpt") || normalized.startsWith("o1") || normalized.startsWith("chatgpt")) {
+    return "openai";
+  }
+  if (normalized.startsWith("gemini") || normalized.startsWith("models/gemini")) {
+    return "gemini";
+  }
+  return null;
+}
+function getDefaultModelForProvider(providerId) {
+  if (providerId === "anthropic") {
+    return process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
+  }
+  if (providerId === "gemini") {
+    return process.env.GEMINI_MODEL || "gemini-1.5-pro";
+  }
+  return process.env.OPENAI_MODEL || "gpt-5.2";
+}
+function getActiveProviderId() {
+  if (currentProviderId) {
+    return currentProviderId;
+  }
+  if (currentModelOverride) {
+    return inferProviderFromModel(currentModelOverride);
+  }
+  return getDefaultProviderFromEnv();
+}
+function getActiveModel() {
+  if (currentModelOverride) {
+    return currentModelOverride;
+  }
+  const provider = getActiveProviderId();
+  if (provider) {
+    return getDefaultModelForProvider(provider);
   }
   return "claude-sonnet-4-20250514";
 }
+function parseProvider(arg) {
+  const normalized = arg.toLowerCase();
+  if (normalized === "anthropic" || normalized === "claude") {
+    return "anthropic";
+  }
+  if (normalized === "openai" || normalized === "gpt") {
+    return "openai";
+  }
+  if (normalized === "gemini" || normalized === "google") {
+    return "gemini";
+  }
+  return null;
+}
+function createProvider(providerId) {
+  if (providerId === "anthropic") {
+    return new AnthropicProvider;
+  }
+  if (providerId === "gemini") {
+    return new GeminiProvider({
+      apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+      baseUrl: process.env.GEMINI_BASE_URL
+    });
+  }
+  return new OpenAIProvider({
+    apiKey: process.env.OPENAI_API_KEY,
+    baseUrl: process.env.OPENAI_BASE_URL
+  });
+}
 async function getSession() {
   if (!session) {
+    const providerId = getActiveProviderId();
+    const provider = providerId ? createProvider(providerId) : undefined;
     session = await createSession({
-      model: getDefaultModel(),
+      model: getActiveModel(),
+      provider,
       tools: getAllTools(),
       systemPrompt: buildSystemPrompt()
     });
@@ -5412,7 +6819,9 @@ async function handleInput(input) {
     return true;
   }
   if (trimmed.startsWith("/")) {
-    const cmd = trimmed.toLowerCase();
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
     switch (cmd) {
       case "/help":
         printInteractiveHelp();
@@ -5436,6 +6845,9 @@ async function handleInput(input) {
       case "/skills":
         await printSkills();
         return true;
+      case "/models":
+        await handleModelsCommand(args);
+        return true;
       case "/todos":
         printTodos();
         return true;
@@ -5468,9 +6880,9 @@ Error: ${error instanceof Error ? error.message : String(error)}
   return true;
 }
 async function runQuickQuery(query) {
-  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY && !process.env.GEMINI_API_KEY && !process.env.GOOGLE_API_KEY) {
     console.error(c.red("Error: No API key found"));
-    console.error(c.dim("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    console.error(c.dim("Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable"));
     process.exit(1);
   }
   try {
@@ -5484,9 +6896,9 @@ async function runQuickQuery(query) {
   }
 }
 async function runInteractive() {
-  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY && !process.env.GEMINI_API_KEY && !process.env.GOOGLE_API_KEY) {
     console.error(c.red("Error: No API key found"));
-    console.error(c.dim("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    console.error(c.dim("Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable"));
     process.exit(1);
   }
   setTodoChangeCallback(() => {});