fourmis-agents-sdk 0.2.3 → 0.2.5

package/dist/api.js

@@ -369,6 +369,95 @@ async function openBrowser(url) {
 var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann", AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize", TOKEN_URL = "https://auth.openai.com/oauth/token", REDIRECT_URI = "http://localhost:1455/auth/callback", SCOPE = "openid profile email offline_access", CALLBACK_PORT = 1455;
 var init_openai_oauth = () => {};
 
+// src/auth/gemini-oauth.ts
+var exports_gemini_oauth = {};
+__export(exports_gemini_oauth, {
+  loadTokensSync: () => loadTokensSync2,
+  loadTokens: () => loadTokens2,
+  isLoggedIn: () => isLoggedIn2,
+  getValidToken: () => getValidToken2
+});
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function getHome2() {
+  return process.env.HOME ?? homedir2();
+}
+function tokenPath2() {
+  return join2(getHome2(), ".gemini", "oauth_creds.json");
+}
+function loadTokens2() {
+  const p = tokenPath2();
+  try {
+    const raw = readFileSync2(p, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.access_token && data.refresh_token) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+function loadTokensSync2() {
+  return loadTokens2();
+}
+function saveTokens2(tokens) {
+  const p = tokenPath2();
+  const dir = join2(getHome2(), ".gemini");
+  if (!existsSync2(dir)) {
+    const { mkdirSync: mkdirSync2 } = __require("fs");
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(p, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshAccessToken2(refreshToken) {
+  const res = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: GEMINI_CLIENT_ID,
+      client_secret: GEMINI_CLIENT_SECRET,
+      refresh_token: refreshToken
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Gemini token refresh failed (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+async function getValidToken2() {
+  const tokens = loadTokens2();
+  if (!tokens)
+    return null;
+  const expiresAt = tokens.expires_at ?? tokens.expiry_date;
+  const needsRefresh = expiresAt ? expiresAt <= Date.now() + 300000 : true;
+  if (needsRefresh) {
+    try {
+      const fresh = await refreshAccessToken2(tokens.refresh_token);
+      const expiryMs = Date.now() + fresh.expires_in * 1000;
+      const updated = {
+        access_token: fresh.access_token,
+        refresh_token: fresh.refresh_token ?? tokens.refresh_token,
+        token_type: fresh.token_type ?? "Bearer",
+        expires_in: fresh.expires_in,
+        expires_at: expiryMs,
+        expiry_date: expiryMs
+      };
+      saveTokens2(updated);
+      return { accessToken: updated.access_token };
+    } catch {
+      return { accessToken: tokens.access_token };
+    }
+  }
+  return { accessToken: tokens.access_token };
+}
+function isLoggedIn2() {
+  return loadTokens2() !== null;
+}
+var GEMINI_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com", GEMINI_CLIENT_SECRET = "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", GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var init_gemini_oauth = () => {};
+
 // src/types.ts
 function uuid() {
   return crypto.randomUUID();
@@ -833,6 +922,67 @@ function findOpenAIPricing(model) {
   }
   return bestPricing;
 }
+var GEMINI_PRICING = {
+  "gemini-2.5-pro": {
+    inputPerMillion: 1.25,
+    outputPerMillion: 10,
+    cacheReadPerMillion: 0.315
+  },
+  "gemini-2.5-flash": {
+    inputPerMillion: 0.15,
+    outputPerMillion: 0.6,
+    cacheReadPerMillion: 0.0375
+  },
+  "gemini-2.5-flash-lite": {
+    inputPerMillion: 0.075,
+    outputPerMillion: 0.3
+  },
+  "gemini-2.0-flash": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cacheReadPerMillion: 0.025
+  },
+  "gemini-2.0-flash-lite": {
+    inputPerMillion: 0.075,
+    outputPerMillion: 0.3
+  }
+};
+var GEMINI_CONTEXT_WINDOWS = {
+  "gemini-2.5-pro": 1048576,
+  "gemini-2.5-flash": 1048576,
+  "gemini-2.5-flash-lite": 1048576,
+  "gemini-2.0-flash": 1048576,
+  "gemini-2.0-flash-lite": 1048576
+};
+var GEMINI_MAX_OUTPUT = {
+  "gemini-2.5-pro": 65536,
+  "gemini-2.5-flash": 65536,
+  "gemini-2.5-flash-lite": 65536,
+  "gemini-2.0-flash": 8192,
+  "gemini-2.0-flash-lite": 8192
+};
+function calculateGeminiCost(model, usage) {
+  const pricing = findGeminiPricing(model);
+  if (!pricing)
+    return 0;
+  const inputCost = usage.inputTokens / 1e6 * pricing.inputPerMillion;
+  const outputCost = usage.outputTokens / 1e6 * pricing.outputPerMillion;
+  const cacheReadCost = usage.cacheReadInputTokens / 1e6 * (pricing.cacheReadPerMillion ?? pricing.inputPerMillion);
+  return inputCost + outputCost + cacheReadCost;
+}
+function findGeminiPricing(model) {
+  if (GEMINI_PRICING[model])
+    return GEMINI_PRICING[model];
+  let bestKey = "";
+  let bestPricing;
+  for (const [key, pricing] of Object.entries(GEMINI_PRICING)) {
+    if (model.startsWith(key) && key.length > bestKey.length) {
+      bestKey = key;
+      bestPricing = pricing;
+    }
+  }
+  return bestPricing;
+}
 
 // src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -1469,6 +1619,398 @@ function loadTokensSync() {
   return null;
 }
 
+// src/providers/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+var CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+var CODE_ASSIST_API_VERSION = "v1internal";
+
+class GeminiAdapter {
+  name = "gemini";
+  client = null;
+  oauthMode;
+  currentAccessToken;
+  projectId;
+  constructor(options) {
+    const key = options?.apiKey ?? process.env.GEMINI_API_KEY;
+    if (key) {
+      this.oauthMode = false;
+      this.client = new GoogleGenAI({ apiKey: key });
+    } else {
+      const tokens = loadTokensSync3();
+      if (tokens) {
+        this.oauthMode = true;
+        this.currentAccessToken = tokens.access_token;
+      } else {
+        this.oauthMode = false;
+        this.client = new GoogleGenAI({ apiKey: "" });
+      }
+    }
+  }
+  async* chat(request) {
+    if (this.oauthMode) {
+      yield* this.chatCodeAssist(request);
+    } else {
+      yield* this.chatSdk(request);
+    }
+  }
+  calculateCost(model, usage) {
+    return calculateGeminiCost(model, usage);
+  }
+  getContextWindow(model) {
+    return GEMINI_CONTEXT_WINDOWS[model] ?? 1048576;
+  }
+  supportsFeature(feature) {
+    switch (feature) {
+      case "streaming":
+      case "tool_calling":
+      case "image_input":
+      case "structured_output":
+      case "thinking":
+      case "pdf_input":
+        return true;
+      default:
+        return false;
+    }
+  }
+  async* chatSdk(request) {
+    const contents = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const maxTokens = request.maxTokens ?? GEMINI_MAX_OUTPUT[request.model] ?? 65536;
+    const config = {
+      maxOutputTokens: maxTokens,
+      abortSignal: request.signal ?? undefined
+    };
+    if (request.systemPrompt) {
+      config.systemInstruction = request.systemPrompt;
+    }
+    if (request.temperature !== undefined) {
+      config.temperature = request.temperature;
+    }
+    if (tools) {
+      config.tools = [{ functionDeclarations: tools }];
+    }
+    const stream = await this.client.models.generateContentStream({
+      model: request.model,
+      contents,
+      config
+    });
+    let hasToolCalls = false;
+    for await (const chunk of stream) {
+      if (chunk.usageMetadata) {
+        const u = chunk.usageMetadata;
+        const cached = u.cachedContentTokenCount ?? 0;
+        yield {
+          type: "usage",
+          usage: {
+            inputTokens: (u.promptTokenCount ?? 0) - cached,
+            outputTokens: u.candidatesTokenCount ?? 0,
+            cacheReadInputTokens: cached,
+            cacheCreationInputTokens: 0
+          }
+        };
+      }
+      const candidate = chunk.candidates?.[0];
+      if (!candidate?.content?.parts)
+        continue;
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          if (part.thought) {
+            yield { type: "thinking_delta", text: part.text };
+          } else {
+            yield { type: "text_delta", text: part.text };
+          }
+        }
+        if (part.functionCall) {
+          hasToolCalls = true;
+          yield {
+            type: "tool_call",
+            id: part.functionCall.id ?? crypto.randomUUID(),
+            name: part.functionCall.name ?? "",
+            input: part.functionCall.args ?? {}
+          };
+        }
+      }
+      if (candidate.finishReason) {
+        yield {
+          type: "done",
+          stopReason: this.mapFinishReason(candidate.finishReason, hasToolCalls)
+        };
+        return;
+      }
+    }
+    yield { type: "done", stopReason: hasToolCalls ? "tool_use" : "end_turn" };
+  }
+  async* chatCodeAssist(request) {
+    await this.refreshTokenIfNeeded();
+    await this.ensureProjectId();
+    const contents = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const maxTokens = request.maxTokens ?? GEMINI_MAX_OUTPUT[request.model] ?? 65536;
+    const generationConfig = {
+      maxOutputTokens: maxTokens
+    };
+    if (request.temperature !== undefined) {
+      generationConfig.temperature = request.temperature;
+    }
+    const innerRequest = {
+      contents,
+      generationConfig
+    };
+    if (request.systemPrompt) {
+      innerRequest.systemInstruction = {
+        parts: [{ text: request.systemPrompt }]
+      };
+    }
+    if (tools) {
+      innerRequest.tools = [{ functionDeclarations: tools }];
+    }
+    const body = {
+      model: request.model,
+      project: this.projectId,
+      request: innerRequest
+    };
+    const url = `${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:streamGenerateContent?alt=sse`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.currentAccessToken}`
+      },
+      body: JSON.stringify(body),
+      signal: request.signal ?? undefined
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Gemini Code Assist API error (${res.status}): ${text}`);
+    }
+    yield* this.parseSSEStream(res);
+  }
+  async* parseSSEStream(res) {
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    let hasToolCalls = false;
+    let dataLines = [];
+    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: ")) {
+          dataLines.push(line.slice(6));
+        } else if (line.trim() === "" && dataLines.length > 0) {
+          const json = dataLines.join(`
+`);
+          dataLines = [];
+          let obj;
+          try {
+            obj = JSON.parse(json);
+          } catch {
+            continue;
+          }
+          const response = obj.response ?? obj;
+          const candidate = response?.candidates?.[0];
+          if (candidate?.content?.parts) {
+            for (const part of candidate.content.parts) {
+              if (part.text) {
+                if (part.thought) {
+                  yield { type: "thinking_delta", text: part.text };
+                } else {
+                  yield { type: "text_delta", text: part.text };
+                }
+              }
+              if (part.functionCall) {
+                hasToolCalls = true;
+                yield {
+                  type: "tool_call",
+                  id: part.functionCall.id ?? crypto.randomUUID(),
+                  name: part.functionCall.name ?? "",
+                  input: part.functionCall.args ?? {}
+                };
+              }
+            }
+          }
+          if (response?.usageMetadata) {
+            const u = response.usageMetadata;
+            const cached = u.cachedContentTokenCount ?? 0;
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: (u.promptTokenCount ?? 0) - cached,
+                outputTokens: u.candidatesTokenCount ?? 0,
+                cacheReadInputTokens: cached,
+                cacheCreationInputTokens: 0
+              }
+            };
+          }
+          if (candidate?.finishReason) {
+            yield {
+              type: "done",
+              stopReason: this.mapFinishReason(candidate.finishReason, hasToolCalls)
+            };
+            return;
+          }
+        }
+      }
+    }
+    if (dataLines.length > 0) {
+      const json = dataLines.join(`
+`);
+      try {
+        const obj = JSON.parse(json);
+        const response = obj.response ?? obj;
+        const candidate = response?.candidates?.[0];
+        if (candidate?.finishReason) {
+          yield {
+            type: "done",
+            stopReason: this.mapFinishReason(candidate.finishReason, hasToolCalls)
+          };
+          return;
+        }
+      } catch {}
+    }
+    yield { type: "done", stopReason: hasToolCalls ? "tool_use" : "end_turn" };
+  }
+  async refreshTokenIfNeeded() {
+    if (!this.oauthMode)
+      return;
+    try {
+      const { getValidToken: getValidToken3 } = await Promise.resolve().then(() => (init_gemini_oauth(), exports_gemini_oauth));
+      const result = await getValidToken3();
+      if (result && result.accessToken !== this.currentAccessToken) {
+        this.currentAccessToken = result.accessToken;
+      }
+    } catch {}
+  }
+  async ensureProjectId() {
+    if (this.projectId)
+      return;
+    this.projectId = process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT_ID ?? undefined;
+    if (this.projectId)
+      return;
+    try {
+      const res = await fetch(`${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:loadCodeAssist`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.currentAccessToken}`
+        },
+        body: JSON.stringify({
+          metadata: {
+            ideType: "IDE_UNSPECIFIED",
+            platform: "PLATFORM_UNSPECIFIED",
+            pluginType: "GEMINI"
+          }
+        })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        this.projectId = data.cloudaicompanionProject;
+      }
+    } catch {}
+  }
+  convertMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        result.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts: [{ text: msg.content }]
+        });
+        continue;
+      }
+      if (msg.role === "assistant") {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            parts.push({ text: block.text });
+          } else if (block.type === "tool_use") {
+            parts.push({
+              functionCall: {
+                name: block.name,
+                args: block.input
+              }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          result.push({ role: "model", parts });
+        }
+      } else {
+        const textParts = [];
+        const functionResponseParts = [];
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            textParts.push({ text: block.text });
+          } else if (block.type === "tool_result") {
+            functionResponseParts.push({
+              functionResponse: {
+                name: findToolName(messages, block.tool_use_id) ?? "unknown",
+                response: { result: block.content }
+              }
+            });
+          }
+        }
+        if (functionResponseParts.length > 0) {
+          result.push({ role: "user", parts: functionResponseParts });
+        }
+        if (textParts.length > 0) {
+          result.push({ role: "user", parts: textParts });
+        }
+      }
+    }
+    return result;
+  }
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+  }
+  mapFinishReason(reason, hasToolCalls) {
+    if (hasToolCalls)
+      return "tool_use";
+    switch (reason) {
+      case "STOP":
+        return "end_turn";
+      case "MAX_TOKENS":
+        return "max_tokens";
+      default:
+        return "end_turn";
+    }
+  }
+}
+function findToolName(messages, toolUseId) {
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || typeof msg.content === "string")
+      continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id === toolUseId) {
+        return block.name;
+      }
+    }
+  }
+  return;
+}
+function loadTokensSync3() {
+  const home = process.env.HOME ?? __require("os").homedir();
+  const path = `${home}/.gemini/oauth_creds.json`;
+  try {
+    const fs = __require("fs");
+    const raw = fs.readFileSync(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.access_token && data.refresh_token) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+
 // src/providers/registry.ts
 var providers = new Map;
 function registerProvider(name, adapter) {
@@ -1494,6 +2036,13 @@ function getProvider(name, options) {
     }
     return adapter;
   }
+  if (name === "gemini") {
+    const adapter = new GeminiAdapter(options);
+    if (!options?.apiKey && !options?.baseUrl) {
+      providers.set(name, adapter);
+    }
+    return adapter;
+  }
   throw new Error(`Unknown provider: "${name}". Register it with registerProvider() first.`);
 }
 function listProviders() {
@@ -2058,8 +2607,6 @@ var ALL_TOOLS = {
 function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
   const registry = new ToolRegistry;
   for (const name of toolNames) {
-    if (allowedTools && !allowedTools.includes(name))
-      continue;
     if (disallowedTools?.includes(name))
       continue;
     const tool = ALL_TOOLS[name];
@@ -2212,9 +2759,9 @@ class PermissionManager {
 }
 
 // src/settings.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 
 class SettingsManager {
   cwd;
@@ -2292,36 +2839,36 @@ class SettingsManager {
         return;
     }
     const dir = dirname2(path);
-    if (!existsSync2(dir))
+    if (!existsSync3(dir))
       mkdirSync2(dir, { recursive: true });
-    writeFileSync2(path, JSON.stringify(data, null, 2) + `
+    writeFileSync3(path, JSON.stringify(data, null, 2) + `
 `);
   }
   sourceToPath(source) {
     switch (source) {
       case "user":
-        return join2(homedir2(), ".claude", "settings.json");
+        return join3(homedir3(), ".claude", "settings.json");
       case "project":
-        return join2(this.cwd, ".claude", "settings.json");
+        return join3(this.cwd, ".claude", "settings.json");
       case "local":
-        return join2(this.cwd, ".claude", "settings.local.json");
+        return join3(this.cwd, ".claude", "settings.local.json");
     }
   }
   destinationToPath(destination) {
     switch (destination) {
       case "userSettings":
-        return join2(homedir2(), ".claude", "settings.json");
+        return join3(homedir3(), ".claude", "settings.json");
       case "projectSettings":
-        return join2(this.cwd, ".claude", "settings.json");
+        return join3(this.cwd, ".claude", "settings.json");
       case "localSettings":
-        return join2(this.cwd, ".claude", "settings.local.json");
+        return join3(this.cwd, ".claude", "settings.local.json");
       default:
         return null;
     }
   }
   readJson(path) {
     try {
-      const content = readFileSync2(path, "utf-8");
+      const content = readFileSync3(path, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -2339,8 +2886,8 @@ class SettingsManager {
 }
 
 // src/utils/system-prompt.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 var CORE_IDENTITY = `You are an AI coding agent. You help users with software engineering tasks by reading, writing, and modifying code. You have access to tools that let you interact with the filesystem and execute commands.
 
 You are highly capable and can help users complete complex tasks that would otherwise be too difficult or time-consuming.`;
@@ -2421,7 +2968,7 @@ ${instructions}`);
 function readProjectInstructions(cwd) {
   for (const name of ["CLAUDE.md", "AGENTS.md"]) {
     try {
-      const content = readFileSync3(join3(cwd, name), "utf-8").trim();
+      const content = readFileSync4(join4(cwd, name), "utf-8").trim();
       if (content)
         return content;
     } catch {}
@@ -2542,11 +3089,16 @@ class McpClientManager {
         await client.connect(clientTransport);
       } else if (config.type === "sse") {
         const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
-        const transport = new SSEClientTransport(new URL(config.url));
+        const opts = config.headers ? {
+          eventSourceInit: { headers: config.headers },
+          requestInit: { headers: config.headers }
+        } : undefined;
+        const transport = new SSEClientTransport(new URL(config.url), opts);
         await client.connect(transport);
       } else if (config.type === "http") {
         const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
-        const transport = new StreamableHTTPClientTransport(new URL(config.url));
+        const requestInit = config.headers ? { headers: config.headers } : undefined;
+        const transport = new StreamableHTTPClientTransport(new URL(config.url), { requestInit });
         await client.connect(transport);
       } else {
         const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
@@ -2929,21 +3481,21 @@ class TaskManager {
 }
 
 // src/utils/session-store.ts
-import { readFileSync as readFileSync4, appendFileSync, mkdirSync as mkdirSync3, readdirSync, statSync } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync3, readdirSync, statSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 function sanitizeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
 }
 function sessionsDir(cwd) {
-  return join4(homedir3(), ".claude", "projects", sanitizeCwd(cwd));
+  return join5(homedir4(), ".claude", "projects", sanitizeCwd(cwd));
 }
 function ensureDir(dir) {
   mkdirSync3(dir, { recursive: true });
 }
 function logMessage(dir, sessionId, entry) {
   ensureDir(dir);
-  const filePath = join4(dir, `${sessionId}.jsonl`);
+  const filePath = join5(dir, `${sessionId}.jsonl`);
   appendFileSync(filePath, JSON.stringify(entry) + `
 `);
 }
@@ -2981,7 +3533,7 @@ function findLatestSession(cwd) {
   const dir = sessionsDir(cwd);
   try {
     const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
-      const filePath = join4(dir, f);
+      const filePath = join5(dir, f);
       try {
         return { name: f, mtime: statSync(filePath).mtimeMs };
       } catch {
@@ -2997,10 +3549,10 @@ function findLatestSession(cwd) {
 }
 function loadSessionMessages(cwd, sessionId) {
   const dir = sessionsDir(cwd);
-  const filePath = join4(dir, `${sessionId}.jsonl`);
+  const filePath = join5(dir, `${sessionId}.jsonl`);
   let lines;
   try {
-    lines = readFileSync4(filePath, "utf-8").trim().split(`
+    lines = readFileSync5(filePath, "utf-8").trim().split(`
 `).filter(Boolean);
   } catch {
     return [];
@@ -3044,7 +3596,7 @@ function query(params) {
   });
   const model = options.model ?? DEFAULT_MODEL;
   const toolNames = resolveToolNames(options.tools);
-  const registry = buildToolRegistry(toolNames, options.allowedTools, options.disallowedTools);
+  const registry = buildToolRegistry(toolNames, undefined, options.disallowedTools);
   const systemPrompt = options.systemPrompt ?? buildSystemPrompt({
     tools: registry.list(),
     cwd: options.cwd,
@@ -3072,6 +3624,14 @@ function query(params) {
         mergedPermissions.deny = mergedDeny;
     }
   }
+  if (options.allowedTools && options.allowedTools.length > 0) {
+    if (!mergedPermissions)
+      mergedPermissions = {};
+    mergedPermissions.allow = [
+      ...mergedPermissions.allow ?? [],
+      ...options.allowedTools
+    ];
+  }
   const permissions = new PermissionManager(options.permissionMode ?? "default", options.canUseTool, mergedPermissions, settingsManager);
   const cwd = options.cwd ?? process.cwd();
   let sessionId = options.sessionId ?? uuid();