@deepstrike/sdk 0.1.7 → 0.1.9

package/README.md

@@ -33,9 +33,9 @@ The correct platform package is selected and installed automatically via `option
 ## Quick start
 
 ```typescript
-import { Agent, OpenAIProvider, tool } from "@deepstrike/sdk"
+import { Agent, OpenAIResponsesProvider, tool } from "@deepstrike/sdk"
 
-const provider = new OpenAIProvider(process.env.OPENAI_API_KEY!, "gpt-5-mini")
+const provider = new OpenAIResponsesProvider(process.env.OPENAI_API_KEY!, "gpt-5-mini")
 
 const add = tool("add", "Add two numbers.", {
   type: "object",
@@ -67,16 +67,29 @@ for await (const event of agent.runStreaming("Summarize README.md")) {
 
 | Class | Backend | Notes |
 |-------|---------|-------|
-| `OpenAIProvider` | OpenAI API | SSE tool-call accumulation |
+| `OpenAIChatProvider` | OpenAI Chat Completions API | SSE tool-call accumulation |
+| `OpenAIProvider` | OpenAI Chat Completions API | Compatibility alias for `OpenAIChatProvider` |
+| `OpenAIResponsesProvider` | OpenAI Responses API | Native `previous_response_id` continuation |
 | `AnthropicProvider` | Anthropic API | Native SSE, `ThinkingDelta` support |
 | `QwenProvider` | DashScope | `enable_thinking` via extensions |
-| `DeepSeekProvider` | DeepSeek API | Reasoner models strip tools automatically |
-| `MiniMaxProvider` | MiniMax API | M1 reasoning via `expose_reasoning` |
+| `DeepSeekProvider` | DeepSeek API | V4 thinking controls + reasoning replay across tool turns |
+| `MiniMaxProvider` | MiniMax API | Anthropic-compatible M2.7/M2.5 path |
 | `OllamaProvider` | Local Ollama | `http://localhost:11434` default |
-| `KimiProvider` | Moonshot API | |
+| `KimiProvider` | Moonshot API | K2.6 default; K2.5 also supported |
 
 All providers accept `RetryConfig` for exponential backoff and share a `CircuitBreaker`.
 
+OpenAI can also be selected through the provider catalog:
+
+```typescript
+import { createProvider } from "@deepstrike/sdk"
+
+const provider = createProvider({
+  model: "openai/gpt-5-mini",
+  apiKey: process.env.OPENAI_API_KEY!,
+})
+```
+
 ---
 
 ## Agent options

package/dist/agent.js

@@ -62,6 +62,7 @@ export class Agent {
         }
         const kernel = getKernel();
         const ext = { ...this.extensions, ...(extensions ?? {}) };
+        const providerState = this.provider.createRunState?.();
         const sm = new kernel.LoopStateMachine({
             maxTokens: this.options.maxTokens,
             maxTurns: this.options.maxTurns ?? 25,
@@ -156,7 +157,7 @@ export class Agent {
                 const tools = (action.tools ?? []);
                 let turnTokens = 0;
                 try {
-                    for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined)) {
+                    for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
                         if (evt.type === "usage") {
                             turnTokens = evt.totalTokens;
                             continue;
@@ -330,7 +331,8 @@ export class Agent {
             throw new Error(`unexpected action after feedTrigger: ${action1.kind}`);
         }
         let synthesisText = "";
-        for await (const evt of this.provider.stream((action1.messages ?? []), [], undefined)) {
+        const providerState = this.provider.createRunState?.();
+        for await (const evt of this.provider.stream((action1.messages ?? []), [], undefined, providerState)) {
             if (evt.type === "text_delta")
                 synthesisText += evt.delta;
         }

package/dist/index.d.ts

@@ -1,9 +1,20 @@
 export { Agent } from "./agent.js";
 export type { AgentOptions } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { OpenAIChatProvider, OpenAIProvider } from "./providers/openai.js";
+export { DeepSeekProvider } from "./providers/deepseek.js";
+export { KimiProvider } from "./providers/kimi.js";
+export { QwenProvider } from "./providers/qwen.js";
+export { GeminiProvider } from "./providers/gemini.js";
+export { MiniMaxProvider } from "./providers/minimax.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
+export { OpenAIChatAdapter } from "./providers/openai-chat.js";
+export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
+export type { OpenAIResponsesRunState } from "./providers/openai-responses.js";
+export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
+export { createProvider } from "./providers/catalog.js";
+export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
@@ -20,4 +31,4 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export type { PermissionDecision, Permission } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, } from "./types.js";

package/dist/index.js

@@ -1,8 +1,17 @@
 export { Agent } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { OpenAIChatProvider, OpenAIProvider } from "./providers/openai.js";
+export { DeepSeekProvider } from "./providers/deepseek.js";
+export { KimiProvider } from "./providers/kimi.js";
+export { QwenProvider } from "./providers/qwen.js";
+export { GeminiProvider } from "./providers/gemini.js";
+export { MiniMaxProvider } from "./providers/minimax.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
+export { OpenAIChatAdapter } from "./providers/openai-chat.js";
+export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
+export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
+export { createProvider } from "./providers/catalog.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";

package/dist/providers/anthropic.d.ts

@@ -1,15 +1,24 @@
 import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+interface AnthropicProviderOptions {
+    baseURL?: string;
+    authMode?: "api-key" | "bearer";
+}
 export declare class AnthropicProvider implements LLMProvider {
-    private readonly model;
+    protected readonly model: string;
     private client;
     private circuit;
     private maxRetries;
     private baseDelay;
+    private nativeAssistantBlocks;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
-    });
+    }, options?: AnthropicProviderOptions);
     private buildTools;
     complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
     stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private buildMessages;
+    private rememberNativeBlocks;
+    private assistantReplayKey;
 }
+export {};

package/dist/providers/anthropic.js

@@ -1,14 +1,19 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { CircuitBreaker, normalizeToolCall, toAnthropicContent } from "./base.js";
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker, normalizeToolCall, splitAnthropicSystem, toAnthropicMessages } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
     circuit;
     maxRetries;
     baseDelay;
-    constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }) {
+    nativeAssistantBlocks = new Map();
+    constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }, options = {}) {
         this.model = model;
-        this.client = new Anthropic({ apiKey });
+        this.client = withServerRuntimeGuard(() => new Anthropic({
+            ...(options.authMode === "bearer" ? { authToken: apiKey } : { apiKey }),
+            ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+        }));
         this.circuit = new CircuitBreaker();
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
@@ -23,8 +28,8 @@ export class AnthropicProvider {
     async complete(messages, tools) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
+        const system = splitAnthropicSystem(messages);
+        const msgs = this.buildMessages(messages);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -47,7 +52,9 @@ export class AnthropicProvider {
                             toolCalls.push(tc);
                     }
                 }
-                return { role: "assistant", content, tokenCount: resp.usage.input_tokens + resp.usage.output_tokens, toolCalls };
+                const message = { role: "assistant", content, tokenCount: resp.usage.input_tokens + resp.usage.output_tokens, toolCalls };
+                this.rememberNativeBlocks(message, resp.content);
+                return message;
             }
             catch (err) {
                 lastErr = err;
@@ -59,9 +66,12 @@ export class AnthropicProvider {
         throw lastErr;
     }
     async *stream(messages, tools, extensions) {
-        const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
+        const system = splitAnthropicSystem(messages);
+        const msgs = this.buildMessages(messages);
         const toolBlocks = {};
+        const nativeBlocks = {};
+        let finalText = "";
+        const finalToolCalls = [];
         const stream = this.client.messages.stream({
             model: this.model,
             max_tokens: 8096,
@@ -70,17 +80,26 @@ export class AnthropicProvider {
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
         });
         for await (const evt of stream) {
-            if (evt.type === "content_block_start" && evt.content_block.type === "tool_use") {
-                toolBlocks[evt.index] = { id: evt.content_block.id, name: evt.content_block.name, argsBuf: "" };
+            if (evt.type === "content_block_start") {
+                nativeBlocks[evt.index] = { ...evt.content_block };
+                if (evt.content_block.type === "tool_use") {
+                    toolBlocks[evt.index] = { id: evt.content_block.id, name: evt.content_block.name, argsBuf: "" };
+                }
             }
             else if (evt.type === "content_block_delta") {
                 const d = evt.delta;
                 if (d.type === "text_delta") {
+                    finalText += d.text;
+                    nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], text: String(nativeBlocks[evt.index]?.text ?? "") + d.text };
                     yield { type: "text_delta", delta: d.text };
                 }
                 else if (d.type === "thinking_delta") {
+                    nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], thinking: String(nativeBlocks[evt.index]?.thinking ?? "") + d.thinking };
                     yield { type: "thinking_delta", delta: d.thinking };
                 }
+                else if (d.type === "signature_delta") {
+                    nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], signature: String(nativeBlocks[evt.index]?.signature ?? "") + d.signature };
+                }
                 else if (d.type === "input_json_delta" && toolBlocks[evt.index]) {
                     toolBlocks[evt.index].argsBuf += d.partial_json;
                 }
@@ -95,8 +114,25 @@ export class AnthropicProvider {
                 catch {
                     args = {};
                 }
+                nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], input: args };
+                finalToolCalls.push({ id: tb.id, name: tb.name, arguments: JSON.stringify(args) });
                 yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
             }
         }
+        this.rememberNativeBlocks({ content: finalText, toolCalls: finalToolCalls }, Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]));
+    }
+    buildMessages(messages) {
+        return toAnthropicMessages(messages, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
+    }
+    rememberNativeBlocks(message, blocks) {
+        if (!message.toolCalls?.length)
+            return;
+        this.nativeAssistantBlocks.set(this.assistantReplayKey(message), blocks);
+    }
+    assistantReplayKey(message) {
+        return JSON.stringify({
+            content: message.content,
+            toolCalls: message.toolCalls ?? [],
+        });
     }
 }

package/dist/providers/base.d.ts

@@ -16,3 +16,6 @@ export declare function normalizeToolCall(id: string, name: string, args: unknow
 import type { Message } from "../types.js";
 export declare function toAnthropicContent(msg: Message): string | Array<Record<string, unknown>>;
 export declare function toOpenAIContent(msg: Message): string | Array<Record<string, unknown>>;
+export declare function splitAnthropicSystem(messages: Message[]): string;
+export declare function toAnthropicMessages(messages: Message[], nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+export declare function toOpenAIMessageParams(messages: Message[]): Array<Record<string, unknown>>;

package/dist/providers/base.js

@@ -59,6 +59,9 @@ export function toAnthropicContent(msg) {
         if (p.type === "audio") {
             return { type: "text", text: `[audio: ${p.mediaType}]` };
         }
+        if (p.type === "tool_result") {
+            return { type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError };
+        }
         return { type: "text", text: "" };
     });
 }
@@ -75,6 +78,82 @@ export function toOpenAIContent(msg) {
         if (p.type === "audio") {
             return { type: "input_audio", input_audio: { data: p.data, format: p.mediaType?.split("/")[1] ?? "wav" } };
         }
+        if (p.type === "tool_result") {
+            return { type: "text", text: p.output };
+        }
         return { type: "text", text: "" };
     });
 }
+function parseToolArguments(args) {
+    try {
+        return JSON.parse(args || "{}");
+    }
+    catch {
+        return {};
+    }
+}
+export function splitAnthropicSystem(messages) {
+    return messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
+}
+export function toAnthropicMessages(messages, nativeReplay) {
+    const result = [];
+    for (const msg of messages.filter(m => m.role !== "system")) {
+        if (msg.role === "tool") {
+            const parts = (msg.contentParts ?? [])
+                .filter((p) => p.type === "tool_result")
+                .map(p => ({ type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError }));
+            if (parts.length)
+                result.push({ role: "user", content: parts });
+            continue;
+        }
+        if (msg.role === "assistant" && msg.toolCalls?.length) {
+            const replay = nativeReplay?.(msg);
+            if (replay) {
+                result.push({ role: "assistant", content: replay });
+                continue;
+            }
+            const blocks = [];
+            if (msg.content)
+                blocks.push({ type: "text", text: msg.content });
+            blocks.push(...msg.toolCalls.map(tc => ({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.name,
+                input: parseToolArguments(tc.arguments),
+            })));
+            result.push({ role: "assistant", content: blocks });
+            continue;
+        }
+        result.push({
+            role: msg.role,
+            content: toAnthropicContent(msg),
+        });
+    }
+    return result;
+}
+export function toOpenAIMessageParams(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === "tool") {
+            const parts = (msg.contentParts ?? [])
+                .filter((p) => p.type === "tool_result");
+            for (const p of parts) {
+                result.push({ role: "tool", tool_call_id: p.callId, content: p.output });
+            }
+            continue;
+        }
+        const next = {
+            role: msg.role,
+            content: toOpenAIContent(msg),
+        };
+        if (msg.role === "assistant" && msg.toolCalls?.length) {
+            next.tool_calls = msg.toolCalls.map(tc => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: tc.arguments },
+            }));
+        }
+        result.push(next);
+    }
+    return result;
+}

package/dist/providers/catalog.d.ts

@@ -0,0 +1,14 @@
+import type { LLMProvider } from "../types.js";
+import { endpointProfiles, type ModelProfileId } from "./profiles.js";
+export type EndpointProfileId = keyof typeof endpointProfiles;
+export interface CreateProviderOptions {
+    model: ModelProfileId;
+    apiKey: string;
+    endpoint?: EndpointProfileId;
+    retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    };
+    baseURL?: string;
+}
+export declare function createProvider(options: CreateProviderOptions): LLMProvider;

package/dist/providers/catalog.js

@@ -0,0 +1,45 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { DeepSeekProvider } from "./deepseek.js";
+import { KimiProvider } from "./kimi.js";
+import { OpenAIResponsesProvider } from "./openai-responses.js";
+import { MiniMaxProvider } from "./minimax.js";
+import { QwenProvider } from "./qwen.js";
+import { GeminiProvider } from "./gemini.js";
+import { endpointProfiles, getModelProfile } from "./profiles.js";
+export function createProvider(options) {
+    const profile = getModelProfile(options.model);
+    const endpointId = (options.endpoint ?? profile.defaultEndpointId);
+    const endpoint = endpointProfiles[endpointId];
+    if (!endpoint) {
+        throw new Error(`Unknown endpoint profile: ${endpointId}`);
+    }
+    if (endpoint.providerId !== profile.providerId) {
+        throw new Error(`Endpoint ${endpoint.id} does not belong to provider ${profile.providerId}`);
+    }
+    const model = options.model.slice(`${profile.providerId}/`.length);
+    const baseURL = options.baseURL ?? endpoint.baseURL;
+    if (profile.providerId === "openai") {
+        if (endpoint.protocol === "openai-chat") {
+            return new OpenAIChatProvider(options.apiKey, model, options.retry, baseURL);
+        }
+        if (endpoint.protocol === "openai-responses") {
+            return new OpenAIResponsesProvider(options.apiKey, model, options.retry, baseURL);
+        }
+    }
+    if (profile.providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
+        return new MiniMaxProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "deepseek" && endpoint.protocol === "openai-chat") {
+        return new DeepSeekProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "kimi" && endpoint.protocol === "openai-chat") {
+        return new KimiProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "qwen" && endpoint.protocol === "openai-chat") {
+        return new QwenProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "gemini" && endpoint.protocol === "gemini") {
+        return new GeminiProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    throw new Error(`No Node provider factory for ${profile.id} on ${endpoint.id}`);
+}

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,9 @@
+import type { Message, ToolSchema, StreamEvent } from "../types.js";
+import { OpenAIChatProvider } from "./openai.js";
+export declare class DeepSeekProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: "deepseek-v4-flash" | "deepseek-v4-pro", retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/deepseek.js

@@ -0,0 +1,64 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { endpointProfiles } from "./profiles.js";
+const DEEPSEEK_BASE = endpointProfiles["deepseek.openai"].baseURL;
+export class DeepSeekProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = DEEPSEEK_BASE) {
+        super(apiKey, model, retry, baseURL);
+    }
+    async *stream(messages, tools, extensions) {
+        const exposeReasoning = extensions?.exposeReasoning ?? false;
+        const thinking = extensions?.thinking === false ? "disabled" : "enabled";
+        const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
+        const msgs = this.chat.buildMessages(messages);
+        const toolCallBufs = {};
+        let reasoningContent = "";
+        let finalText = "";
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: msgs,
+            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
+            stream: true,
+            reasoning_effort: reasoningEffort,
+            extra_body: { thinking: { type: thinking } },
+        });
+        for await (const chunk of stream) {
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const delta = choice.delta;
+            if (exposeReasoning && delta.reasoning_content) {
+                yield { type: "thinking_delta", delta: delta.reasoning_content };
+            }
+            if (delta.reasoning_content)
+                reasoningContent += String(delta.reasoning_content);
+            if (delta.content) {
+                finalText += String(delta.content);
+                yield { type: "text_delta", delta: delta.content };
+            }
+            for (const tc of delta.tool_calls ?? []) {
+                const idx = tc.index;
+                if (!toolCallBufs[idx])
+                    toolCallBufs[idx] = { id: tc.id ?? "", name: "", argsBuf: "" };
+                if (tc.function?.name)
+                    toolCallBufs[idx].name += tc.function.name;
+                toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
+            }
+            if (choice.finish_reason === "tool_calls") {
+                const toolCalls = Object.values(toolCallBufs).map(tb => ({
+                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+                }));
+                this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
+                for (const tb of Object.values(toolCallBufs)) {
+                    let args = {};
+                    try {
+                        args = JSON.parse(tb.argsBuf || "{}");
+                    }
+                    catch {
+                        args = {};
+                    }
+                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+                }
+            }
+        }
+    }
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,14 @@
+import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+export declare class GeminiProvider implements LLMProvider {
+    private readonly model;
+    private genAI;
+    private circuit;
+    private maxRetries;
+    private baseDelay;
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/gemini.js

@@ -0,0 +1,142 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker, normalizeToolCall } from "./base.js";
+import { endpointProfiles } from "./profiles.js";
+const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
+function buildContents(messages) {
+    const contents = [];
+    for (const msg of messages) {
+        if (msg.role === "system")
+            continue;
+        if (msg.role === "tool") {
+            const parts = (msg.contentParts ?? [])
+                .filter(p => p.type === "tool_result")
+                .map(p => p.type === "tool_result" ? ({
+                functionResponse: { name: p.callId, response: { output: p.output } },
+            }) : ({ text: "" }));
+            if (parts.length)
+                contents.push({ role: "user", parts });
+            continue;
+        }
+        const role = msg.role === "assistant" ? "model" : "user";
+        const parts = [];
+        if (msg.toolCalls?.length) {
+            for (const tc of msg.toolCalls) {
+                let args = {};
+                try {
+                    args = JSON.parse(tc.arguments);
+                }
+                catch {
+                    args = {};
+                }
+                parts.push({ functionCall: { name: tc.name, args } });
+            }
+        }
+        if (msg.content)
+            parts.push({ text: msg.content });
+        if (parts.length)
+            contents.push({ role, parts });
+    }
+    return contents;
+}
+function buildTools(tools) {
+    if (!tools.length)
+        return [];
+    return [{
+            functionDeclarations: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                parameters: JSON.parse(t.parameters),
+            })),
+        }];
+}
+function systemInstruction(messages) {
+    return messages.find(m => m.role === "system")?.content;
+}
+export class GeminiProvider {
+    model;
+    genAI;
+    circuit;
+    maxRetries;
+    baseDelay;
+    constructor(apiKey, model = "gemini-2.0-flash", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = GEMINI_BASE) {
+        this.model = model;
+        this.genAI = withServerRuntimeGuard(() => new GoogleGenerativeAI(apiKey));
+        this.circuit = new CircuitBreaker();
+        this.maxRetries = retry.maxRetries;
+        this.baseDelay = retry.baseDelay;
+    }
+    async complete(messages, tools) {
+        if (this.circuit.isOpen())
+            throw new Error("Circuit breaker open");
+        const system = systemInstruction(messages);
+        const contents = buildContents(messages);
+        const geminiTools = buildTools(tools);
+        let lastErr;
+        for (let i = 0; i < this.maxRetries; i++) {
+            try {
+                const m = this.genAI.getGenerativeModel({
+                    model: this.model,
+                    ...(system ? { systemInstruction: system } : {}),
+                    ...(geminiTools.length ? { tools: geminiTools } : {}),
+                });
+                const resp = await m.generateContent({ contents });
+                this.circuit.recordSuccess();
+                const candidate = resp.response.candidates?.[0];
+                let content = "";
+                const toolCalls = [];
+                for (const part of candidate?.content.parts ?? []) {
+                    if (part.text)
+                        content += part.text;
+                    else if (part.functionCall) {
+                        const tc = normalizeToolCall(part.functionCall.name, part.functionCall.name, part.functionCall.args);
+                        if (tc)
+                            toolCalls.push(tc);
+                    }
+                }
+                const usage = resp.response.usageMetadata;
+                return {
+                    role: "assistant",
+                    content,
+                    tokenCount: usage?.totalTokenCount,
+                    toolCalls,
+                };
+            }
+            catch (err) {
+                lastErr = err;
+                this.circuit.recordFailure();
+                if (i < this.maxRetries - 1)
+                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
+            }
+        }
+        throw lastErr;
+    }
+    async *stream(messages, tools, extensions) {
+        const system = systemInstruction(messages);
+        const contents = buildContents(messages);
+        const geminiTools = buildTools(tools);
+        const m = this.genAI.getGenerativeModel({
+            model: this.model,
+            ...(system ? { systemInstruction: system } : {}),
+            ...(geminiTools.length ? { tools: geminiTools } : {}),
+        });
+        const result = await m.generateContentStream({ contents });
+        const toolCallBufs = {};
+        for await (const chunk of result.stream) {
+            for (const part of chunk.candidates?.[0]?.content.parts ?? []) {
+                if (part.text)
+                    yield { type: "text_delta", delta: part.text };
+                else if (part.functionCall) {
+                    const { name, args } = part.functionCall;
+                    toolCallBufs[name] = { name, args: args };
+                }
+            }
+        }
+        for (const [id, tc] of Object.entries(toolCallBufs)) {
+            yield { type: "tool_call", id, name: tc.name, arguments: tc.args };
+        }
+        const usage = (await result.response).usageMetadata;
+        if (usage?.totalTokenCount)
+            yield { type: "usage", totalTokens: usage.totalTokenCount };
+    }
+}