geminisdk 0.1.1

package/dist/index.mjs

@@ -0,0 +1,1480 @@
+import {
+  EventType,
+  GEMINI_CLI_MODELS,
+  GEMINI_CODE_ASSIST_API_VERSION,
+  GEMINI_CODE_ASSIST_ENDPOINT,
+  GEMINI_CREDENTIAL_FILENAME,
+  GEMINI_DIR,
+  GEMINI_ENV_FILENAME,
+  GEMINI_OAUTH_AUTH_ENDPOINT,
+  GEMINI_OAUTH_BASE_URL,
+  GEMINI_OAUTH_CLIENT_ID,
+  GEMINI_OAUTH_CLIENT_SECRET,
+  GEMINI_OAUTH_REDIRECT_URI,
+  GEMINI_OAUTH_SCOPES,
+  GEMINI_OAUTH_TOKEN_ENDPOINT,
+  HTTP_FORBIDDEN,
+  HTTP_OK,
+  HTTP_UNAUTHORIZED,
+  Role,
+  TOKEN_REFRESH_BUFFER_MS,
+  getGeminiCliCredentialPath,
+  getGeminiCliEnvPath
+} from "./chunk-Y4MC6YDW.mjs";
+
+// src/auth.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/exceptions.ts
+var GeminiSDKError = class extends Error {
+  details;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "GeminiSDKError";
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AuthenticationError = class extends GeminiSDKError {
+  constructor(message = "Authentication failed", details = {}) {
+    super(message, details);
+    this.name = "AuthenticationError";
+  }
+};
+var CredentialsNotFoundError = class extends AuthenticationError {
+  credentialPath;
+  constructor(credentialPath, message) {
+    const msg = message ?? `Gemini OAuth credentials not found at ${credentialPath}. Please login using the Gemini CLI first: gemini auth login`;
+    super(msg, { credentialPath });
+    this.name = "CredentialsNotFoundError";
+    this.credentialPath = credentialPath;
+  }
+};
+var TokenRefreshError = class extends AuthenticationError {
+  statusCode;
+  responseBody;
+  constructor(message = "Failed to refresh access token", statusCode, responseBody) {
+    const details = {};
+    if (statusCode !== void 0) details["statusCode"] = statusCode;
+    if (responseBody !== void 0) details["responseBody"] = responseBody;
+    super(message, details);
+    this.name = "TokenRefreshError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+  }
+};
+var TokenExpiredError = class extends AuthenticationError {
+  constructor(message = "Access token has expired") {
+    super(message);
+    this.name = "TokenExpiredError";
+  }
+};
+var ConnectionError = class extends GeminiSDKError {
+  endpoint;
+  constructor(message = "Failed to connect to Gemini API", endpoint, details = {}) {
+    if (endpoint) details["endpoint"] = endpoint;
+    super(message, details);
+    this.name = "ConnectionError";
+    this.endpoint = endpoint;
+  }
+};
+var APIError = class extends GeminiSDKError {
+  statusCode;
+  responseBody;
+  endpoint;
+  constructor(message, statusCode, responseBody, endpoint) {
+    const details = { statusCode };
+    if (responseBody !== void 0) details["responseBody"] = responseBody;
+    if (endpoint !== void 0) details["endpoint"] = endpoint;
+    super(message, details);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.endpoint = endpoint;
+  }
+};
+var RateLimitError = class extends APIError {
+  retryAfter;
+  constructor(message = "Rate limit exceeded", statusCode = 429, retryAfter, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    if (retryAfter !== void 0) this.details["retryAfter"] = retryAfter;
+  }
+};
+var QuotaExceededError = class extends APIError {
+  resetTime;
+  constructor(message = "Quota exceeded", statusCode = 429, resetTime, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "QuotaExceededError";
+    this.resetTime = resetTime;
+    if (resetTime !== void 0) this.details["resetTime"] = resetTime;
+  }
+};
+var PermissionDeniedError = class extends APIError {
+  constructor(message = "Permission denied", statusCode = 403, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends APIError {
+  resource;
+  constructor(message = "Resource not found", statusCode = 404, resource, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "NotFoundError";
+    this.resource = resource;
+    if (resource !== void 0) this.details["resource"] = resource;
+  }
+};
+var SessionError = class extends GeminiSDKError {
+  sessionId;
+  constructor(message, sessionId, details = {}) {
+    if (sessionId) details["sessionId"] = sessionId;
+    super(message, details);
+    this.name = "SessionError";
+    this.sessionId = sessionId;
+  }
+};
+var SessionNotFoundError = class extends SessionError {
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`, sessionId);
+    this.name = "SessionNotFoundError";
+  }
+};
+var SessionClosedError = class extends SessionError {
+  constructor(sessionId) {
+    super("Session is closed", sessionId);
+    this.name = "SessionClosedError";
+  }
+};
+var ToolError = class extends GeminiSDKError {
+  toolName;
+  constructor(message, toolName, details = {}) {
+    if (toolName) details["toolName"] = toolName;
+    super(message, details);
+    this.name = "ToolError";
+    this.toolName = toolName;
+  }
+};
+var ToolNotFoundError = class extends ToolError {
+  constructor(toolName) {
+    super(`Tool not found: ${toolName}`, toolName);
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolExecutionError = class extends ToolError {
+  originalError;
+  constructor(message, toolName, originalError) {
+    const details = {};
+    if (originalError) details["originalError"] = originalError.message;
+    super(message, toolName, details);
+    this.name = "ToolExecutionError";
+    this.originalError = originalError;
+  }
+};
+var ValidationError = class extends GeminiSDKError {
+  field;
+  value;
+  constructor(message, field, value) {
+    const details = {};
+    if (field !== void 0) details["field"] = field;
+    if (value !== void 0) details["value"] = String(value);
+    super(message, details);
+    this.name = "ValidationError";
+    this.field = field;
+    this.value = value;
+  }
+};
+var ConfigurationError = class extends GeminiSDKError {
+  configKey;
+  constructor(message, configKey) {
+    const details = {};
+    if (configKey) details["configKey"] = configKey;
+    super(message, details);
+    this.name = "ConfigurationError";
+    this.configKey = configKey;
+  }
+};
+var StreamError = class extends GeminiSDKError {
+  partialContent;
+  constructor(message, partialContent) {
+    const details = {};
+    if (partialContent) details["partialContent"] = partialContent.slice(0, 500);
+    super(message, details);
+    this.name = "StreamError";
+    this.partialContent = partialContent;
+  }
+};
+var CancellationError = class extends GeminiSDKError {
+  constructor(message = "Operation was cancelled") {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+var TimeoutError = class extends GeminiSDKError {
+  timeout;
+  constructor(message = "Operation timed out", timeout) {
+    const details = {};
+    if (timeout !== void 0) details["timeout"] = timeout;
+    super(message, details);
+    this.name = "TimeoutError";
+    this.timeout = timeout;
+  }
+};
+var OnboardingError = class extends GeminiSDKError {
+  tierId;
+  constructor(message = "Failed to complete Gemini Code Assist onboarding", tierId) {
+    const details = {};
+    if (tierId) details["tierId"] = tierId;
+    super(message, details);
+    this.name = "OnboardingError";
+    this.tierId = tierId;
+  }
+};
+
+// src/auth.ts
+var GeminiOAuthManager = class {
+  oauthPath;
+  clientId;
+  clientSecret;
+  credentials = null;
+  refreshLock = null;
+  projectId = null;
+  constructor(oauthPath, clientId, clientSecret) {
+    this.oauthPath = oauthPath;
+    this.clientId = clientId ?? GEMINI_OAUTH_CLIENT_ID;
+    this.clientSecret = clientSecret ?? GEMINI_OAUTH_CLIENT_SECRET;
+  }
+  getCredentialPath() {
+    return getGeminiCliCredentialPath(this.oauthPath);
+  }
+  loadCachedCredentials() {
+    const keyFile = this.getCredentialPath();
+    try {
+      const data = JSON.parse(fs.readFileSync(keyFile, "utf-8"));
+      return {
+        accessToken: data["access_token"],
+        refreshToken: data["refresh_token"],
+        tokenType: data["token_type"] ?? "Bearer",
+        expiryDate: data["expiry_date"] ?? 0
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new CredentialsNotFoundError(keyFile);
+      }
+      throw new AuthenticationError(
+        `Invalid Gemini OAuth credentials file at ${keyFile}: ${error}`
+      );
+    }
+  }
+  saveCredentials(credentials) {
+    const keyFile = this.getCredentialPath();
+    const dir = path.dirname(keyFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const data = {
+      access_token: credentials.accessToken,
+      refresh_token: credentials.refreshToken,
+      token_type: credentials.tokenType,
+      expiry_date: credentials.expiryDate
+    };
+    fs.writeFileSync(keyFile, JSON.stringify(data, null, 2), "utf-8");
+  }
+  async refreshAccessToken(credentials) {
+    if (this.refreshLock) {
+      return this.refreshLock;
+    }
+    this.refreshLock = this.doRefresh(credentials);
+    try {
+      return await this.refreshLock;
+    } finally {
+      this.refreshLock = null;
+    }
+  }
+  async doRefresh(credentials) {
+    if (!credentials.refreshToken) {
+      throw new TokenRefreshError("No refresh token available in credentials.");
+    }
+    const bodyData = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: credentials.refreshToken,
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      scope: GEMINI_OAUTH_SCOPES.join(" ")
+    });
+    const response = await fetch(GEMINI_OAUTH_TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+      },
+      body: bodyData.toString()
+    });
+    if (response.status !== HTTP_OK) {
+      throw new TokenRefreshError(
+        `Token refresh failed: ${response.status} ${response.statusText}`,
+        response.status,
+        await response.text()
+      );
+    }
+    const tokenData = await response.json();
+    if (tokenData["error"]) {
+      throw new TokenRefreshError(
+        `Token refresh failed: ${tokenData["error"]} - ${tokenData["error_description"] ?? "Unknown error"}`
+      );
+    }
+    const newCredentials = {
+      accessToken: tokenData["access_token"],
+      tokenType: tokenData["token_type"] ?? "Bearer",
+      refreshToken: tokenData["refresh_token"] ?? credentials.refreshToken,
+      expiryDate: Date.now() + (tokenData["expires_in"] ?? 3600) * 1e3
+    };
+    this.saveCredentials(newCredentials);
+    this.credentials = newCredentials;
+    return newCredentials;
+  }
+  isTokenValid(credentials) {
+    if (!credentials.expiryDate) return false;
+    return Date.now() < credentials.expiryDate - TOKEN_REFRESH_BUFFER_MS;
+  }
+  invalidateCredentials() {
+    this.credentials = null;
+  }
+  async ensureAuthenticated(forceRefresh = false) {
+    if (this.credentials === null) {
+      this.credentials = this.loadCachedCredentials();
+    }
+    if (forceRefresh || !this.isTokenValid(this.credentials)) {
+      this.credentials = await this.refreshAccessToken(this.credentials);
+    }
+    return this.credentials.accessToken;
+  }
+  async getCredentials() {
+    await this.ensureAuthenticated();
+    return this.credentials;
+  }
+  getApiEndpoint() {
+    return `${GEMINI_CODE_ASSIST_ENDPOINT}/${GEMINI_CODE_ASSIST_API_VERSION}`;
+  }
+  getProjectId() {
+    const envProjectId = process.env["GOOGLE_CLOUD_PROJECT"];
+    if (envProjectId) return envProjectId;
+    const envFile = getGeminiCliEnvPath(
+      this.oauthPath ? path.dirname(this.getCredentialPath()) : void 0
+    );
+    if (fs.existsSync(envFile)) {
+      try {
+        const content = fs.readFileSync(envFile, "utf-8");
+        for (const line of content.split("\n")) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("GOOGLE_CLOUD_PROJECT=")) {
+            return trimmed.split("=")[1]?.trim().replace(/['"]/g, "") ?? null;
+          }
+        }
+      } catch {
+      }
+    }
+    return this.projectId;
+  }
+  setProjectId(projectId) {
+    this.projectId = projectId;
+  }
+  generateAuthUrl(state, codeVerifier) {
+    const params = new URLSearchParams({
+      client_id: this.clientId,
+      redirect_uri: GEMINI_OAUTH_REDIRECT_URI,
+      response_type: "code",
+      scope: GEMINI_OAUTH_SCOPES.join(" "),
+      access_type: "offline",
+      state
+    });
+    if (codeVerifier) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(codeVerifier);
+      params.set("code_challenge_method", "S256");
+    }
+    return `${GEMINI_OAUTH_AUTH_ENDPOINT}?${params.toString()}`;
+  }
+  async exchangeCode(code, codeVerifier) {
+    const bodyData = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      redirect_uri: GEMINI_OAUTH_REDIRECT_URI
+    });
+    if (codeVerifier) {
+      bodyData.set("code_verifier", codeVerifier);
+    }
+    const response = await fetch(GEMINI_OAUTH_TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json"
+      },
+      body: bodyData.toString()
+    });
+    if (response.status !== HTTP_OK) {
+      throw new AuthenticationError(
+        `Code exchange failed: ${response.status} - ${await response.text()}`
+      );
+    }
+    const tokenData = await response.json();
+    if (tokenData["error"]) {
+      throw new AuthenticationError(
+        `Code exchange failed: ${tokenData["error"]} - ${tokenData["error_description"] ?? "Unknown error"}`
+      );
+    }
+    const credentials = {
+      accessToken: tokenData["access_token"],
+      refreshToken: tokenData["refresh_token"],
+      tokenType: tokenData["token_type"] ?? "Bearer",
+      expiryDate: Date.now() + (tokenData["expires_in"] ?? 3600) * 1e3
+    };
+    this.saveCredentials(credentials);
+    this.credentials = credentials;
+    return credentials;
+  }
+};
+
+// src/backend.ts
+import { v4 as uuidv4 } from "uuid";
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([HTTP_UNAUTHORIZED, HTTP_FORBIDDEN]);
+var ONBOARD_MAX_RETRIES = 30;
+var ONBOARD_SLEEP_SECONDS = 2;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function generateUUID() {
+  try {
+    return uuidv4();
+  } catch {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+}
+var GeminiBackend = class {
+  timeout;
+  oauthManager;
+  projectId = null;
+  constructor(options = {}) {
+    this.timeout = options.timeout ?? 72e4;
+    this.oauthManager = new GeminiOAuthManager(
+      options.oauthPath,
+      options.clientId,
+      options.clientSecret
+    );
+  }
+  async getAuthHeaders(forceRefresh = false) {
+    const accessToken = await this.oauthManager.ensureAuthenticated(forceRefresh);
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`
+    };
+  }
+  prepareMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+      const role = msg.role === "assistant" /* ASSISTANT */ ? "model" : "user";
+      const contentParts = [];
+      if (msg.content) {
+        if (typeof msg.content === "string") {
+          contentParts.push({ text: msg.content });
+        } else {
+          for (const part of msg.content) {
+            if (part.text) {
+              contentParts.push({ text: part.text });
+            } else if (part.imageData && part.imageMimeType) {
+              contentParts.push({
+                inlineData: {
+                  mimeType: part.imageMimeType,
+                  data: part.imageData instanceof Uint8Array ? Buffer.from(part.imageData).toString("base64") : part.imageData
+                }
+              });
+            }
+          }
+        }
+      }
+      if (msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          const args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+          contentParts.push({
+            functionCall: {
+              name: tc.function.name,
+              args
+            }
+          });
+        }
+      }
+      if (msg.toolCallId) {
+        contentParts.push({
+          functionResponse: {
+            name: msg.name ?? "",
+            response: typeof msg.content === "string" ? { result: msg.content } : msg.content
+          }
+        });
+      }
+      if (contentParts.length > 0) {
+        result.push({ role, parts: contentParts });
+      }
+    }
+    return result;
+  }
+  prepareTools(tools) {
+    if (!tools || tools.length === 0) return void 0;
+    const funcDecls = [];
+    for (const tool of tools) {
+      const funcDef = {
+        name: tool.name,
+        description: tool.description ?? ""
+      };
+      if (tool.parameters) {
+        funcDef["parameters"] = {
+          type: "object",
+          properties: tool.parameters["properties"] ?? {},
+          required: tool.parameters["required"] ?? []
+        };
+      }
+      funcDecls.push(funcDef);
+    }
+    return [{ functionDeclarations: funcDecls }];
+  }
+  async ensureProjectId(accessToken) {
+    if (this.projectId !== null) return this.projectId;
+    const envProjectId = this.oauthManager.getProjectId();
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    };
+    const clientMetadata = {
+      ideType: "IDE_UNSPECIFIED",
+      platform: "PLATFORM_UNSPECIFIED",
+      pluginType: "GEMINI",
+      duetProject: envProjectId
+    };
+    const loadRequest = {
+      cloudaicompanionProject: envProjectId,
+      metadata: clientMetadata
+    };
+    try {
+      const url = `${this.oauthManager.getApiEndpoint()}:loadCodeAssist`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(loadRequest)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      if (data["currentTier"]) {
+        const projectFromApi = data["cloudaicompanionProject"];
+        if (projectFromApi) {
+          this.projectId = projectFromApi;
+          return projectFromApi;
+        }
+        if (envProjectId) {
+          this.projectId = envProjectId;
+          return envProjectId;
+        }
+        this.projectId = "";
+        return "";
+      }
+      const allowedTiers = data["allowedTiers"] ?? [];
+      let tierId = "free-tier";
+      for (const tier of allowedTiers) {
+        if (tier["isDefault"]) {
+          tierId = tier["id"] ?? "free-tier";
+          break;
+        }
+      }
+      return this.onboardForProject(headers, envProjectId, clientMetadata, tierId);
+    } catch (error) {
+      throw new APIError(
+        `Gemini Code Assist access denied: ${error}`,
+        403,
+        String(error)
+      );
+    }
+  }
+  async onboardForProject(headers, envProjectId, clientMetadata, tierId) {
+    const onboardRequest = tierId === "free-tier" ? {
+      tierId,
+      cloudaicompanionProject: null,
+      metadata: clientMetadata
+    } : {
+      tierId,
+      cloudaicompanionProject: envProjectId,
+      metadata: { ...clientMetadata, duetProject: envProjectId }
+    };
+    const url = `${this.oauthManager.getApiEndpoint()}:onboardUser`;
+    for (let i = 0; i < ONBOARD_MAX_RETRIES; i++) {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(onboardRequest)
+      });
+      if (!response.ok) {
+        throw new Error(`Onboard failed: ${response.status}`);
+      }
+      const lroData = await response.json();
+      if (lroData["done"]) {
+        const responseData = lroData["response"] ?? {};
+        const cloudAiCompanion = responseData["cloudaicompanionProject"];
+        if (cloudAiCompanion?.["id"]) {
+          this.projectId = cloudAiCompanion["id"];
+          return this.projectId;
+        }
+        break;
+      }
+      await sleep(ONBOARD_SLEEP_SECONDS * 1e3);
+    }
+    if (tierId === "free-tier") {
+      this.projectId = "";
+      return "";
+    }
+    throw new OnboardingError(void 0, tierId);
+  }
+  buildRequestPayload(model, messages, generationConfig, thinkingConfig, tools, projectId = "") {
+    const genConfig = {
+      temperature: generationConfig?.temperature ?? 0.7
+    };
+    if (generationConfig?.maxOutputTokens) {
+      genConfig["maxOutputTokens"] = generationConfig.maxOutputTokens;
+    }
+    if (generationConfig?.topP !== void 0) {
+      genConfig["topP"] = generationConfig.topP;
+    }
+    if (generationConfig?.topK !== void 0) {
+      genConfig["topK"] = generationConfig.topK;
+    }
+    if (generationConfig?.stopSequences) {
+      genConfig["stopSequences"] = generationConfig.stopSequences;
+    }
+    if (thinkingConfig?.includeThoughts) {
+      genConfig["thinkingConfig"] = {
+        includeThoughts: thinkingConfig.includeThoughts,
+        ...thinkingConfig.thinkingBudget && {
+          thinkingBudget: thinkingConfig.thinkingBudget
+        }
+      };
+    }
+    const requestBody = {
+      contents: this.prepareMessages(messages),
+      generationConfig: genConfig
+    };
+    const preparedTools = this.prepareTools(tools);
+    if (preparedTools) {
+      requestBody["tools"] = preparedTools;
+    }
+    const payload = {
+      model,
+      request: requestBody
+    };
+    if (projectId) {
+      payload["project"] = projectId;
+    }
+    return payload;
+  }
+  parseCompletionResponse(data) {
+    const responseData = data["response"] ?? data;
+    const candidates = responseData["candidates"] ?? [];
+    if (candidates.length === 0) {
+      return {
+        content: "",
+        reasoningContent: void 0,
+        toolCalls: void 0,
+        usage: void 0,
+        finishReason: void 0
+      };
+    }
+    const candidate = candidates[0];
+    const contentObj = candidate["content"] ?? {};
+    const parts = contentObj["parts"] ?? [];
+    let textContent = "";
+    let reasoningContent;
+    let toolCalls;
+    for (const part of parts) {
+      if (part["text"]) {
+        textContent += part["text"];
+      }
+      if (part["thought"]) {
+        reasoningContent = part["thought"];
+      }
+      if (part["functionCall"]) {
+        const fc = part["functionCall"];
+        if (!toolCalls) toolCalls = [];
+        toolCalls.push({
+          id: generateUUID(),
+          type: "function",
+          function: {
+            name: fc["name"] ?? "",
+            arguments: fc["args"] ?? fc["arguments"] ?? {}
+          }
+        });
+      }
+    }
+    const usageData = data["usageMetadata"] ?? responseData["usageMetadata"] ?? {};
+    let usage;
+    if (Object.keys(usageData).length > 0) {
+      usage = {
+        promptTokens: usageData["promptTokenCount"] ?? 0,
+        completionTokens: usageData["candidatesTokenCount"] ?? 0,
+        totalTokens: usageData["totalTokenCount"] ?? 0
+      };
+    }
+    return {
+      content: textContent,
+      reasoningContent,
+      toolCalls,
+      usage,
+      finishReason: candidate["finishReason"]
+    };
+  }
+  async complete(options) {
+    return this.completeWithRetry(options, 0);
+  }
+  async completeWithRetry(options, retryCount) {
+    const headers = await this.getAuthHeaders(retryCount > 0);
+    if (options.extraHeaders) {
+      Object.assign(headers, options.extraHeaders);
+    }
+    const accessToken = headers["Authorization"].replace("Bearer ", "");
+    const projectId = await this.ensureProjectId(accessToken);
+    const url = `${this.oauthManager.getApiEndpoint()}:generateContent`;
+    const payload = this.buildRequestPayload(
+      options.model,
+      options.messages,
+      options.generationConfig,
+      options.thinkingConfig,
+      options.tools,
+      projectId
+    );
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (RETRYABLE_STATUS_CODES.has(response.status) && retryCount === 0) {
+        this.oauthManager.invalidateCredentials();
+        return this.completeWithRetry(options, 1);
+      }
+      if (!response.ok) {
+        this.handleHttpError(response.status, await response.text());
+      }
+      const data = await response.json();
+      return this.parseCompletionResponse(data);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async *completeStreaming(options) {
+    yield* this.completeStreamingWithRetry(options, 0);
+  }
+  async *completeStreamingWithRetry(options, retryCount) {
+    const headers = await this.getAuthHeaders(retryCount > 0);
+    if (options.extraHeaders) {
+      Object.assign(headers, options.extraHeaders);
+    }
+    const accessToken = headers["Authorization"].replace("Bearer ", "");
+    const projectId = await this.ensureProjectId(accessToken);
+    const url = `${this.oauthManager.getApiEndpoint()}:streamGenerateContent?alt=sse`;
+    const payload = this.buildRequestPayload(
+      options.model,
+      options.messages,
+      options.generationConfig,
+      options.thinkingConfig,
+      options.tools,
+      projectId
+    );
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (RETRYABLE_STATUS_CODES.has(response.status) && retryCount === 0) {
+        this.oauthManager.invalidateCredentials();
+        yield* this.completeStreamingWithRetry(options, 1);
+        return;
+      }
+      if (!response.ok) {
+        this.handleHttpError(response.status, await response.text());
+      }
+      if (!response.body) {
+        throw new APIError("No response body", 500);
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith(":")) continue;
+          if (trimmed.startsWith("data:")) {
+            const data = trimmed.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed["error"]) {
+                const errorMsg = typeof parsed["error"] === "object" ? parsed["error"]["message"] : String(parsed["error"]);
+                throw new APIError(errorMsg, 500);
+              }
+              yield this.parseCompletionResponse(parsed);
+            } catch (e) {
+              if (e instanceof APIError) throw e;
+            }
+          }
+        }
+      }
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  handleHttpError(status, body) {
+    let errorMsg = body;
+    try {
+      const errorData = JSON.parse(body);
+      if (errorData["error"]) {
+        const err = errorData["error"];
+        errorMsg = err["message"] ?? body;
+      }
+    } catch {
+    }
+    if (status === 429) {
+      throw new RateLimitError(`Rate limit exceeded: ${errorMsg}`, 429, void 0, body);
+    } else if (status === 403) {
+      throw new PermissionDeniedError(`Permission denied: ${errorMsg}`, 403, body);
+    } else {
+      throw new APIError(`API error: ${errorMsg}`, status, body);
+    }
+  }
+  async listModels() {
+    const { GEMINI_CLI_MODELS: GEMINI_CLI_MODELS2 } = await import("./types-ADTG4FSI.mjs");
+    return Object.keys(GEMINI_CLI_MODELS2);
+  }
+  async close() {
+  }
+};
+
+// src/session.ts
+var GeminiSession = class {
+  _sessionId;
+  _model;
+  _backend;
+  _tools;
+  _toolHandlers;
+  _systemMessage;
+  _generationConfig;
+  _thinkingConfig;
+  _streaming;
+  _messages = [];
+  _eventHandlers = [];
+  _closed = false;
+  _startTime;
+  _modifiedTime;
+  constructor(options) {
+    this._sessionId = options.sessionId;
+    this._model = options.model;
+    this._backend = options.backend;
+    this._tools = options.tools ?? [];
+    this._systemMessage = options.systemMessage;
+    this._generationConfig = options.generationConfig;
+    this._thinkingConfig = options.thinkingConfig;
+    this._streaming = options.streaming ?? true;
+    this._startTime = /* @__PURE__ */ new Date();
+    this._modifiedTime = /* @__PURE__ */ new Date();
+    this._toolHandlers = /* @__PURE__ */ new Map();
+    for (const tool of this._tools) {
+      if (tool.handler) {
+        this._toolHandlers.set(tool.name, tool.handler);
+      }
+    }
+    if (this._systemMessage) {
+      this._messages.push({
+        role: "system" /* SYSTEM */,
+        content: this._systemMessage
+      });
+    }
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get model() {
+    return this._model;
+  }
+  get startTime() {
+    return this._startTime;
+  }
+  get modifiedTime() {
+    return this._modifiedTime;
+  }
+  get messages() {
+    return [...this._messages];
+  }
+  on(handler) {
+    this._eventHandlers.push(handler);
+    return () => {
+      const index = this._eventHandlers.indexOf(handler);
+      if (index > -1) {
+        this._eventHandlers.splice(index, 1);
+      }
+    };
+  }
+  emit(eventType, data) {
+    const event = {
+      type: eventType,
+      data,
+      sessionId: this._sessionId
+    };
+    for (const handler of this._eventHandlers) {
+      try {
+        handler(event);
+      } catch (e) {
+        console.warn("Event handler error:", e);
+      }
+    }
+  }
+  async send(options) {
+    if (this._closed) {
+      throw new SessionClosedError(this._sessionId);
+    }
+    const prompt = options.prompt;
+    const context = options.context;
+    let content = prompt;
+    if (context) {
+      content = `${context}
+
+${prompt}`;
+    }
+    const userMessage = {
+      role: "user" /* USER */,
+      content
+    };
+    this._messages.push(userMessage);
+    this._modifiedTime = /* @__PURE__ */ new Date();
+    try {
+      if (this._streaming) {
+        await this.streamResponse();
+      } else {
+        await this.getResponse();
+      }
+    } catch (e) {
+      this.emit("session.error" /* SESSION_ERROR */, { error: String(e) });
+      throw e;
+    }
+  }
+  async sendAndWait(options) {
+    return new Promise((resolve, reject) => {
+      let responseEvent = null;
+      const unsubscribe = this.on((event) => {
+        if (event.type === "assistant.message" /* ASSISTANT_MESSAGE */) {
+          responseEvent = event;
+        } else if (event.type === "session.idle" /* SESSION_IDLE */ || event.type === "session.error" /* SESSION_ERROR */) {
+          unsubscribe();
+          if (responseEvent) {
+            resolve(responseEvent);
+          } else if (event.type === "session.error" /* SESSION_ERROR */) {
+            reject(new Error(String(event.data?.["error"])));
+          } else {
+            reject(new Error("No response received"));
+          }
+        }
+      });
+      this.send(options).catch((e) => {
+        unsubscribe();
+        reject(e);
+      });
+    });
+  }
+  async streamResponse() {
+    let fullContent = "";
+    let fullReasoning = "";
+    const allToolCalls = [];
+    let finalUsage;
+    for await (const chunk of this._backend.completeStreaming({
+      model: this._model,
+      messages: this._messages,
+      generationConfig: this._generationConfig,
+      thinkingConfig: this._thinkingConfig,
+      tools: this._tools.length > 0 ? this._tools : void 0
+    })) {
+      if (chunk.content) {
+        fullContent += chunk.content;
+        this.emit("assistant.message_delta" /* ASSISTANT_MESSAGE_DELTA */, {
+          deltaContent: chunk.content,
+          content: fullContent
+        });
+      }
+      if (chunk.reasoningContent) {
+        fullReasoning += chunk.reasoningContent;
+        this.emit("assistant.reasoning_delta" /* ASSISTANT_REASONING_DELTA */, {
+          deltaContent: chunk.reasoningContent,
+          content: fullReasoning
+        });
+      }
+      if (chunk.toolCalls) {
+        allToolCalls.push(...chunk.toolCalls);
+      }
+      if (chunk.usage) {
+        finalUsage = chunk.usage;
+      }
+    }
+    if (allToolCalls.length > 0) {
+      await this.handleToolCalls(allToolCalls);
+    }
+    const assistantMessage = {
+      role: "assistant" /* ASSISTANT */,
+      content: fullContent,
+      toolCalls: allToolCalls.length > 0 ? allToolCalls : void 0
+    };
+    this._messages.push(assistantMessage);
+    if (fullReasoning) {
+      this.emit("assistant.reasoning" /* ASSISTANT_REASONING */, {
+        content: fullReasoning
+      });
+    }
+    this.emit("assistant.message" /* ASSISTANT_MESSAGE */, {
+      content: fullContent,
+      toolCalls: allToolCalls.length > 0 ? allToolCalls : void 0,
+      usage: finalUsage
+    });
+    this.emit("session.idle" /* SESSION_IDLE */, {});
+  }
+  async getResponse() {
+    const chunk = await this._backend.complete({
+      model: this._model,
+      messages: this._messages,
+      generationConfig: this._generationConfig,
+      thinkingConfig: this._thinkingConfig,
+      tools: this._tools.length > 0 ? this._tools : void 0
+    });
+    if (chunk.toolCalls) {
+      await this.handleToolCalls(chunk.toolCalls);
+    }
+    const assistantMessage = {
+      role: "assistant" /* ASSISTANT */,
+      content: chunk.content,
+      toolCalls: chunk.toolCalls
+    };
+    this._messages.push(assistantMessage);
+    if (chunk.reasoningContent) {
+      this.emit("assistant.reasoning" /* ASSISTANT_REASONING */, {
+        content: chunk.reasoningContent
+      });
+    }
+    this.emit("assistant.message" /* ASSISTANT_MESSAGE */, {
+      content: chunk.content,
+      toolCalls: chunk.toolCalls,
+      usage: chunk.usage
+    });
+    this.emit("session.idle" /* SESSION_IDLE */, {});
+  }
+  async handleToolCalls(toolCalls) {
+    for (const toolCall of toolCalls) {
+      const toolName = toolCall.function.name;
+      this.emit("tool.call" /* TOOL_CALL */, {
+        name: toolName,
+        arguments: toolCall.function.arguments,
+        callId: toolCall.id
+      });
+      const handler = this._toolHandlers.get(toolName);
+      if (!handler) {
+        console.warn(`No handler for tool: ${toolName}`);
+        this._messages.push({
+          role: "user" /* USER */,
+          content: `Error: Tool '${toolName}' not found`,
+          toolCallId: toolCall.id,
+          name: toolName
+        });
+        continue;
+      }
+      try {
+        const invocation = {
+          name: toolName,
+          arguments: typeof toolCall.function.arguments === "object" ? toolCall.function.arguments : {},
+          callId: toolCall.id
+        };
+        const result = await Promise.resolve(handler(invocation));
+        const resultText = result.textResultForLlm ?? JSON.stringify(result);
+        this.emit("tool.result" /* TOOL_RESULT */, {
+          name: toolName,
+          callId: toolCall.id,
+          result: resultText
+        });
+        this._messages.push({
+          role: "user" /* USER */,
+          content: resultText,
+          toolCallId: toolCall.id,
+          name: toolName
+        });
+      } catch (e) {
+        const errorMsg = `Error executing tool '${toolName}': ${e}`;
+        console.error(errorMsg);
+        this.emit("tool.result" /* TOOL_RESULT */, {
+          name: toolName,
+          callId: toolCall.id,
+          error: String(e)
+        });
+        this._messages.push({
+          role: "user" /* USER */,
+          content: errorMsg,
+          toolCallId: toolCall.id,
+          name: toolName
+        });
+      }
+    }
+  }
+  getMessages() {
+    return [...this._messages];
+  }
+  addTool(tool) {
+    this._tools.push(tool);
+    if (tool.handler) {
+      this._toolHandlers.set(tool.name, tool.handler);
+    }
+  }
+  removeTool(toolName) {
+    this._tools = this._tools.filter((t) => t.name !== toolName);
+    this._toolHandlers.delete(toolName);
+  }
+  async clearHistory() {
+    if (this._systemMessage) {
+      this._messages = [{ role: "system" /* SYSTEM */, content: this._systemMessage }];
+    } else {
+      this._messages = [];
+    }
+    this._modifiedTime = /* @__PURE__ */ new Date();
+  }
+  async destroy() {
+    this._closed = true;
+    this._eventHandlers.length = 0;
+    this._toolHandlers.clear();
+    this._messages = [];
+  }
+};
+
+// src/client.ts
+function generateUUID2() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var GeminiClient = class {
+  _options;
+  _state = "disconnected";
+  _backend = null;
+  _oauthManager = null;
+  _sessions = /* @__PURE__ */ new Map();
+  _started = false;
+  _autoRefreshInterval = null;
+  constructor(options = {}) {
+    this._options = options;
+  }
+  get options() {
+    return this._options;
+  }
+  get state() {
+    return this._state;
+  }
+  async start() {
+    if (this._started) return;
+    this._state = "connecting";
+    try {
+      this._oauthManager = new GeminiOAuthManager(
+        this._options.oauthPath,
+        this._options.clientId,
+        this._options.clientSecret
+      );
+      this._backend = new GeminiBackend({
+        timeout: this._options.timeout ?? 72e4,
+        oauthPath: this._options.oauthPath,
+        clientId: this._options.clientId,
+        clientSecret: this._options.clientSecret
+      });
+      await this._oauthManager.ensureAuthenticated();
+      this._state = "connected";
+      this._started = true;
+      if (this._options.autoRefresh !== false) {
+        this.startAutoRefresh();
+      }
+    } catch (e) {
+      this._state = "error";
+      throw e;
+    }
+  }
+  startAutoRefresh() {
+    if (this._autoRefreshInterval) return;
+    this._autoRefreshInterval = setInterval(async () => {
+      try {
+        if (this._oauthManager) {
+          await this._oauthManager.ensureAuthenticated();
+        }
+      } catch (e) {
+      }
+    }, 3e4);
+  }
+  async stop() {
+    if (this._autoRefreshInterval) {
+      clearInterval(this._autoRefreshInterval);
+      this._autoRefreshInterval = null;
+    }
+    for (const session of this._sessions.values()) {
+      try {
+        await session.destroy();
+      } catch (e) {
+        console.warn("Error destroying session:", e);
+      }
+    }
+    this._sessions.clear();
+    if (this._backend) {
+      await this._backend.close();
+      this._backend = null;
+    }
+    this._oauthManager = null;
+    this._state = "disconnected";
+    this._started = false;
+  }
+  async close() {
+    await this.stop();
+  }
+  async createSession(config = {}) {
+    if (!this._started) {
+      await this.start();
+    }
+    if (!this._backend) {
+      throw new Error("Client not connected. Call start() first.");
+    }
+    const sessionId = config.sessionId ?? generateUUID2();
+    const model = config.model ?? "gemini-2.5-pro";
+    const session = new GeminiSession({
+      sessionId,
+      model,
+      backend: this._backend,
+      tools: config.tools,
+      systemMessage: config.systemMessage,
+      generationConfig: config.generationConfig,
+      thinkingConfig: config.thinkingConfig,
+      streaming: config.streaming ?? true
+    });
+    this._sessions.set(sessionId, session);
+    return session;
+  }
+  async getSession(sessionId) {
+    const session = this._sessions.get(sessionId);
+    if (!session) {
+      throw new SessionNotFoundError(sessionId);
+    }
+    return session;
+  }
+  async listSessions() {
+    const result = [];
+    for (const session of this._sessions.values()) {
+      result.push({
+        sessionId: session.sessionId,
+        startTime: session.startTime.toISOString(),
+        modifiedTime: session.modifiedTime.toISOString(),
+        model: session.model
+      });
+    }
+    return result;
+  }
+  async deleteSession(sessionId) {
+    const session = this._sessions.get(sessionId);
+    if (session) {
+      await session.destroy();
+      this._sessions.delete(sessionId);
+    }
+  }
+  getState() {
+    return this._state;
+  }
+  async getAuthStatus() {
+    if (!this._oauthManager) {
+      return { authenticated: false };
+    }
+    try {
+      const credentials = await this._oauthManager.getCredentials();
+      return {
+        authenticated: true,
+        tokenType: credentials.tokenType,
+        expiresAt: credentials.expiryDate
+      };
+    } catch {
+      return { authenticated: false };
+    }
+  }
+  async listModels() {
+    const models = [];
+    for (const [modelId, info] of Object.entries(GEMINI_CLI_MODELS)) {
+      models.push({
+        id: modelId,
+        name: info.name,
+        capabilities: {
+          supports: {
+            vision: false,
+            tools: info.supportsNativeTools,
+            thinking: info.supportsThinking
+          },
+          limits: {
+            maxContextWindowTokens: info.contextWindow,
+            maxPromptTokens: info.contextWindow
+          }
+        }
+      });
+    }
+    return models;
+  }
+  async refreshAuth() {
+    if (this._oauthManager) {
+      await this._oauthManager.ensureAuthenticated(true);
+    }
+  }
+};
+
+// src/tools.ts
+function defineTool(options, handler) {
+  const toolName = options.name ?? handler.name ?? "unnamed_tool";
+  const description = options.description ?? `Tool: ${toolName}`;
+  const parameters = options.parameters ?? { type: "object", properties: {} };
+  const wrappedHandler = async (invocation) => {
+    const result = await Promise.resolve(handler(invocation.arguments));
+    if (typeof result === "object" && result !== null && "textResultForLlm" in result) {
+      return result;
+    }
+    return { textResultForLlm: String(result) };
+  };
+  return {
+    name: toolName,
+    description,
+    parameters,
+    handler: wrappedHandler
+  };
+}
+function createTool(name, description, parameters, handler) {
+  return {
+    name,
+    description,
+    parameters: parameters ?? { type: "object", properties: {} },
+    handler
+  };
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  categories = /* @__PURE__ */ new Map();
+  register(tool, category) {
+    this.tools.set(tool.name, tool);
+    if (category) {
+      if (!this.categories.has(category)) {
+        this.categories.set(category, /* @__PURE__ */ new Set());
+      }
+      this.categories.get(category).add(tool.name);
+    }
+  }
+  unregister(name) {
+    this.tools.delete(name);
+    for (const categoryTools of this.categories.values()) {
+      categoryTools.delete(name);
+    }
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  getByCategory(category) {
+    const toolNames = this.categories.get(category);
+    if (!toolNames) return [];
+    return Array.from(toolNames).map((name) => this.tools.get(name)).filter((tool) => tool !== void 0);
+  }
+  listCategories() {
+    return Array.from(this.categories.keys());
+  }
+};
+var defaultRegistry = new ToolRegistry();
+function getDefaultRegistry() {
+  return defaultRegistry;
+}
+function registerTool(tool, category) {
+  defaultRegistry.register(tool, category);
+}
+
+// src/index.ts
+var VERSION = "0.1.1";
+export {
+  APIError,
+  AuthenticationError,
+  CancellationError,
+  ConfigurationError,
+  ConnectionError,
+  CredentialsNotFoundError,
+  EventType,
+  GEMINI_CLI_MODELS,
+  GEMINI_CODE_ASSIST_API_VERSION,
+  GEMINI_CODE_ASSIST_ENDPOINT,
+  GEMINI_CREDENTIAL_FILENAME,
+  GEMINI_DIR,
+  GEMINI_ENV_FILENAME,
+  GEMINI_OAUTH_AUTH_ENDPOINT,
+  GEMINI_OAUTH_BASE_URL,
+  GEMINI_OAUTH_CLIENT_ID,
+  GEMINI_OAUTH_CLIENT_SECRET,
+  GEMINI_OAUTH_REDIRECT_URI,
+  GEMINI_OAUTH_SCOPES,
+  GEMINI_OAUTH_TOKEN_ENDPOINT,
+  GeminiBackend,
+  GeminiClient,
+  GeminiOAuthManager,
+  GeminiSDKError,
+  GeminiSession,
+  HTTP_FORBIDDEN,
+  HTTP_OK,
+  HTTP_UNAUTHORIZED,
+  NotFoundError,
+  OnboardingError,
+  PermissionDeniedError,
+  QuotaExceededError,
+  RateLimitError,
+  Role,
+  SessionClosedError,
+  SessionError,
+  SessionNotFoundError,
+  StreamError,
+  TOKEN_REFRESH_BUFFER_MS,
+  TimeoutError,
+  TokenExpiredError,
+  TokenRefreshError,
+  ToolError,
+  ToolExecutionError,
+  ToolNotFoundError,
+  ToolRegistry,
+  VERSION,
+  ValidationError,
+  createTool,
+  defineTool,
+  getDefaultRegistry,
+  getGeminiCliCredentialPath,
+  getGeminiCliEnvPath,
+  registerTool
+};