@providerprotocol/ai 0.0.20 → 0.0.22

package/dist/google/index.js

@@ -1,43 +1,46 @@
-import {
-  createProvider
-} from "../chunk-MSR5P65T.js";
 import {
   Image
 } from "../chunk-WAKD3OO5.js";
+import {
+  parseJsonResponse
+} from "../chunk-I2VHCGQE.js";
 import {
   AssistantMessage,
+  createProvider,
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "../chunk-UMKWXGO3.js";
+} from "../chunk-M4BMM5IB.js";
 import {
   parseSSEStream
-} from "../chunk-Z7RBRCRN.js";
+} from "../chunk-NWS5IKNR.js";
 import {
   resolveApiKey
-} from "../chunk-P5IRTEM5.js";
+} from "../chunk-7WYBJPJJ.js";
 import {
   UPPError,
   doFetch,
   doStreamFetch,
-  normalizeHttpError
-} from "../chunk-U3FZWV4U.js";
+  normalizeHttpError,
+  toError
+} from "../chunk-RFWLEFAB.js";
 
 // src/providers/google/transform.ts
 function transformRequest(request, modelId) {
   const params = request.params ?? {};
-  const { cachedContent, builtInTools, toolConfig, ...generationParams } = params;
+  const { cachedContent, tools: builtInTools, toolConfig, ...generationParams } = params;
   const googleRequest = {
     contents: transformMessages(request.messages)
   };
-  if (request.system) {
-    if (typeof request.system === "string") {
+  const normalizedSystem = normalizeSystem(request.system);
+  if (normalizedSystem !== void 0) {
+    if (typeof normalizedSystem === "string") {
       googleRequest.systemInstruction = {
-        parts: [{ text: request.system }]
+        parts: [{ text: normalizedSystem }]
       };
-    } else {
+    } else if (normalizedSystem.length > 0) {
       googleRequest.systemInstruction = {
-        parts: request.system
+        parts: normalizedSystem
       };
     }
   }
@@ -51,17 +54,17 @@ function transformRequest(request, modelId) {
   if (Object.keys(generationConfig).length > 0) {
     googleRequest.generationConfig = generationConfig;
   }
-  const tools2 = [];
+  const requestTools = [];
   if (request.tools && request.tools.length > 0) {
-    tools2.push({
+    requestTools.push({
       functionDeclarations: request.tools.map(transformTool)
     });
   }
   if (builtInTools && builtInTools.length > 0) {
-    tools2.push(...builtInTools);
+    requestTools.push(...builtInTools);
   }
-  if (tools2.length > 0) {
-    googleRequest.tools = tools2;
+  if (requestTools.length > 0) {
+    googleRequest.tools = requestTools;
   }
   if (toolConfig) {
     googleRequest.toolConfig = toolConfig;
@@ -71,6 +74,56 @@ function transformRequest(request, modelId) {
   }
   return googleRequest;
 }
+function normalizeSystem(system) {
+  if (system === void 0 || system === null) return void 0;
+  if (typeof system === "string") return system;
+  if (!Array.isArray(system)) {
+    throw new UPPError(
+      "System prompt must be a string or an array of text parts",
+      "INVALID_REQUEST",
+      "google",
+      "llm"
+    );
+  }
+  const parts = [];
+  for (const part of system) {
+    if (!part || typeof part !== "object" || !("text" in part)) {
+      throw new UPPError(
+        "Google system prompt array must contain text parts",
+        "INVALID_REQUEST",
+        "google",
+        "llm"
+      );
+    }
+    const textValue = part.text;
+    if (typeof textValue !== "string") {
+      throw new UPPError(
+        "Google system prompt text must be a string",
+        "INVALID_REQUEST",
+        "google",
+        "llm"
+      );
+    }
+    parts.push(part);
+  }
+  return parts.length > 0 ? parts : void 0;
+}
+var GOOGLE_TOOLCALL_PREFIX = "google_toolcall";
+function createGoogleToolCallId(name, index) {
+  return `${GOOGLE_TOOLCALL_PREFIX}:${index}:${name}`;
+}
+function extractGoogleToolName(toolCallId) {
+  const prefix = `${GOOGLE_TOOLCALL_PREFIX}:`;
+  if (!toolCallId.startsWith(prefix)) {
+    return toolCallId;
+  }
+  const rest = toolCallId.slice(prefix.length);
+  const separatorIndex = rest.indexOf(":");
+  if (separatorIndex === -1) {
+    return toolCallId;
+  }
+  return rest.slice(separatorIndex + 1);
+}
 function filterValidContent(content) {
   return content.filter((c) => c && typeof c.type === "string");
 }
@@ -126,7 +179,7 @@ function transformMessages(messages) {
         role: "user",
         parts: msg.results.map((result) => ({
           functionResponse: {
-            name: result.toolCallId,
+            name: extractGoogleToolName(result.toolCallId),
             response: typeof result.result === "object" ? result.result : { result: result.result }
           }
         }))
@@ -193,8 +246,9 @@ function transformResponse(data) {
       }
     } else if ("functionCall" in part) {
       const fc = part;
+      const toolCallId = createGoogleToolCallId(fc.functionCall.name, toolCalls.length);
       toolCalls.push({
-        toolCallId: fc.functionCall.name,
+        toolCallId,
         toolName: fc.functionCall.name,
         arguments: fc.functionCall.args
       });
@@ -236,7 +290,7 @@ ${codeResult.codeExecutionResult.output}\`\`\`
   return {
     message,
     usage,
-    stopReason: candidate.finishReason ?? "STOP",
+    stopReason: normalizeStopReason(candidate.finishReason),
     data: structuredData
   };
 }
@@ -276,7 +330,9 @@ function transformStreamChunk(chunk, state) {
       });
     } else if ("functionCall" in part) {
       const fc = part;
+      const toolCallId = createGoogleToolCallId(fc.functionCall.name, state.toolCalls.length);
       state.toolCalls.push({
+        id: toolCallId,
         name: fc.functionCall.name,
         args: fc.functionCall.args,
         thoughtSignature: fc.thoughtSignature
@@ -285,7 +341,7 @@ function transformStreamChunk(chunk, state) {
         type: "tool_call_delta",
         index: state.toolCalls.length - 1,
         delta: {
-          toolCallId: fc.functionCall.name,
+          toolCallId,
           toolName: fc.functionCall.name,
           argumentsJson: JSON.stringify(fc.functionCall.args)
         }
@@ -325,8 +381,9 @@ function buildResponseFromState(state) {
     }
   }
   for (const tc of state.toolCalls) {
+    const toolCallId = tc.id || createGoogleToolCallId(tc.name, toolCalls.length);
     toolCalls.push({
-      toolCallId: tc.name,
+      toolCallId,
       toolName: tc.name,
       arguments: tc.args
     });
@@ -358,10 +415,25 @@ function buildResponseFromState(state) {
   return {
     message,
     usage,
-    stopReason: state.finishReason ?? "STOP",
+    stopReason: normalizeStopReason(state.finishReason),
     data: structuredData
   };
 }
+function normalizeStopReason(reason) {
+  switch (reason) {
+    case "STOP":
+      return "end_turn";
+    case "MAX_TOKENS":
+      return "max_tokens";
+    case "SAFETY":
+    case "RECITATION":
+      return "content_filter";
+    case "OTHER":
+      return "end_turn";
+    default:
+      return "end_turn";
+  }
+}
 
 // src/providers/google/llm.ts
 var GOOGLE_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
@@ -373,9 +445,8 @@ var GOOGLE_CAPABILITIES = {
   videoInput: true,
   audioInput: true
 };
-function buildUrl(modelId, action, apiKey) {
-  const base = `${GOOGLE_API_BASE}/models/${modelId}:${action}`;
-  return `${base}?key=${apiKey}`;
+function buildUrl(modelId, action) {
+  return `${GOOGLE_API_BASE}/models/${modelId}:${action}`;
 }
 function createLLMHandler() {
   let providerRef = null;
@@ -405,10 +476,11 @@ function createLLMHandler() {
             "google",
             "llm"
           );
-          const url = request.config.baseUrl ? `${request.config.baseUrl}/models/${modelId}:generateContent?key=${apiKey}` : buildUrl(modelId, "generateContent", apiKey);
+          const url = request.config.baseUrl ? `${request.config.baseUrl}/models/${modelId}:generateContent` : buildUrl(modelId, "generateContent");
           const body = transformRequest(request, modelId);
           const headers = {
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
+            "x-goog-api-key": apiKey
           };
           if (request.config.headers) {
             for (const [key, value] of Object.entries(request.config.headers)) {
@@ -429,7 +501,7 @@ function createLLMHandler() {
             "google",
             "llm"
           );
-          const data = await response.json();
+          const data = await parseJsonResponse(response, "google", "llm");
           return transformResponse(data);
         },
         stream(request) {
@@ -448,10 +520,12 @@ function createLLMHandler() {
                 "google",
                 "llm"
               );
-              const url = request.config.baseUrl ? `${request.config.baseUrl}/models/${modelId}:streamGenerateContent?alt=sse&key=${apiKey}` : `${buildUrl(modelId, "streamGenerateContent", apiKey)}&alt=sse`;
+              const url = request.config.baseUrl ? `${request.config.baseUrl}/models/${modelId}:streamGenerateContent?alt=sse` : `${buildUrl(modelId, "streamGenerateContent")}?alt=sse`;
               const body = transformRequest(request, modelId);
               const headers = {
-                "Content-Type": "application/json"
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+                "x-goog-api-key": apiKey
               };
               if (request.config.headers) {
                 for (const [key, value] of Object.entries(request.config.headers)) {
@@ -490,7 +564,7 @@ function createLLMHandler() {
               for await (const data of parseSSEStream(response.body)) {
                 if (typeof data === "object" && data !== null) {
                   const chunk = data;
-                  if ("error" in chunk) {
+                  if (chunk.error) {
                     const error = new UPPError(
                       chunk.error.message,
                       "PROVIDER_ERROR",
@@ -508,8 +582,9 @@ function createLLMHandler() {
               }
               responseResolve(buildResponseFromState(state));
             } catch (error) {
-              responseReject(error);
-              throw error;
+              const err = toError(error);
+              responseReject(err);
+              throw err;
             }
           }
           return {
@@ -570,26 +645,16 @@ function createEmbeddingHandler() {
               );
             }
             const embedRequest = {
+              ...request.params,
               model: `models/${modelId}`,
               content: { parts: [{ text }] }
             };
-            if (request.params?.taskType !== void 0) {
-              embedRequest.taskType = request.params.taskType;
-            }
-            if (request.params?.title !== void 0) {
-              embedRequest.title = request.params.title;
-            }
-            if (request.params?.outputDimensionality !== void 0) {
-              embedRequest.outputDimensionality = request.params.outputDimensionality;
-            }
-            if (request.params?.autoTruncate !== void 0) {
-              embedRequest.autoTruncate = request.params.autoTruncate;
-            }
             return embedRequest;
           });
-          const url = `${baseUrl}/models/${modelId}:batchEmbedContents?key=${apiKey}`;
+          const url = `${baseUrl}/models/${modelId}:batchEmbedContents`;
           const headers = {
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
+            "x-goog-api-key": apiKey
           };
           if (request.config.headers) {
             for (const [key, value] of Object.entries(request.config.headers)) {
@@ -604,7 +669,7 @@ function createEmbeddingHandler() {
             body: JSON.stringify({ requests }),
             signal: request.signal
           }, request.config, "google", "embedding");
-          const data = await response.json();
+          const data = await parseJsonResponse(response, "google", "embedding");
           let totalTokens = 0;
           for (const emb of data.embeddings) {
             totalTokens += emb.statistics?.tokenCount ?? 0;
@@ -700,20 +765,11 @@ async function executeGenerate(modelId, request) {
     body: JSON.stringify(body),
     signal: request.signal
   }, request.config, "google", "image");
-  const data = await response.json();
+  const data = await parseJsonResponse(response, "google", "image");
   return transformResponse2(data);
 }
 function buildParameters(params) {
-  const parameters = {};
-  if (!params) return parameters;
-  if (params.sampleCount !== void 0) parameters.sampleCount = params.sampleCount;
-  if (params.imageSize !== void 0) parameters.imageSize = params.imageSize;
-  if (params.aspectRatio !== void 0) parameters.aspectRatio = params.aspectRatio;
-  if (params.personGeneration !== void 0) parameters.personGeneration = params.personGeneration;
-  if (params.safetyFilterLevel !== void 0) parameters.safetyFilterLevel = params.safetyFilterLevel;
-  if (params.addWatermark !== void 0) parameters.addWatermark = params.addWatermark;
-  if (params.negativePrompt !== void 0) parameters.negativePrompt = params.negativePrompt;
-  return parameters;
+  return params ? { ...params } : {};
 }
 function transformResponse2(data) {
   if (!data.predictions || data.predictions.length === 0) {
@@ -738,10 +794,19 @@ function transformResponse2(data) {
 }
 
 // src/providers/google/cache.ts
-var CACHE_API_BASE = "https://generativelanguage.googleapis.com/v1beta/cachedContents";
+var DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function resolveBaseUrl(config) {
+  if (config?.baseUrl) {
+    const trimmed = config.baseUrl.replace(/\/$/, "");
+    return trimmed.endsWith("/v1beta") ? trimmed : `${trimmed}/v1beta`;
+  }
+  return DEFAULT_BASE_URL;
+}
 async function create(options) {
   const {
     apiKey,
+    config,
+    signal,
     model,
     displayName,
     contents,
@@ -750,6 +815,8 @@ async function create(options) {
     ttl,
     expireTime
   } = options;
+  const baseUrl = resolveBaseUrl(config);
+  const requestConfig = { ...config, apiKey };
   const requestBody = {
     model: model.startsWith("models/") ? model : `models/${model}`
   };
@@ -772,56 +839,163 @@ async function create(options) {
   } else if (expireTime) {
     requestBody.expireTime = expireTime;
   }
-  const response = await fetch(`${CACHE_API_BASE}?key=${apiKey}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(requestBody)
-  });
-  if (!response.ok) {
-    throw await normalizeHttpError(response, "google", "llm");
+  const headers = {
+    "Content-Type": "application/json",
+    "x-goog-api-key": apiKey
+  };
+  if (config?.headers) {
+    for (const [key, value] of Object.entries(config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
   }
-  return response.json();
+  const response = await doFetch(
+    `${baseUrl}/cachedContents`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody),
+      signal
+    },
+    requestConfig,
+    "google",
+    "llm"
+  );
+  return parseJsonResponse(response, "google", "llm");
 }
-async function get(name, apiKey) {
+async function get(name, apiKey, config, signal) {
   const cacheName = name.startsWith("cachedContents/") ? name : `cachedContents/${name}`;
-  const url = `https://generativelanguage.googleapis.com/v1beta/${cacheName}?key=${apiKey}`;
-  const response = await fetch(url, { method: "GET" });
-  if (!response.ok) {
-    throw await normalizeHttpError(response, "google", "llm");
+  const baseUrl = resolveBaseUrl(config);
+  const url = `${baseUrl}/${cacheName}`;
+  const requestConfig = { ...config, apiKey };
+  const headers = { "x-goog-api-key": apiKey };
+  if (config?.headers) {
+    for (const [key, value] of Object.entries(config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
   }
-  return response.json();
+  const response = await doFetch(
+    url,
+    {
+      method: "GET",
+      headers,
+      signal
+    },
+    requestConfig,
+    "google",
+    "llm"
+  );
+  return parseJsonResponse(response, "google", "llm");
 }
 async function list(options) {
-  const { apiKey, pageSize, pageToken } = options;
-  const params = new URLSearchParams({ key: apiKey });
+  const { apiKey, config, signal, pageSize, pageToken } = options;
+  const baseUrl = resolveBaseUrl(config);
+  const requestConfig = { ...config, apiKey };
+  const params = new URLSearchParams();
   if (pageSize) params.set("pageSize", String(pageSize));
   if (pageToken) params.set("pageToken", pageToken);
-  const response = await fetch(`${CACHE_API_BASE}?${params}`, { method: "GET" });
-  if (!response.ok) {
-    throw await normalizeHttpError(response, "google", "llm");
+  const headers = { "x-goog-api-key": apiKey };
+  if (config?.headers) {
+    for (const [key, value] of Object.entries(config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
   }
-  return response.json();
+  const response = await doFetch(
+    `${baseUrl}/cachedContents?${params}`,
+    {
+      method: "GET",
+      headers,
+      signal
+    },
+    requestConfig,
+    "google",
+    "llm"
+  );
+  return parseJsonResponse(response, "google", "llm");
 }
-async function update(name, updateRequest, apiKey) {
+async function update(name, updateRequest, apiKey, config, signal) {
+  if (updateRequest.expireTime && updateRequest.ttl) {
+    throw new UPPError(
+      "Provide either expireTime or ttl (not both)",
+      "INVALID_REQUEST",
+      "google",
+      "llm"
+    );
+  }
+  const updateMaskParts = [];
+  if (updateRequest.expireTime) {
+    updateMaskParts.push("expireTime");
+  }
+  if (updateRequest.ttl) {
+    updateMaskParts.push("ttl");
+  }
+  if (updateMaskParts.length === 0) {
+    throw new UPPError(
+      "Update request must include expireTime or ttl",
+      "INVALID_REQUEST",
+      "google",
+      "llm"
+    );
+  }
   const cacheName = name.startsWith("cachedContents/") ? name : `cachedContents/${name}`;
-  const url = `https://generativelanguage.googleapis.com/v1beta/${cacheName}?key=${apiKey}`;
-  const response = await fetch(url, {
-    method: "PATCH",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(updateRequest)
-  });
-  if (!response.ok) {
-    throw await normalizeHttpError(response, "google", "llm");
+  const baseUrl = resolveBaseUrl(config);
+  const params = new URLSearchParams({ updateMask: updateMaskParts.join(",") });
+  const url = `${baseUrl}/${cacheName}?${params.toString()}`;
+  const requestConfig = { ...config, apiKey };
+  const headers = {
+    "Content-Type": "application/json",
+    "x-goog-api-key": apiKey
+  };
+  if (config?.headers) {
+    for (const [key, value] of Object.entries(config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
   }
-  return response.json();
+  const response = await doFetch(
+    url,
+    {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(updateRequest),
+      signal
+    },
+    requestConfig,
+    "google",
+    "llm"
+  );
+  return parseJsonResponse(response, "google", "llm");
 }
-async function deleteCache(name, apiKey) {
+async function deleteCache(name, apiKey, config, signal) {
   const cacheName = name.startsWith("cachedContents/") ? name : `cachedContents/${name}`;
-  const url = `https://generativelanguage.googleapis.com/v1beta/${cacheName}?key=${apiKey}`;
-  const response = await fetch(url, { method: "DELETE" });
-  if (!response.ok) {
-    throw await normalizeHttpError(response, "google", "llm");
+  const baseUrl = resolveBaseUrl(config);
+  const url = `${baseUrl}/${cacheName}`;
+  const requestConfig = { ...config, apiKey };
+  const headers = { "x-goog-api-key": apiKey };
+  if (config?.headers) {
+    for (const [key, value] of Object.entries(config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
   }
+  const response = await doFetch(
+    url,
+    {
+      method: "DELETE",
+      headers,
+      signal
+    },
+    requestConfig,
+    "google",
+    "llm"
+  );
 }
 var cache = {
   create,
@@ -870,7 +1044,7 @@ var tools = {
 var baseProvider = createProvider({
   name: "google",
   version: "1.0.0",
-  modalities: {
+  handlers: {
     llm: createLLMHandler(),
     embedding: createEmbeddingHandler(),
     image: createImageHandler()