@strand-js/google 0.1.0

package/README.md

@@ -0,0 +1,99 @@
+# @strand-js/google
+
+Google Gemini provider adapter for [Strand](https://github.com/strand-js/strand) — AI state management for React.
+
+## Install
+
+```bash
+npm install @strand-js/google
+```
+
+## Usage
+
+### Express / Fastify / Hono
+
+```ts
+import { createStrandHandler } from '@strand-js/google'
+
+app.post('/api/strand', createStrandHandler({
+  apiKey: process.env.GOOGLE_API_KEY,
+  model: 'gemini-2.0-flash',
+  system: 'You are a helpful assistant.',
+}))
+```
+
+### Next.js App Router
+
+```ts
+// app/api/strand/route.ts
+import { createStrandRoute } from '@strand-js/google'
+
+export const POST = createStrandRoute({
+  apiKey: process.env.GOOGLE_API_KEY,
+  model: 'gemini-2.0-flash',
+})
+```
+
+## Get a Google API key
+
+1. Go to [aistudio.google.com](https://aistudio.google.com)
+2. Click **Get API Key**
+3. Create a new key or use an existing project
+
+## Supported models
+
+| Model | Notes |
+|---|---|
+| `gemini-2.0-flash` | Fastest, recommended for most use cases |
+| `gemini-2.5-pro` | Most capable |
+| `gemini-1.5-pro` | Previous generation |
+| `gemini-1.5-flash` | Previous generation, fast |
+
+## Switching from Anthropic
+
+Only the server changes — the React hooks are identical:
+
+```diff
+- import { createStrandHandler } from '@strand-js/anthropic'
++ import { createStrandHandler } from '@strand-js/google'
+
+  createStrandHandler({
+-   apiKey: process.env.ANTHROPIC_API_KEY,
+-   model: 'claude-sonnet-4-6',
++   apiKey: process.env.GOOGLE_API_KEY,
++   model: 'gemini-2.0-flash',
+  })
+```
+
+## Production security
+
+```ts
+createStrandHandler({
+  apiKey: process.env.GOOGLE_API_KEY,
+  model: 'gemini-2.0-flash',
+  authorize: async (request) => {
+    const user = await verifyToken(request.headers.get('authorization'))
+    if (!user) throw new Error('Unauthorized')
+  },
+  rateLimit: { windowMs: 60_000, maxRequests: 20 },
+  maxMessages: 50,
+  maxMessageLength: 10_000,
+})
+```
+
+## Config reference
+
+| Option | Type | Description |
+|---|---|---|
+| `apiKey` | `string` | Your Google AI API key |
+| `model` | `string` | Model ID, e.g. `'gemini-2.0-flash'` |
+| `system` | `string \| (req) => string` | System prompt |
+| `tools` | `ToolDefinition[]` | Tools available to the model |
+| `onToolCall` | `async (name, args, ctx) => result` | Server-side tool execution |
+| `authorize` | `async (req) => void` | Throw to reject with 401 |
+| `rateLimit` | `{ windowMs, maxRequests }` | Built-in IP rate limiting |
+| `maxMessages` | `number` | Max messages per request (default: 100) |
+| `maxMessageLength` | `number` | Max chars per message (default: 50,000) |
+| `maxSteps` | `number` | Max tool call rounds (default: 10) |
+
+[Full documentation →](https://github.com/strand-js/strand)

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { ToolDefinition, RateLimitConfig, Session } from '@strand-js/core';
+
+interface StrandHandlerConfig {
+    apiKey: string;
+    model: string;
+    system?: string | ((request: Request) => string | Promise<string>);
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>, ctx: {
+        request: Request;
+    }) => Promise<unknown>;
+    authorize?: (request: Request) => Promise<unknown> | unknown;
+    rateLimit?: RateLimitConfig;
+    maxMessages?: number;
+    maxMessageLength?: number;
+    maxSteps?: number;
+    onFinish?: (session: Session) => void;
+}
+type AnyReq = Record<string, unknown>;
+type AnyRes = {
+    setHeader(name: string, value: string): void;
+    status(code: number): AnyRes;
+    json(body: unknown): void;
+    write(chunk: string): void;
+    end(): void;
+};
+declare function createStrandHandler(config: StrandHandlerConfig): (req: AnyReq, res: AnyRes) => Promise<void>;
+
+declare function createStrandRoute(config: StrandHandlerConfig): (req: Request) => Promise<Response>;
+
+export { type StrandHandlerConfig, createStrandHandler, createStrandRoute };

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { ToolDefinition, RateLimitConfig, Session } from '@strand-js/core';
+
+interface StrandHandlerConfig {
+    apiKey: string;
+    model: string;
+    system?: string | ((request: Request) => string | Promise<string>);
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>, ctx: {
+        request: Request;
+    }) => Promise<unknown>;
+    authorize?: (request: Request) => Promise<unknown> | unknown;
+    rateLimit?: RateLimitConfig;
+    maxMessages?: number;
+    maxMessageLength?: number;
+    maxSteps?: number;
+    onFinish?: (session: Session) => void;
+}
+type AnyReq = Record<string, unknown>;
+type AnyRes = {
+    setHeader(name: string, value: string): void;
+    status(code: number): AnyRes;
+    json(body: unknown): void;
+    write(chunk: string): void;
+    end(): void;
+};
+declare function createStrandHandler(config: StrandHandlerConfig): (req: AnyReq, res: AnyRes) => Promise<void>;
+
+declare function createStrandRoute(config: StrandHandlerConfig): (req: Request) => Promise<Response>;
+
+export { type StrandHandlerConfig, createStrandHandler, createStrandRoute };

package/dist/index.js

@@ -0,0 +1,339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createStrandHandler: () => createStrandHandler,
+  createStrandRoute: () => createStrandRoute
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/handler.ts
+var import_generative_ai = require("@google/generative-ai");
+var import_core2 = require("@strand-js/core");
+
+// src/format.ts
+var import_core = require("@strand-js/core");
+function toolToGoogleTool(tool) {
+  const schema = (0, import_core.toolToJsonSchema)(tool);
+  return {
+    functionDeclarations: [
+      {
+        name: tool.name,
+        description: tool.description,
+        parameters: schema
+      }
+    ]
+  };
+}
+function messagesToGoogleMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (!msg.content.trim() && !msg.toolCalls?.length) continue;
+    const role = msg.role === "assistant" ? "model" : "user";
+    const parts = [];
+    if (msg.content.trim()) {
+      parts.push({ text: msg.content });
+    }
+    for (const tc of msg.toolCalls ?? []) {
+      parts.push({
+        functionCall: { name: tc.name, args: tc.input }
+      });
+    }
+    const last = result.at(-1);
+    if (last && last.role === role) {
+      last.parts.push(...parts);
+    } else {
+      result.push({ role, parts });
+    }
+  }
+  return result;
+}
+
+// src/handler.ts
+function emit(res, eventType, data) {
+  res.write(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function normalizeRequest(req) {
+  const rawHeaders = req.headers ?? {};
+  return {
+    ...req,
+    headers: {
+      get: (name) => {
+        const val = rawHeaders[name.toLowerCase()];
+        return Array.isArray(val) ? val[0] ?? null : val ?? null;
+      }
+    }
+  };
+}
+function createStrandHandler(config) {
+  const genAI = new import_generative_ai.GoogleGenerativeAI(config.apiKey);
+  const googleTools = (config.tools ?? []).map(toolToGoogleTool);
+  const maxSteps = config.maxSteps ?? 10;
+  const rateLimiter = config.rateLimit ? new import_core2.RateLimiter(config.rateLimit) : null;
+  return async (req, res) => {
+    const normalizedReq = normalizeRequest(req);
+    const body = req.body;
+    if (rateLimiter) {
+      const ip = req.ip ?? "unknown";
+      const limited = rateLimiter.check(ip);
+      if (limited) {
+        res.status(429).json({ error: "Too many requests", retryAfter: limited.retryAfter });
+        return;
+      }
+    }
+    const validation = (0, import_core2.validateMessages)(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      res.status(validation.status).json({ error: validation.error });
+      return;
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(normalizedReq);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        res.status(401).json({ error: message });
+        return;
+      }
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    emit(res, "strand:start", { sessionId: (0, import_core2.generateId)(), requestId: (0, import_core2.generateId)() });
+    try {
+      const messages = body.messages;
+      const system = typeof config.system === "function" ? await config.system(normalizedReq) : config.system ?? "";
+      const model = genAI.getGenerativeModel({
+        model: config.model,
+        ...system ? { systemInstruction: system } : {},
+        ...googleTools.length > 0 ? { tools: googleTools } : {}
+      });
+      const allMessages = messages.map((m) => ({
+        id: (0, import_core2.generateId)(),
+        role: m.role,
+        content: m.content,
+        createdAt: /* @__PURE__ */ new Date()
+      }));
+      const history = messagesToGoogleMessages(allMessages.slice(0, -1));
+      const lastMessage = allMessages.at(-1)?.content ?? "";
+      const chat = model.startChat({ history });
+      let totalInput = 0;
+      let totalOutput = 0;
+      for (let step = 0; step < maxSteps; step++) {
+        const result = await chat.sendMessageStream(lastMessage);
+        let pendingFunctionCall = null;
+        for await (const chunk of result.stream) {
+          const candidate = chunk.candidates?.[0];
+          if (!candidate) continue;
+          for (const part of candidate.content?.parts ?? []) {
+            if ("text" in part && part.text) {
+              emit(res, "strand:text-delta", { delta: part.text });
+            }
+            if ("functionCall" in part && part.functionCall) {
+              const fc = part.functionCall;
+              pendingFunctionCall = {
+                name: fc.name,
+                args: fc.args
+              };
+              const toolCallId2 = (0, import_core2.generateId)();
+              emit(res, "strand:tool-start", { toolCallId: toolCallId2, toolName: fc.name });
+              emit(res, "strand:tool-input-done", { toolCallId: toolCallId2, input: fc.args });
+            }
+          }
+          if (chunk.usageMetadata) {
+            totalInput = chunk.usageMetadata.promptTokenCount ?? totalInput;
+            totalOutput = chunk.usageMetadata.candidatesTokenCount ?? totalOutput;
+          }
+        }
+        const response = await result.response;
+        const finishReason = response.candidates?.[0]?.finishReason;
+        if (!pendingFunctionCall || finishReason === "STOP") {
+          emit(res, "strand:done", {
+            usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput }
+          });
+          res.end();
+          return;
+        }
+        const toolCallId = (0, import_core2.generateId)();
+        try {
+          const toolResult = await config.onToolCall?.(
+            pendingFunctionCall.name,
+            pendingFunctionCall.args,
+            { request: normalizedReq }
+          );
+          emit(res, "strand:tool-result", { toolCallId, result: toolResult });
+          await chat.sendMessageStream([{
+            functionResponse: {
+              name: pendingFunctionCall.name,
+              response: { result: toolResult }
+            }
+          }]);
+          continue;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Tool execution failed";
+          emit(res, "strand:tool-error", { toolCallId, error: message });
+          break;
+        }
+      }
+      emit(res, "strand:done", {
+        usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput }
+      });
+      res.end();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      emit(res, "strand:error", { code: "server_error", message });
+      res.end();
+    }
+  };
+}
+
+// src/route.ts
+var import_generative_ai2 = require("@google/generative-ai");
+var import_core3 = require("@strand-js/core");
+function sseChunk(eventType, data) {
+  return new TextEncoder().encode(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandRoute(config) {
+  const genAI = new import_generative_ai2.GoogleGenerativeAI(config.apiKey);
+  const googleTools = (config.tools ?? []).map(toolToGoogleTool);
+  const maxSteps = config.maxSteps ?? 10;
+  const rateLimiter = config.rateLimit ? new import_core3.RateLimiter(config.rateLimit) : null;
+  return async (req) => {
+    if (rateLimiter) {
+      const ip = req.headers.get("x-forwarded-for") ?? req.headers.get("x-real-ip") ?? "unknown";
+      const limited = rateLimiter.check(ip);
+      if (limited) {
+        return new Response(JSON.stringify({ error: "Too many requests", retryAfter: limited.retryAfter }), {
+          status: 429,
+          headers: { "Content-Type": "application/json", "Retry-After": String(limited.retryAfter) }
+        });
+      }
+    }
+    const body = await req.json();
+    const validation = (0, import_core3.validateMessages)(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      return new Response(JSON.stringify({ error: validation.error }), {
+        status: validation.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(req);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    const messages = body.messages;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const emit2 = (eventType, data) => controller.enqueue(sseChunk(eventType, data));
+        emit2("strand:start", { sessionId: (0, import_core3.generateId)(), requestId: (0, import_core3.generateId)() });
+        try {
+          const system = typeof config.system === "function" ? await config.system(req) : config.system ?? "";
+          const model = genAI.getGenerativeModel({
+            model: config.model,
+            ...system ? { systemInstruction: system } : {},
+            ...googleTools.length > 0 ? { tools: googleTools } : {}
+          });
+          const allMessages = messages.map((m) => ({
+            id: (0, import_core3.generateId)(),
+            role: m.role,
+            content: m.content,
+            createdAt: /* @__PURE__ */ new Date()
+          }));
+          const history = messagesToGoogleMessages(allMessages.slice(0, -1));
+          const lastMessage = allMessages.at(-1)?.content ?? "";
+          const chat = model.startChat({ history });
+          let totalInput = 0;
+          let totalOutput = 0;
+          for (let step = 0; step < maxSteps; step++) {
+            const result = await chat.sendMessageStream(lastMessage);
+            let pendingFunctionCall = null;
+            for await (const chunk of result.stream) {
+              const candidate = chunk.candidates?.[0];
+              if (!candidate) continue;
+              for (const part of candidate.content?.parts ?? []) {
+                if ("text" in part && part.text) emit2("strand:text-delta", { delta: part.text });
+                if ("functionCall" in part && part.functionCall) {
+                  const fc = part.functionCall;
+                  pendingFunctionCall = { name: fc.name, args: fc.args };
+                  const toolCallId2 = (0, import_core3.generateId)();
+                  emit2("strand:tool-start", { toolCallId: toolCallId2, toolName: fc.name });
+                  emit2("strand:tool-input-done", { toolCallId: toolCallId2, input: fc.args });
+                }
+              }
+              if (chunk.usageMetadata) {
+                totalInput = chunk.usageMetadata.promptTokenCount ?? totalInput;
+                totalOutput = chunk.usageMetadata.candidatesTokenCount ?? totalOutput;
+              }
+            }
+            const response = await result.response;
+            const finishReason = response.candidates?.[0]?.finishReason;
+            if (!pendingFunctionCall || finishReason === "STOP") {
+              emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+              break;
+            }
+            const toolCallId = (0, import_core3.generateId)();
+            try {
+              const toolResult = await config.onToolCall?.(pendingFunctionCall.name, pendingFunctionCall.args, { request: req });
+              emit2("strand:tool-result", { toolCallId, result: toolResult });
+              await chat.sendMessageStream([{ functionResponse: { name: pendingFunctionCall.name, response: { result: toolResult } } }]);
+              continue;
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "Tool execution failed";
+              emit2("strand:tool-error", { toolCallId, error: message });
+              break;
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          emit2("strand:error", { code: "server_error", message });
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStrandHandler,
+  createStrandRoute
+});

package/dist/index.mjs

@@ -0,0 +1,311 @@
+// src/handler.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { generateId, validateMessages, RateLimiter } from "@strand-js/core";
+
+// src/format.ts
+import { toolToJsonSchema } from "@strand-js/core";
+function toolToGoogleTool(tool) {
+  const schema = toolToJsonSchema(tool);
+  return {
+    functionDeclarations: [
+      {
+        name: tool.name,
+        description: tool.description,
+        parameters: schema
+      }
+    ]
+  };
+}
+function messagesToGoogleMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (!msg.content.trim() && !msg.toolCalls?.length) continue;
+    const role = msg.role === "assistant" ? "model" : "user";
+    const parts = [];
+    if (msg.content.trim()) {
+      parts.push({ text: msg.content });
+    }
+    for (const tc of msg.toolCalls ?? []) {
+      parts.push({
+        functionCall: { name: tc.name, args: tc.input }
+      });
+    }
+    const last = result.at(-1);
+    if (last && last.role === role) {
+      last.parts.push(...parts);
+    } else {
+      result.push({ role, parts });
+    }
+  }
+  return result;
+}
+
+// src/handler.ts
+function emit(res, eventType, data) {
+  res.write(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function normalizeRequest(req) {
+  const rawHeaders = req.headers ?? {};
+  return {
+    ...req,
+    headers: {
+      get: (name) => {
+        const val = rawHeaders[name.toLowerCase()];
+        return Array.isArray(val) ? val[0] ?? null : val ?? null;
+      }
+    }
+  };
+}
+function createStrandHandler(config) {
+  const genAI = new GoogleGenerativeAI(config.apiKey);
+  const googleTools = (config.tools ?? []).map(toolToGoogleTool);
+  const maxSteps = config.maxSteps ?? 10;
+  const rateLimiter = config.rateLimit ? new RateLimiter(config.rateLimit) : null;
+  return async (req, res) => {
+    const normalizedReq = normalizeRequest(req);
+    const body = req.body;
+    if (rateLimiter) {
+      const ip = req.ip ?? "unknown";
+      const limited = rateLimiter.check(ip);
+      if (limited) {
+        res.status(429).json({ error: "Too many requests", retryAfter: limited.retryAfter });
+        return;
+      }
+    }
+    const validation = validateMessages(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      res.status(validation.status).json({ error: validation.error });
+      return;
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(normalizedReq);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        res.status(401).json({ error: message });
+        return;
+      }
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    emit(res, "strand:start", { sessionId: generateId(), requestId: generateId() });
+    try {
+      const messages = body.messages;
+      const system = typeof config.system === "function" ? await config.system(normalizedReq) : config.system ?? "";
+      const model = genAI.getGenerativeModel({
+        model: config.model,
+        ...system ? { systemInstruction: system } : {},
+        ...googleTools.length > 0 ? { tools: googleTools } : {}
+      });
+      const allMessages = messages.map((m) => ({
+        id: generateId(),
+        role: m.role,
+        content: m.content,
+        createdAt: /* @__PURE__ */ new Date()
+      }));
+      const history = messagesToGoogleMessages(allMessages.slice(0, -1));
+      const lastMessage = allMessages.at(-1)?.content ?? "";
+      const chat = model.startChat({ history });
+      let totalInput = 0;
+      let totalOutput = 0;
+      for (let step = 0; step < maxSteps; step++) {
+        const result = await chat.sendMessageStream(lastMessage);
+        let pendingFunctionCall = null;
+        for await (const chunk of result.stream) {
+          const candidate = chunk.candidates?.[0];
+          if (!candidate) continue;
+          for (const part of candidate.content?.parts ?? []) {
+            if ("text" in part && part.text) {
+              emit(res, "strand:text-delta", { delta: part.text });
+            }
+            if ("functionCall" in part && part.functionCall) {
+              const fc = part.functionCall;
+              pendingFunctionCall = {
+                name: fc.name,
+                args: fc.args
+              };
+              const toolCallId2 = generateId();
+              emit(res, "strand:tool-start", { toolCallId: toolCallId2, toolName: fc.name });
+              emit(res, "strand:tool-input-done", { toolCallId: toolCallId2, input: fc.args });
+            }
+          }
+          if (chunk.usageMetadata) {
+            totalInput = chunk.usageMetadata.promptTokenCount ?? totalInput;
+            totalOutput = chunk.usageMetadata.candidatesTokenCount ?? totalOutput;
+          }
+        }
+        const response = await result.response;
+        const finishReason = response.candidates?.[0]?.finishReason;
+        if (!pendingFunctionCall || finishReason === "STOP") {
+          emit(res, "strand:done", {
+            usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput }
+          });
+          res.end();
+          return;
+        }
+        const toolCallId = generateId();
+        try {
+          const toolResult = await config.onToolCall?.(
+            pendingFunctionCall.name,
+            pendingFunctionCall.args,
+            { request: normalizedReq }
+          );
+          emit(res, "strand:tool-result", { toolCallId, result: toolResult });
+          await chat.sendMessageStream([{
+            functionResponse: {
+              name: pendingFunctionCall.name,
+              response: { result: toolResult }
+            }
+          }]);
+          continue;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Tool execution failed";
+          emit(res, "strand:tool-error", { toolCallId, error: message });
+          break;
+        }
+      }
+      emit(res, "strand:done", {
+        usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput }
+      });
+      res.end();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      emit(res, "strand:error", { code: "server_error", message });
+      res.end();
+    }
+  };
+}
+
+// src/route.ts
+import { GoogleGenerativeAI as GoogleGenerativeAI2 } from "@google/generative-ai";
+import { generateId as generateId2, validateMessages as validateMessages2, RateLimiter as RateLimiter2 } from "@strand-js/core";
+function sseChunk(eventType, data) {
+  return new TextEncoder().encode(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandRoute(config) {
+  const genAI = new GoogleGenerativeAI2(config.apiKey);
+  const googleTools = (config.tools ?? []).map(toolToGoogleTool);
+  const maxSteps = config.maxSteps ?? 10;
+  const rateLimiter = config.rateLimit ? new RateLimiter2(config.rateLimit) : null;
+  return async (req) => {
+    if (rateLimiter) {
+      const ip = req.headers.get("x-forwarded-for") ?? req.headers.get("x-real-ip") ?? "unknown";
+      const limited = rateLimiter.check(ip);
+      if (limited) {
+        return new Response(JSON.stringify({ error: "Too many requests", retryAfter: limited.retryAfter }), {
+          status: 429,
+          headers: { "Content-Type": "application/json", "Retry-After": String(limited.retryAfter) }
+        });
+      }
+    }
+    const body = await req.json();
+    const validation = validateMessages2(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      return new Response(JSON.stringify({ error: validation.error }), {
+        status: validation.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(req);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    const messages = body.messages;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const emit2 = (eventType, data) => controller.enqueue(sseChunk(eventType, data));
+        emit2("strand:start", { sessionId: generateId2(), requestId: generateId2() });
+        try {
+          const system = typeof config.system === "function" ? await config.system(req) : config.system ?? "";
+          const model = genAI.getGenerativeModel({
+            model: config.model,
+            ...system ? { systemInstruction: system } : {},
+            ...googleTools.length > 0 ? { tools: googleTools } : {}
+          });
+          const allMessages = messages.map((m) => ({
+            id: generateId2(),
+            role: m.role,
+            content: m.content,
+            createdAt: /* @__PURE__ */ new Date()
+          }));
+          const history = messagesToGoogleMessages(allMessages.slice(0, -1));
+          const lastMessage = allMessages.at(-1)?.content ?? "";
+          const chat = model.startChat({ history });
+          let totalInput = 0;
+          let totalOutput = 0;
+          for (let step = 0; step < maxSteps; step++) {
+            const result = await chat.sendMessageStream(lastMessage);
+            let pendingFunctionCall = null;
+            for await (const chunk of result.stream) {
+              const candidate = chunk.candidates?.[0];
+              if (!candidate) continue;
+              for (const part of candidate.content?.parts ?? []) {
+                if ("text" in part && part.text) emit2("strand:text-delta", { delta: part.text });
+                if ("functionCall" in part && part.functionCall) {
+                  const fc = part.functionCall;
+                  pendingFunctionCall = { name: fc.name, args: fc.args };
+                  const toolCallId2 = generateId2();
+                  emit2("strand:tool-start", { toolCallId: toolCallId2, toolName: fc.name });
+                  emit2("strand:tool-input-done", { toolCallId: toolCallId2, input: fc.args });
+                }
+              }
+              if (chunk.usageMetadata) {
+                totalInput = chunk.usageMetadata.promptTokenCount ?? totalInput;
+                totalOutput = chunk.usageMetadata.candidatesTokenCount ?? totalOutput;
+              }
+            }
+            const response = await result.response;
+            const finishReason = response.candidates?.[0]?.finishReason;
+            if (!pendingFunctionCall || finishReason === "STOP") {
+              emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+              break;
+            }
+            const toolCallId = generateId2();
+            try {
+              const toolResult = await config.onToolCall?.(pendingFunctionCall.name, pendingFunctionCall.args, { request: req });
+              emit2("strand:tool-result", { toolCallId, result: toolResult });
+              await chat.sendMessageStream([{ functionResponse: { name: pendingFunctionCall.name, response: { result: toolResult } } }]);
+              continue;
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "Tool execution failed";
+              emit2("strand:tool-error", { toolCallId, error: message });
+              break;
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          emit2("strand:error", { code: "server_error", message });
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" }
+    });
+  };
+}
+export {
+  createStrandHandler,
+  createStrandRoute
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@strand-js/google",
+  "version": "0.1.0",
+  "description": "Google Gemini provider adapter for Strand",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@google/generative-ai": "^0.24.0",
+    "@strand-js/core": "0.1.7"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8",
+    "zod": "^3.23.8"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src"
+  }
+}