@core-ai/google-genai 0.2.0 → 0.3.0

package/README.md

@@ -1,5 +1,7 @@
 # @core-ai/google-genai
 
+[![npm](https://img.shields.io/npm/v/@core-ai/google-genai.svg)](https://www.npmjs.com/package/@core-ai/google-genai)
+
 Google GenAI provider package for `@core-ai/core-ai`.
 
 ## Installation

package/dist/index.js

@@ -2,15 +2,31 @@
 import { GoogleGenAI } from "@google/genai";
 
 // src/chat-model.ts
-import { createStreamResult } from "@core-ai/core-ai";
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStreamResult,
+  createStreamResult
+} from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
 import {
-  ApiError,
   FunctionCallingConfigMode
 } from "@google/genai";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { ProviderError } from "@core-ai/core-ai";
+
+// src/object-utils.ts
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+
+// src/chat-adapter.ts
+var DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME = "core_ai_generate_object";
+var DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION = "Return a JSON object that matches the requested schema.";
 function convertMessages(messages) {
   const systemParts = [];
   const contents = [];
@@ -101,17 +117,17 @@ function convertUserContentPart(part) {
   };
 }
 function convertTools(tools) {
-  const functionDeclarations = Object.values(tools).map(
-    (tool) => {
-      const schema = zodToJsonSchema(tool.parameters);
-      const { $schema: _schema, ...parametersJsonSchema } = schema;
-      return {
-        name: tool.name,
-        description: tool.description,
-        parametersJsonSchema
-      };
-    }
-  );
+  const functionDeclarations = Object.values(
+    tools
+  ).map((tool) => {
+    const schema = zodToJsonSchema(tool.parameters);
+    const { $schema: _schema, ...parametersJsonSchema } = schema;
+    return {
+      name: tool.name,
+      description: tool.description,
+      parametersJsonSchema
+    };
+  });
   if (functionDeclarations.length === 0) {
     return [];
   }
@@ -150,6 +166,33 @@ function convertToolChoice(choice) {
     }
   };
 }
+function getStructuredOutputToolName(options) {
+  const trimmedName = options.schemaName?.trim();
+  if (trimmedName && trimmedName.length > 0) {
+    return trimmedName;
+  }
+  return DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME;
+}
+function createStructuredOutputOptions(options) {
+  const toolName = getStructuredOutputToolName(options);
+  return {
+    messages: options.messages,
+    tools: {
+      structured_output: {
+        name: toolName,
+        description: options.schemaDescription ?? DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION,
+        parameters: options.schema
+      }
+    },
+    toolChoice: {
+      type: "tool",
+      toolName
+    },
+    config: options.config,
+    providerOptions: options.providerOptions,
+    signal: options.signal
+  };
+}
 function isToolResultContent(content) {
   if (content.role !== "user" || !content.parts || content.parts.length === 0) {
     return false;
@@ -282,7 +325,9 @@ async function* transformStream(stream) {
             toolCallId: mappedCall.id,
             toolName: mappedCall.name
           };
-          const serializedArguments = JSON.stringify(mappedCall.arguments);
+          const serializedArguments = JSON.stringify(
+            mappedCall.arguments
+          );
           if (serializedArguments !== "{}") {
             yield {
               type: "tool-call-delta",
@@ -339,13 +384,11 @@ function mapUsage(response, fallback) {
     totalTokens
   };
 }
-function asObject(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return value;
-  }
-  return {};
-}
-function wrapError(error) {
+
+// src/google-error.ts
+import { ApiError } from "@google/genai";
+import { ProviderError } from "@core-ai/core-ai";
+function wrapGoogleError(error) {
   if (error instanceof ApiError) {
     return new ProviderError(error.message, "google", error.status, error);
   }
@@ -359,33 +402,215 @@ function wrapError(error) {
 
 // src/chat-model.ts
 function createGoogleGenAIChatModel(client, modelId) {
+  const provider = "google";
+  async function callGenerateContentApi(request) {
+    try {
+      return await client.models.generateContent(request);
+    } catch (error) {
+      throw wrapGoogleError(error);
+    }
+  }
+  async function callGenerateContentStreamApi(request) {
+    try {
+      return await client.models.generateContentStream(request);
+    } catch (error) {
+      throw wrapGoogleError(error);
+    }
+  }
+  async function generateChat(options) {
+    const request = createGenerateRequest(modelId, options);
+    const response = await callGenerateContentApi(request);
+    return mapGenerateResponse(response);
+  }
+  async function streamChat(options) {
+    const request = createGenerateRequest(modelId, options);
+    const stream = await callGenerateContentStreamApi(request);
+    return createStreamResult(transformStream(stream));
+  }
   return {
-    provider: "google",
+    provider,
     modelId,
-    async generate(options) {
-      try {
-        const request = createGenerateRequest(modelId, options);
-        const response = await client.models.generateContent(request);
-        return mapGenerateResponse(response);
-      } catch (error) {
-        throw wrapError(error);
-      }
+    generate: generateChat,
+    stream: streamChat,
+    async generateObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const result = await generateChat(structuredOptions);
+      const toolName = getStructuredOutputToolName(options);
+      const object = extractStructuredObject(
+        result,
+        options.schema,
+        provider,
+        toolName
+      );
+      return {
+        object,
+        finishReason: result.finishReason,
+        usage: result.usage
+      };
     },
-    async stream(options) {
-      try {
-        const request = createGenerateRequest(modelId, options);
-        const stream = await client.models.generateContentStream(request);
-        return createStreamResult(transformStream(stream));
-      } catch (error) {
-        throw wrapError(error);
-      }
+    async streamObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const stream = await streamChat(structuredOptions);
+      const toolName = getStructuredOutputToolName(options);
+      return createObjectStreamResult(
+        transformStructuredOutputStream(
+          stream,
+          options.schema,
+          provider,
+          toolName
+        )
+      );
     }
   };
 }
+function extractStructuredObject(result, schema, provider, toolName) {
+  const structuredToolCall = result.toolCalls.find(
+    (toolCall) => toolCall.name === toolName
+  );
+  if (structuredToolCall) {
+    return validateStructuredToolArguments(
+      schema,
+      structuredToolCall.arguments,
+      provider
+    );
+  }
+  const rawOutput = result.content?.trim();
+  if (rawOutput && rawOutput.length > 0) {
+    return parseAndValidateStructuredPayload(schema, rawOutput, provider);
+  }
+  throw new StructuredOutputNoObjectGeneratedError(
+    "model did not emit a structured object payload",
+    provider
+  );
+}
+async function* transformStructuredOutputStream(stream, schema, provider, toolName) {
+  let validatedObject;
+  let contentBuffer = "";
+  const toolArgumentDeltas = /* @__PURE__ */ new Map();
+  for await (const event of stream) {
+    if (event.type === "content-delta") {
+      contentBuffer += event.text;
+      yield {
+        type: "object-delta",
+        text: event.text
+      };
+      continue;
+    }
+    if (event.type === "tool-call-delta") {
+      const previous = toolArgumentDeltas.get(event.toolCallId) ?? "";
+      toolArgumentDeltas.set(
+        event.toolCallId,
+        `${previous}${event.argumentsDelta}`
+      );
+      yield {
+        type: "object-delta",
+        text: event.argumentsDelta
+      };
+      continue;
+    }
+    if (event.type === "tool-call-end" && event.toolCall.name === toolName) {
+      validatedObject = validateStructuredToolArguments(
+        schema,
+        event.toolCall.arguments,
+        provider
+      );
+      yield {
+        type: "object",
+        object: validatedObject
+      };
+      continue;
+    }
+    if (event.type === "finish") {
+      if (validatedObject === void 0) {
+        const fallbackPayload = getFallbackStructuredPayload(
+          contentBuffer,
+          toolArgumentDeltas
+        );
+        if (!fallbackPayload) {
+          throw new StructuredOutputNoObjectGeneratedError(
+            "structured output stream ended without an object payload",
+            provider
+          );
+        }
+        validatedObject = parseAndValidateStructuredPayload(
+          schema,
+          fallbackPayload,
+          provider
+        );
+        yield {
+          type: "object",
+          object: validatedObject
+        };
+      }
+      yield {
+        type: "finish",
+        finishReason: event.finishReason,
+        usage: event.usage
+      };
+    }
+  }
+}
+function getFallbackStructuredPayload(contentBuffer, toolArgumentDeltas) {
+  for (const delta of toolArgumentDeltas.values()) {
+    const trimmed = delta.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  const trimmedContent = contentBuffer.trim();
+  if (trimmedContent.length > 0) {
+    return trimmedContent;
+  }
+  return void 0;
+}
+function validateStructuredToolArguments(schema, toolArguments, provider) {
+  return validateStructuredObject(
+    schema,
+    toolArguments,
+    provider,
+    JSON.stringify(toolArguments)
+  );
+}
+function parseAndValidateStructuredPayload(schema, rawPayload, provider) {
+  const parsedPayload = parseJson(rawPayload, provider);
+  return validateStructuredObject(schema, parsedPayload, provider, rawPayload);
+}
+function parseJson(rawOutput, provider) {
+  try {
+    return JSON.parse(rawOutput);
+  } catch (error) {
+    throw new StructuredOutputParseError(
+      "failed to parse structured output as JSON",
+      provider,
+      {
+        rawOutput,
+        cause: error
+      }
+    );
+  }
+}
+function validateStructuredObject(schema, value, provider, rawOutput) {
+  const parsed = schema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  throw new StructuredOutputValidationError(
+    "structured output does not match schema",
+    provider,
+    formatZodIssues(parsed.error.issues),
+    {
+      rawOutput
+    }
+  );
+}
+function formatZodIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.map((segment) => String(segment)).join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  });
+}
 
 // src/embedding-model.ts
-import { ApiError as ApiError2 } from "@google/genai";
-import { ProviderError as ProviderError2 } from "@core-ai/core-ai";
 function createGoogleGenAIEmbeddingModel(client, modelId) {
   return {
     provider: "google",
@@ -407,48 +632,33 @@ function createGoogleGenAIEmbeddingModel(client, modelId) {
           ...providerOptions,
           config: {
             ...baseRequest.config,
-            ...asObject2(providerOptions["config"])
+            ...asObject(providerOptions["config"])
           }
         } : baseRequest;
         const response = await client.models.embedContent(request);
+        const tokenCounts = (response.embeddings ?? []).map((item) => item.statistics?.tokenCount).filter(
+          (tokenCount) => typeof tokenCount === "number"
+        );
+        const usage = tokenCounts.length > 0 ? {
+          inputTokens: tokenCounts.reduce(
+            (total, tokenCount) => total + tokenCount,
+            0
+          )
+        } : void 0;
         return {
           embeddings: (response.embeddings ?? []).map(
             (item) => item.values ?? []
           ),
-          usage: {
-            inputTokens: (response.embeddings ?? []).reduce(
-              (total, item) => total + (item.statistics?.tokenCount ?? 0),
-              0
-            )
-          }
+          usage
         };
       } catch (error) {
-        throw wrapError2(error);
+        throw wrapGoogleError(error);
       }
     }
   };
 }
-function wrapError2(error) {
-  if (error instanceof ApiError2) {
-    return new ProviderError2(error.message, "google", error.status, error);
-  }
-  return new ProviderError2(
-    error instanceof Error ? error.message : String(error),
-    "google",
-    void 0,
-    error
-  );
-}
-function asObject2(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return value;
-  }
-  return {};
-}
 
 // src/image-model.ts
-import { ApiError as ApiError3 } from "@google/genai";
-import { ProviderError as ProviderError3 } from "@core-ai/core-ai";
 function createGoogleGenAIImageModel(client, modelId) {
   return {
     provider: "google",
@@ -469,7 +679,7 @@ function createGoogleGenAIImageModel(client, modelId) {
           ...providerOptions,
           config: {
             ...baseRequest.config,
-            ...asObject3(providerOptions["config"])
+            ...asObject(providerOptions["config"])
           }
         } : baseRequest;
         const response = await client.models.generateImages(request);
@@ -481,22 +691,11 @@ function createGoogleGenAIImageModel(client, modelId) {
           }))
         };
       } catch (error) {
-        throw wrapError3(error);
+        throw wrapGoogleError(error);
       }
     }
   };
 }
-function wrapError3(error) {
-  if (error instanceof ApiError3) {
-    return new ProviderError3(error.message, "google", error.status, error);
-  }
-  return new ProviderError3(
-    error instanceof Error ? error.message : String(error),
-    "google",
-    void 0,
-    error
-  );
-}
 function mapSizeToImageConfig(size) {
   if (!size) {
     return {};
@@ -531,12 +730,6 @@ function greatestCommonDivisor(a, b) {
   }
   return x === 0 ? 1 : x;
 }
-function asObject3(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return value;
-  }
-  return {};
-}
 
 // src/provider.ts
 function createGoogleGenAI(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/google-genai",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "description": "Google GenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -44,12 +44,12 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.2.0",
+        "@core-ai/core-ai": "^0.3.0",
         "@google/genai": "^1.42.0",
-        "zod-to-json-schema": "^3.24.5"
+        "zod-to-json-schema": "^3.25.1"
     },
     "peerDependencies": {
-        "zod": "^3.25.76"
+        "zod": "^3.25.0 || ^4.0.0"
     },
     "devDependencies": {
         "@core-ai/eslint-config": "^0.0.0",