@core-ai/google-genai 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omnifact (https://omnifact.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @core-ai/google-genai
+
+Google GenAI provider package for `@core-ai/core-ai`.
+
+## Installation
+
+```bash
+npm install @core-ai/core-ai @core-ai/google-genai zod
+```
+
+## Usage
+
+```ts
+import { generate } from '@core-ai/core-ai';
+import { createGoogleGenAI } from '@core-ai/google-genai';
+
+const google = createGoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });
+const model = google.chatModel('gemini-3-flash');
+
+const result = await generate({
+    model,
+    messages: [{ role: 'user', content: 'Hello!' }],
+});
+
+console.log(result.content);
+```

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { GoogleGenAI } from '@google/genai';
+import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
+
+type GoogleGenAIProviderOptions = {
+    apiKey?: string;
+    apiVersion?: string;
+    baseUrl?: string;
+    client?: GoogleGenAI;
+};
+type GoogleGenAIProvider = {
+    chatModel(modelId: string): ChatModel;
+    embeddingModel(modelId: string): EmbeddingModel;
+    imageModel(modelId: string): ImageModel;
+};
+declare function createGoogleGenAI(options?: GoogleGenAIProviderOptions): GoogleGenAIProvider;
+
+export { type GoogleGenAIProvider, type GoogleGenAIProviderOptions, createGoogleGenAI };

package/dist/index.js

@@ -0,0 +1,560 @@
+// src/provider.ts
+import { GoogleGenAI } from "@google/genai";
+
+// src/chat-model.ts
+import { 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";
+function convertMessages(messages) {
+  const systemParts = [];
+  const contents = [];
+  const toolCallNameById = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "system") {
+      systemParts.push(message.content);
+      continue;
+    }
+    if (message.role === "user") {
+      const userParts = typeof message.content === "string" ? [{ text: message.content }] : message.content.map(convertUserContentPart);
+      contents.push({
+        role: "user",
+        parts: userParts
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const assistantParts = [];
+      if (message.content) {
+        assistantParts.push({ text: message.content });
+      }
+      for (const toolCall of message.toolCalls ?? []) {
+        toolCallNameById.set(toolCall.id, toolCall.name);
+        assistantParts.push({
+          functionCall: {
+            id: toolCall.id,
+            name: toolCall.name,
+            args: toolCall.arguments
+          }
+        });
+      }
+      contents.push({
+        role: "model",
+        parts: assistantParts.length > 0 ? assistantParts : [{ text: "" }]
+      });
+      continue;
+    }
+    const functionName = toolCallNameById.get(message.toolCallId) ?? message.toolCallId;
+    const response = message.isError ? { error: message.content } : { output: message.content };
+    const toolResponsePart = {
+      functionResponse: {
+        id: message.toolCallId,
+        name: functionName,
+        response
+      }
+    };
+    const lastContent = contents.at(-1);
+    if (lastContent && isToolResultContent(lastContent)) {
+      lastContent.parts?.push(toolResponsePart);
+      continue;
+    }
+    contents.push({
+      role: "user",
+      parts: [toolResponsePart]
+    });
+  }
+  return {
+    contents,
+    systemInstruction: systemParts.length > 0 ? systemParts.join("\n") : void 0
+  };
+}
+function convertUserContentPart(part) {
+  if (part.type === "text") {
+    return { text: part.text };
+  }
+  if (part.type === "image") {
+    if (part.source.type === "url") {
+      return {
+        fileData: {
+          fileUri: part.source.url,
+          mimeType: inferMimeTypeFromUrl(part.source.url)
+        }
+      };
+    }
+    return {
+      inlineData: {
+        data: part.source.data,
+        mimeType: part.source.mediaType
+      }
+    };
+  }
+  return {
+    inlineData: {
+      data: part.data,
+      mimeType: part.mimeType
+    }
+  };
+}
+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
+      };
+    }
+  );
+  if (functionDeclarations.length === 0) {
+    return [];
+  }
+  return [
+    {
+      functionDeclarations
+    }
+  ];
+}
+function convertToolChoice(choice) {
+  if (choice === "auto") {
+    return {
+      functionCallingConfig: {
+        mode: FunctionCallingConfigMode.AUTO
+      }
+    };
+  }
+  if (choice === "none") {
+    return {
+      functionCallingConfig: {
+        mode: FunctionCallingConfigMode.NONE
+      }
+    };
+  }
+  if (choice === "required") {
+    return {
+      functionCallingConfig: {
+        mode: FunctionCallingConfigMode.ANY
+      }
+    };
+  }
+  return {
+    functionCallingConfig: {
+      mode: FunctionCallingConfigMode.ANY,
+      allowedFunctionNames: [choice.toolName]
+    }
+  };
+}
+function isToolResultContent(content) {
+  if (content.role !== "user" || !content.parts || content.parts.length === 0) {
+    return false;
+  }
+  return content.parts.every((part) => part.functionResponse);
+}
+function inferMimeTypeFromUrl(url) {
+  const normalized = url.toLowerCase();
+  if (normalized.endsWith(".png")) {
+    return "image/png";
+  }
+  if (normalized.endsWith(".webp")) {
+    return "image/webp";
+  }
+  if (normalized.endsWith(".gif")) {
+    return "image/gif";
+  }
+  if (normalized.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  return "application/octet-stream";
+}
+function createGenerateRequest(modelId, options) {
+  const convertedMessages = convertMessages(options.messages);
+  const baseRequest = {
+    model: modelId,
+    contents: convertedMessages.contents,
+    config: {
+      ...convertedMessages.systemInstruction ? { systemInstruction: convertedMessages.systemInstruction } : {},
+      ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
+      ...options.toolChoice ? { toolConfig: convertToolChoice(options.toolChoice) } : {},
+      ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
+      ...options.config?.maxTokens !== void 0 ? { maxOutputTokens: options.config.maxTokens } : {},
+      ...options.config?.topP !== void 0 ? { topP: options.config.topP } : {},
+      ...options.config?.stopSequences ? { stopSequences: options.config.stopSequences } : {},
+      ...options.config?.frequencyPenalty !== void 0 ? { frequencyPenalty: options.config.frequencyPenalty } : {},
+      ...options.config?.presencePenalty !== void 0 ? { presencePenalty: options.config.presencePenalty } : {}
+    }
+  };
+  const providerOptions = options.providerOptions;
+  if (!providerOptions) {
+    return baseRequest;
+  }
+  const providerConfig = asObject(providerOptions["config"]);
+  return {
+    ...baseRequest,
+    ...providerOptions,
+    config: {
+      ...baseRequest.config,
+      ...providerConfig
+    }
+  };
+}
+function mapGenerateResponse(response) {
+  const toolCalls = parseFunctionCalls(response.functionCalls);
+  const finishReason = mapFinishReason(
+    response.candidates?.[0]?.finishReason ?? void 0
+  );
+  if (!response.candidates?.[0]) {
+    return {
+      content: null,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? "tool-calls" : finishReason,
+      usage: mapUsage(response)
+    };
+  }
+  return {
+    content: response.text ?? null,
+    toolCalls,
+    finishReason: toolCalls.length > 0 ? "tool-calls" : finishReason,
+    usage: mapUsage(response)
+  };
+}
+function parseFunctionCalls(calls) {
+  if (!calls || calls.length === 0) {
+    return [];
+  }
+  return calls.map((call, index) => mapFunctionCall(call, index));
+}
+function mapFunctionCall(toolCall, index) {
+  return {
+    id: toolCall.id ?? `tool-${index}`,
+    name: toolCall.name ?? `tool-${index}`,
+    arguments: asObject(toolCall.args)
+  };
+}
+function mapFinishReason(reason) {
+  if (reason === "STOP") {
+    return "stop";
+  }
+  if (reason === "MAX_TOKENS") {
+    return "length";
+  }
+  if (reason === "SAFETY" || reason === "RECITATION" || reason === "BLOCKLIST" || reason === "PROHIBITED_CONTENT" || reason === "SPII" || reason === "IMAGE_SAFETY" || reason === "IMAGE_PROHIBITED_CONTENT" || reason === "IMAGE_RECITATION") {
+    return "content-filter";
+  }
+  return "unknown";
+}
+async function* transformStream(stream) {
+  const bufferedToolCalls = /* @__PURE__ */ new Map();
+  let finishReason = "unknown";
+  let sawToolCalls = false;
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0
+  };
+  for await (const chunk of stream) {
+    usage = mapUsage(chunk, usage);
+    if (chunk.text) {
+      yield {
+        type: "content-delta",
+        text: chunk.text
+      };
+    }
+    const functionCalls = chunk.functionCalls ?? [];
+    if (functionCalls.length > 0) {
+      sawToolCalls = true;
+      for (const [index, functionCall] of functionCalls.entries()) {
+        const mappedCall = mapFunctionCall(functionCall, index);
+        const existing = bufferedToolCalls.get(mappedCall.id);
+        if (!existing) {
+          bufferedToolCalls.set(mappedCall.id, mappedCall);
+          yield {
+            type: "tool-call-start",
+            toolCallId: mappedCall.id,
+            toolName: mappedCall.name
+          };
+          const serializedArguments = JSON.stringify(mappedCall.arguments);
+          if (serializedArguments !== "{}") {
+            yield {
+              type: "tool-call-delta",
+              toolCallId: mappedCall.id,
+              argumentsDelta: serializedArguments
+            };
+          }
+          continue;
+        }
+        const serializedExisting = JSON.stringify(existing.arguments);
+        const serializedNext = JSON.stringify(mappedCall.arguments);
+        if (serializedExisting !== serializedNext) {
+          bufferedToolCalls.set(mappedCall.id, mappedCall);
+          yield {
+            type: "tool-call-delta",
+            toolCallId: mappedCall.id,
+            argumentsDelta: serializedNext
+          };
+        }
+      }
+    }
+    const candidateFinishReason = mapFinishReason(
+      chunk.candidates?.[0]?.finishReason ?? void 0
+    );
+    if (candidateFinishReason !== "unknown") {
+      finishReason = candidateFinishReason;
+    }
+  }
+  for (const toolCall of bufferedToolCalls.values()) {
+    yield {
+      type: "tool-call-end",
+      toolCall
+    };
+  }
+  if (sawToolCalls && finishReason !== "content-filter") {
+    finishReason = "tool-calls";
+  }
+  yield {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function mapUsage(response, fallback) {
+  const inputTokens = response.usageMetadata?.promptTokenCount ?? fallback?.inputTokens ?? 0;
+  const textTokens = response.usageMetadata?.candidatesTokenCount ?? 0;
+  const reasoningTokens = response.usageMetadata?.thoughtsTokenCount ?? fallback?.reasoningTokens ?? 0;
+  const outputTokens = textTokens + reasoningTokens;
+  const totalTokens = response.usageMetadata?.totalTokenCount ?? fallback?.totalTokens ?? inputTokens + outputTokens;
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    totalTokens
+  };
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function wrapError(error) {
+  if (error instanceof ApiError) {
+    return new ProviderError(error.message, "google", error.status, error);
+  }
+  return new ProviderError(
+    error instanceof Error ? error.message : String(error),
+    "google",
+    void 0,
+    error
+  );
+}
+
+// src/chat-model.ts
+function createGoogleGenAIChatModel(client, modelId) {
+  return {
+    provider: "google",
+    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);
+      }
+    },
+    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);
+      }
+    }
+  };
+}
+
+// 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",
+    modelId,
+    async embed(options) {
+      try {
+        const baseRequest = {
+          model: modelId,
+          contents: Array.isArray(options.input) ? options.input : [options.input],
+          ...options.dimensions !== void 0 ? {
+            config: {
+              outputDimensionality: options.dimensions
+            }
+          } : {}
+        };
+        const providerOptions = options.providerOptions;
+        const request = providerOptions ? {
+          ...baseRequest,
+          ...providerOptions,
+          config: {
+            ...baseRequest.config,
+            ...asObject2(providerOptions["config"])
+          }
+        } : baseRequest;
+        const response = await client.models.embedContent(request);
+        return {
+          embeddings: (response.embeddings ?? []).map(
+            (item) => item.values ?? []
+          ),
+          usage: {
+            inputTokens: (response.embeddings ?? []).reduce(
+              (total, item) => total + (item.statistics?.tokenCount ?? 0),
+              0
+            )
+          }
+        };
+      } catch (error) {
+        throw wrapError2(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",
+    modelId,
+    async generate(options) {
+      try {
+        const baseRequest = {
+          model: modelId,
+          prompt: options.prompt,
+          config: {
+            ...options.n !== void 0 ? { numberOfImages: options.n } : {},
+            ...mapSizeToImageConfig(options.size)
+          }
+        };
+        const providerOptions = options.providerOptions;
+        const request = providerOptions ? {
+          ...baseRequest,
+          ...providerOptions,
+          config: {
+            ...baseRequest.config,
+            ...asObject3(providerOptions["config"])
+          }
+        } : baseRequest;
+        const response = await client.models.generateImages(request);
+        return {
+          images: (response.generatedImages ?? []).map((image) => ({
+            base64: image.image?.imageBytes ?? void 0,
+            url: image.image?.gcsUri ?? void 0,
+            revisedPrompt: image.enhancedPrompt ?? void 0
+          }))
+        };
+      } catch (error) {
+        throw wrapError3(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 {};
+  }
+  const match = /^(\d+)x(\d+)$/i.exec(size.trim());
+  if (!match) {
+    return {};
+  }
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || height === 0) {
+    return {};
+  }
+  const aspectRatio = simplifyRatio(width, height);
+  const largestDimension = Math.max(width, height);
+  return {
+    aspectRatio,
+    ...largestDimension <= 1024 ? { imageSize: "1K" } : largestDimension <= 2048 ? { imageSize: "2K" } : {}
+  };
+}
+function simplifyRatio(width, height) {
+  const divisor = greatestCommonDivisor(width, height);
+  return `${Math.round(width / divisor)}:${Math.round(height / divisor)}`;
+}
+function greatestCommonDivisor(a, b) {
+  let x = Math.abs(a);
+  let y = Math.abs(b);
+  while (y !== 0) {
+    const remainder = x % y;
+    x = y;
+    y = remainder;
+  }
+  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 = {}) {
+  const client = options.client ?? new GoogleGenAI({
+    apiKey: options.apiKey,
+    ...options.apiVersion ? { apiVersion: options.apiVersion } : {},
+    ...options.baseUrl ? {
+      httpOptions: {
+        baseUrl: options.baseUrl
+      }
+    } : {}
+  });
+  return {
+    chatModel: (modelId) => createGoogleGenAIChatModel(client, modelId),
+    embeddingModel: (modelId) => createGoogleGenAIEmbeddingModel(client, modelId),
+    imageModel: (modelId) => createGoogleGenAIImageModel(client, modelId)
+  };
+}
+export {
+  createGoogleGenAI
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@core-ai/google-genai",
+    "version": "0.1.0",
+    "description": "Google GenAI provider package for @core-ai/core-ai",
+    "license": "MIT",
+    "author": "Omnifact (https://omnifact.ai)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/agdevhq/ai-core.git",
+        "directory": "packages/google-genai"
+    },
+    "keywords": ["llm", "ai", "google", "genai", "provider", "sdk"],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": ["dist", "README.md", "LICENSE"],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsup",
+        "lint": "eslint src/ --max-warnings 0",
+        "check-types": "tsc --noEmit",
+        "prepublishOnly": "npm run build",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "dependencies": {
+        "@core-ai/core-ai": "^0.1.0",
+        "@google/genai": "^1.42.0",
+        "zod-to-json-schema": "^3.24.5"
+    },
+    "peerDependencies": {
+        "zod": "^3.25.76"
+    },
+    "devDependencies": {
+        "@core-ai/eslint-config": "^0.0.0",
+        "@core-ai/typescript-config": "^0.0.0",
+        "typescript": "^5.7.3",
+        "vitest": "^3.2.4"
+    }
+}