privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-NREXJV3M.mjs

@@ -0,0 +1,393 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  GoogleGenAI,
+  convertMessages,
+  convertTools,
+  getDisabledGoogleThinkingConfig,
+  isThinkingPart,
+  mapStopReason,
+  resolveGoogleFunctionCallingMode,
+  resolveGoogleThinkingLevel,
+  retainThoughtSignature,
+  retryGoogleRequest,
+  supportsGoogleStrictToolSampling,
+  toGoogleSdkThinkingLevel,
+  toGoogleThinkingLevel,
+  usesGoogleThinkingLevel
+} from "./c-DOSGVXDZ.mjs";
+import {
+  formatProviderError,
+  normalizeProviderError
+} from "./c-ZWUVHKMK.mjs";
+import {
+  buildBaseOptions,
+  getPiUserAgent
+} from "./c-C6S2YB53.mjs";
+import {
+  sanitizeSurrogates
+} from "./c-5GV3X3RB.mjs";
+import "./c-EYZGSAJU.mjs";
+import {
+  providerHeadersToRecord
+} from "./c-ZJYLGIC3.mjs";
+import "./c-CU4NGAUO.mjs";
+import {
+  calculateCost,
+  clampThinkingLevel,
+  collapseSystemMessages,
+  getCurrentTools,
+  getInitialSystemMessage,
+  getSystemMessageText
+} from "./c-WO3QSZUU.mjs";
+import {
+  AssistantMessageEventStream
+} from "./c-S2RVHR3M.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/google-generative-ai.js
+var toolCallCounter = 0;
+var stream = /* @__PURE__ */ __name((model, context, options) => {
+  const stream2 = new AssistantMessageEventStream();
+  const normalizedContext = collapseSystemMessages(context);
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: "google-generative-ai",
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    try {
+      if (options?.fetch && options.fetch !== globalThis.fetch) {
+        throw new Error("Custom fetch is not supported by the Google Generative AI adapter");
+      }
+      const apiKey = options?.apiKey;
+      if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+      }
+      const client = createClient(model, apiKey, options?.headers);
+      let params = buildParams(model, normalizedContext, options);
+      const nextParams = await options?.onPayload?.(params, model);
+      if (nextParams !== void 0) {
+        params = nextParams;
+      }
+      const googleStream = await retryGoogleRequest(() => client.models.generateContentStream(params), options);
+      stream2.push({ type: "start", partial: output });
+      let currentBlock = null;
+      const blocks = output.content;
+      const blockIndex = /* @__PURE__ */ __name(() => blocks.length - 1, "blockIndex");
+      for await (const chunk of googleStream) {
+        await options?.onProviderStreamEvent?.(chunk, model);
+        output.responseId ||= chunk.responseId;
+        const candidate = chunk.candidates?.[0];
+        if (candidate?.content?.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.text !== void 0) {
+              const isThinking = isThinkingPart(part);
+              if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
+                if (currentBlock) {
+                  if (currentBlock.type === "text") {
+                    stream2.push({
+                      type: "text_end",
+                      contentIndex: blocks.length - 1,
+                      content: currentBlock.text,
+                      partial: output
+                    });
+                  } else {
+                    stream2.push({
+                      type: "thinking_end",
+                      contentIndex: blockIndex(),
+                      content: currentBlock.thinking,
+                      partial: output
+                    });
+                  }
+                }
+                if (isThinking) {
+                  currentBlock = { type: "thinking", thinking: "", thinkingSignature: void 0 };
+                  output.content.push(currentBlock);
+                  stream2.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+                } else {
+                  currentBlock = { type: "text", text: "" };
+                  output.content.push(currentBlock);
+                  stream2.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+                }
+              }
+              if (currentBlock.type === "thinking") {
+                currentBlock.thinking += part.text;
+                currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
+                stream2.push({
+                  type: "thinking_delta",
+                  contentIndex: blockIndex(),
+                  delta: part.text,
+                  partial: output
+                });
+              } else {
+                currentBlock.text += part.text;
+                currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
+                stream2.push({
+                  type: "text_delta",
+                  contentIndex: blockIndex(),
+                  delta: part.text,
+                  partial: output
+                });
+              }
+            }
+            if (part.functionCall) {
+              if (currentBlock) {
+                if (currentBlock.type === "text") {
+                  stream2.push({
+                    type: "text_end",
+                    contentIndex: blockIndex(),
+                    content: currentBlock.text,
+                    partial: output
+                  });
+                } else {
+                  stream2.push({
+                    type: "thinking_end",
+                    contentIndex: blockIndex(),
+                    content: currentBlock.thinking,
+                    partial: output
+                  });
+                }
+                currentBlock = null;
+              }
+              const providedId = part.functionCall.id;
+              const needsNewId = !providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
+              const toolCallId = needsNewId ? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}` : providedId;
+              const toolCall = {
+                type: "toolCall",
+                id: toolCallId,
+                name: part.functionCall.name || "",
+                arguments: part.functionCall.args ?? {},
+                ...part.thoughtSignature && { thoughtSignature: part.thoughtSignature }
+              };
+              output.content.push(toolCall);
+              stream2.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+              stream2.push({
+                type: "toolcall_delta",
+                contentIndex: blockIndex(),
+                delta: JSON.stringify(toolCall.arguments),
+                partial: output
+              });
+              stream2.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+            }
+          }
+        }
+        if (candidate?.finishReason) {
+          output.rawStopReason = candidate.finishReason;
+          output.stopReason = mapStopReason(candidate.finishReason);
+          if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+            output.stopReason = "toolUse";
+          }
+        }
+        if (chunk.usageMetadata) {
+          output.usage = {
+            input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
+            output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+            cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
+            cacheWrite: 0,
+            reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+            totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+            cost: {
+              input: 0,
+              output: 0,
+              cacheRead: 0,
+              cacheWrite: 0,
+              total: 0
+            }
+          };
+          calculateCost(model, output.usage);
+        }
+      }
+      if (currentBlock) {
+        if (currentBlock.type === "text") {
+          stream2.push({
+            type: "text_end",
+            contentIndex: blockIndex(),
+            content: currentBlock.text,
+            partial: output
+          });
+        } else {
+          stream2.push({
+            type: "thinking_end",
+            contentIndex: blockIndex(),
+            content: currentBlock.thinking,
+            partial: output
+          });
+        }
+      }
+      if (options?.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (output.stopReason === "pending") {
+        throw new Error("Google stream ended without a finish reason");
+      }
+      if (output.stopReason === "aborted" || output.stopReason === "error") {
+        const errorMessage = output.rawStopReason ? `Provider stopped with: ${output.rawStopReason}` : "An unknown error occurred";
+        throw new Error(errorMessage);
+      }
+      stream2.push({ type: "done", reason: output.stopReason, message: output });
+      stream2.end();
+    } catch (error) {
+      for (const block of output.content) {
+        if ("index" in block) {
+          delete block.index;
+        }
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatProviderError(normalizeProviderError(error));
+      stream2.push({ type: "error", reason: output.stopReason, error: output });
+      stream2.end();
+    }
+  })();
+  return stream2;
+}, "stream");
+var streamSimple = /* @__PURE__ */ __name((model, context, options) => {
+  const apiKey = options?.apiKey;
+  if (!apiKey) {
+    throw new Error(`No API key for provider: ${model.provider}`);
+  }
+  const base = {
+    ...buildBaseOptions(model, context, options, apiKey),
+    toolChoice: options?.toolChoice
+  };
+  if (!options?.reasoning) {
+    return stream(model, context, { ...base, thinking: { enabled: false } });
+  }
+  const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+  if (clampedReasoning === "off") {
+    return stream(model, context, { ...base, thinking: { enabled: false } });
+  }
+  const resolvedLevel = resolveGoogleThinkingLevel(model, clampedReasoning);
+  if (usesGoogleThinkingLevel(model)) {
+    return stream(model, context, {
+      ...base,
+      thinking: {
+        enabled: true,
+        level: toGoogleThinkingLevel(resolvedLevel)
+      }
+    });
+  }
+  return stream(model, context, {
+    ...base,
+    thinking: {
+      enabled: true,
+      budgetTokens: getGoogleBudget(model, resolvedLevel, options.thinkingBudgets)
+    }
+  });
+}, "streamSimple");
+function createClient(model, apiKey, optionsHeaders) {
+  const httpOptions = {};
+  if (model.baseUrl) {
+    httpOptions.baseUrl = model.baseUrl;
+    httpOptions.apiVersion = "";
+  }
+  const headers = providerHeadersToRecord({ "User-Agent": getPiUserAgent(), ...model.headers, ...optionsHeaders });
+  if (headers) {
+    httpOptions.headers = headers;
+  }
+  return new GoogleGenAI({
+    apiKey,
+    httpOptions: Object.keys(httpOptions).length > 0 ? httpOptions : void 0
+  });
+}
+__name(createClient, "createClient");
+function buildParams(model, context, options = {}) {
+  const contents = convertMessages(model, context);
+  const initialSystemMessage = getInitialSystemMessage(context.messages);
+  const currentTools = getCurrentTools(context.messages);
+  const generationConfig = {};
+  if (options.temperature !== void 0) {
+    generationConfig.temperature = options.temperature;
+  }
+  if (options.maxTokens !== void 0) {
+    generationConfig.maxOutputTokens = options.maxTokens;
+  }
+  const supportsStrictMode = supportsGoogleStrictToolSampling(model.id);
+  const functionCallingMode = currentTools.length > 0 ? resolveGoogleFunctionCallingMode(currentTools, options.toolChoice, supportsStrictMode) : void 0;
+  const systemInstruction = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";
+  const config = {
+    ...Object.keys(generationConfig).length > 0 && generationConfig,
+    ...systemInstruction && { systemInstruction: sanitizeSurrogates(systemInstruction) },
+    ...currentTools.length > 0 && {
+      tools: convertTools(currentTools, false, supportsStrictMode)
+    },
+    ...functionCallingMode !== void 0 && {
+      toolConfig: { functionCallingConfig: { mode: functionCallingMode } }
+    }
+  };
+  if (options.thinking?.enabled && model.reasoning) {
+    const thinkingConfig = { includeThoughts: true };
+    if (options.thinking.level !== void 0) {
+      thinkingConfig.thinkingLevel = toGoogleSdkThinkingLevel(options.thinking.level);
+    } else if (options.thinking.budgetTokens !== void 0) {
+      thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+    }
+    config.thinkingConfig = thinkingConfig;
+  } else if (model.reasoning && options.thinking && !options.thinking.enabled) {
+    config.thinkingConfig = getDisabledGoogleThinkingConfig(model);
+  }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    config.abortSignal = options.signal;
+  }
+  const params = {
+    model: model.id,
+    contents,
+    config
+  };
+  return params;
+}
+__name(buildParams, "buildParams");
+function getGoogleBudget(model, level, customBudgets) {
+  if (customBudgets?.[level] !== void 0) {
+    return customBudgets[level];
+  }
+  if (model.id.includes("2.5-pro")) {
+    const budgets = {
+      minimal: 128,
+      low: 2048,
+      medium: 8192,
+      high: 32768
+    };
+    return budgets[level];
+  }
+  if (model.id.includes("2.5-flash-lite")) {
+    const budgets = {
+      minimal: 512,
+      low: 2048,
+      medium: 8192,
+      high: 24576
+    };
+    return budgets[level];
+  }
+  if (model.id.includes("2.5-flash")) {
+    const budgets = {
+      minimal: 128,
+      low: 2048,
+      medium: 8192,
+      high: 24576
+    };
+    return budgets[level];
+  }
+  return -1;
+}
+__name(getGoogleBudget, "getGoogleBudget");
+export {
+  stream,
+  streamSimple
+};

package/dist-boot/c-O5PP6CTX.mjs

@@ -0,0 +1,162 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  getProviderEnvValue
+} from "./c-CDBEJSBF.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/env-api-keys.js
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+  if (typeof path === "string" && /^\.\.?\//.test(path)) {
+    return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
+};
+var _existsSync = null;
+var _homedir = null;
+var _join = null;
+var dynamicImport = /* @__PURE__ */ __name((specifier) => import(__rewriteRelativeImportExtension(specifier)), "dynamicImport");
+var NODE_FS_SPECIFIER = "node:fs";
+var NODE_OS_SPECIFIER = "node:os";
+var NODE_PATH_SPECIFIER = "node:path";
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+  dynamicImport(NODE_FS_SPECIFIER).then((m) => {
+    _existsSync = m.existsSync;
+  });
+  dynamicImport(NODE_OS_SPECIFIER).then((m) => {
+    _homedir = m.homedir;
+  });
+  dynamicImport(NODE_PATH_SPECIFIER).then((m) => {
+    _join = m.join;
+  });
+}
+var ANTHROPIC_AUTH_TOKEN_ENV = "ANTHROPIC_AUTH_TOKEN";
+var ANTHROPIC_OAUTH_TOKEN_ENV = "ANTHROPIC_OAUTH_TOKEN";
+var ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY";
+var ANTHROPIC_FEDERATION_RULE_ID_ENV = "ANTHROPIC_FEDERATION_RULE_ID";
+var ANTHROPIC_ORGANIZATION_ID_ENV = "ANTHROPIC_ORGANIZATION_ID";
+var ANTHROPIC_SERVICE_ACCOUNT_ID_ENV = "ANTHROPIC_SERVICE_ACCOUNT_ID";
+var ANTHROPIC_IDENTITY_TOKEN_FILE_ENV = "ANTHROPIC_IDENTITY_TOKEN_FILE";
+var ANTHROPIC_WORKSPACE_ID_ENV = "ANTHROPIC_WORKSPACE_ID";
+var cachedVertexAdcCredentialsExists = null;
+function hasVertexAdcCredentials(env) {
+  const explicitCredentialsPath = env?.GOOGLE_APPLICATION_CREDENTIALS;
+  if (explicitCredentialsPath) {
+    return _existsSync ? _existsSync(explicitCredentialsPath) : false;
+  }
+  if (cachedVertexAdcCredentialsExists === null) {
+    if (!_existsSync || !_homedir || !_join) {
+      const isNode = typeof process !== "undefined" && (process.versions?.node || process.versions?.bun);
+      if (!isNode) {
+        cachedVertexAdcCredentialsExists = false;
+      }
+      return false;
+    }
+    const gacPath = getProviderEnvValue("GOOGLE_APPLICATION_CREDENTIALS", env);
+    if (gacPath) {
+      cachedVertexAdcCredentialsExists = _existsSync(gacPath);
+    } else {
+      cachedVertexAdcCredentialsExists = _existsSync(_join(_homedir(), ".config", "gcloud", "application_default_credentials.json"));
+    }
+  }
+  return cachedVertexAdcCredentialsExists;
+}
+__name(hasVertexAdcCredentials, "hasVertexAdcCredentials");
+function getApiKeyEnvVars(provider) {
+  if (provider === "github-copilot") {
+    return ["COPILOT_GITHUB_TOKEN"];
+  }
+  if (provider === "anthropic") {
+    return [ANTHROPIC_AUTH_TOKEN_ENV, ANTHROPIC_OAUTH_TOKEN_ENV, ANTHROPIC_API_KEY_ENV];
+  }
+  const envMap = {
+    "ant-ling": "ANT_LING_API_KEY",
+    "qwen-token-plan": "QWEN_TOKEN_PLAN_API_KEY",
+    "qwen-token-plan-cn": "QWEN_TOKEN_PLAN_CN_API_KEY",
+    "qwen-token-plan-individual": "QWEN_TOKEN_PLAN_API_KEY",
+    openai: "OPENAI_API_KEY",
+    azure: "AZURE_OPENAI_API_KEY",
+    nvidia: "NVIDIA_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    google: "GEMINI_API_KEY",
+    "google-vertex": "GOOGLE_CLOUD_API_KEY",
+    groq: "GROQ_API_KEY",
+    cerebras: "CEREBRAS_API_KEY",
+    xai: "XAI_API_KEY",
+    typesafe: "TYPESAFE_API_KEY",
+    radius: "RADIUS_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+    "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+    zai: "ZAI_API_KEY",
+    "zai-coding-cn": "ZAI_CODING_CN_API_KEY",
+    mistral: "MISTRAL_API_KEY",
+    minimax: "MINIMAX_API_KEY",
+    "minimax-cn": "MINIMAX_CN_API_KEY",
+    moonshotai: "MOONSHOT_API_KEY",
+    "moonshotai-cn": "MOONSHOT_API_KEY",
+    huggingface: "HF_TOKEN",
+    fireworks: "FIREWORKS_API_KEY",
+    together: "TOGETHER_API_KEY",
+    baseten: "BASETEN_API_KEY",
+    opencode: "OPENCODE_API_KEY",
+    "opencode-go": "OPENCODE_API_KEY",
+    "kimi-coding": "KIMI_API_KEY",
+    meta: "META_API_KEY",
+    "cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
+    "cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
+    xiaomi: "XIAOMI_API_KEY",
+    "xiaomi-token-plan-cn": "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+    "xiaomi-token-plan-ams": "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+    "xiaomi-token-plan-sgp": "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+  };
+  const envVar = envMap[provider];
+  return envVar ? [envVar] : void 0;
+}
+__name(getApiKeyEnvVars, "getApiKeyEnvVars");
+function findEnvKeys(provider, env) {
+  const envVars = getApiKeyEnvVars(provider);
+  if (!envVars)
+    return void 0;
+  const found = envVars.filter((envVar) => !!getProviderEnvValue(envVar, env));
+  return found.length > 0 ? found : void 0;
+}
+__name(findEnvKeys, "findEnvKeys");
+function getEnvApiKey(provider, env) {
+  const envKeys = findEnvKeys(provider, env);
+  if (envKeys?.[0]) {
+    const apiKeyEnv = provider === "anthropic" ? envKeys.find((key) => key !== ANTHROPIC_AUTH_TOKEN_ENV) : envKeys[0];
+    if (apiKeyEnv)
+      return getProviderEnvValue(apiKeyEnv, env);
+  }
+  if (provider === "google-vertex") {
+    const hasCredentials = hasVertexAdcCredentials(env);
+    const hasProject = !!(getProviderEnvValue("GOOGLE_CLOUD_PROJECT", env) || getProviderEnvValue("GCLOUD_PROJECT", env));
+    const hasLocation = !!getProviderEnvValue("GOOGLE_CLOUD_LOCATION", env);
+    if (hasCredentials && hasProject && hasLocation) {
+      return "<authenticated>";
+    }
+  }
+  if (provider === "amazon-bedrock") {
+    if (getProviderEnvValue("AWS_PROFILE", env) || getProviderEnvValue("AWS_ACCESS_KEY_ID", env) && getProviderEnvValue("AWS_SECRET_ACCESS_KEY", env) || getProviderEnvValue("AWS_BEARER_TOKEN_BEDROCK", env) || getProviderEnvValue("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", env) || getProviderEnvValue("AWS_CONTAINER_CREDENTIALS_FULL_URI", env) || getProviderEnvValue("AWS_WEB_IDENTITY_TOKEN_FILE", env)) {
+      return "<authenticated>";
+    }
+  }
+  return void 0;
+}
+__name(getEnvApiKey, "getEnvApiKey");
+
+export {
+  ANTHROPIC_AUTH_TOKEN_ENV,
+  ANTHROPIC_OAUTH_TOKEN_ENV,
+  ANTHROPIC_API_KEY_ENV,
+  ANTHROPIC_FEDERATION_RULE_ID_ENV,
+  ANTHROPIC_ORGANIZATION_ID_ENV,
+  ANTHROPIC_SERVICE_ACCOUNT_ID_ENV,
+  ANTHROPIC_IDENTITY_TOKEN_FILE_ENV,
+  ANTHROPIC_WORKSPACE_ID_ENV,
+  findEnvKeys,
+  getEnvApiKey
+};