@deepstrike/sdk 0.2.52 → 0.2.60

package/dist/providers/content-policy.js

@@ -0,0 +1,39 @@
+/**
+ * Provider serialization policy for canonical content. `bridge` means the protocol has no
+ * structured equivalent for that placement, but serializers may send the visible text projection.
+ * It never permits dropping a block or replacing it with an empty string.
+ */
+export function contentDispositionFor(protocol, modality, placement) {
+    if (modality === "text" || modality === "image") {
+        if (protocol === "ollama-chat" && modality === "image" && placement === "tool_result")
+            return "bridge";
+        return "native";
+    }
+    if (protocol === "openai-responses" && modality === "file" && placement === "message")
+        return "native";
+    if (protocol === "openai-responses" && modality === "file" && placement === "tool_result")
+        return "bridge";
+    if (protocol === "openai-chat" && ["audio", "file", "video"].includes(modality))
+        return "bridge";
+    if (protocol === "gemini" && ["audio", "file", "video"].includes(modality))
+        return "bridge";
+    return "unsupported";
+}
+export class ContentPolicyError extends Error {
+    protocol;
+    modality;
+    placement;
+    constructor(protocol, modality, placement) {
+        super(`Unsupported content policy: ${modality} ${placement} is not supported by ${protocol}`);
+        this.protocol = protocol;
+        this.modality = modality;
+        this.placement = placement;
+        this.name = "ContentPolicyError";
+    }
+}
+export function requireContentDisposition(protocol, modality, placement) {
+    const disposition = contentDispositionFor(protocol, modality, placement);
+    if (disposition === "unsupported")
+        throw new ContentPolicyError(protocol, modality, placement);
+    return disposition;
+}

package/dist/providers/credentials.d.ts

@@ -0,0 +1,83 @@
+import type { EndpointProfileId, EndpointProtocol, ProviderId } from "./endpoints.js";
+export type ProviderCredential = {
+    type: "api_key";
+    value: string;
+} | {
+    type: "bearer";
+    value: string;
+};
+export interface CredentialRequest {
+    providerId: ProviderId;
+    modelId: string;
+    endpointId: EndpointProfileId;
+    protocol: EndpointProtocol;
+}
+export type CredentialResolver = (request: CredentialRequest) => ProviderCredential | undefined | Promise<ProviderCredential | undefined>;
+export interface OAuthAccessToken {
+    accessToken: string;
+    /** Epoch time on the clock supplied to the resolver. The token is invalid at this instant. */
+    expiresAt: number;
+    scopes?: readonly string[];
+    audience?: string;
+}
+export interface OAuthRefreshRequest {
+    providerId: ProviderId;
+    audience?: string;
+    requiredScopes: readonly string[];
+}
+export interface OAuthCredentialResolverOptions {
+    providerId: ProviderId;
+    /** Provider-owned refresh/ADC bridge. The Host owns its transport and refresh token. */
+    refresh: (request: OAuthRefreshRequest) => OAuthAccessToken | Promise<OAuthAccessToken>;
+    requiredScopes?: readonly string[];
+    audience?: string;
+    clock?: () => number;
+}
+export interface CredentialOptions {
+    apiKey?: string;
+    bearerToken?: string;
+    credentialResolver?: CredentialResolver;
+}
+/** A deliberately non-sensitive credential failure. Never add resolver output to this error. */
+export declare class CredentialResolutionError extends Error {
+    readonly code: "credential_unavailable" | "credential_invalid" | "credential_resolver_failed" | "credential_refresh_failed" | "credential_oauth_scope_mismatch" | "credential_oauth_audience_mismatch" | "credential_revoked" | "credential_auth_mode_unsupported";
+    readonly providerId: ProviderId;
+    readonly retryable: boolean;
+    constructor(code: CredentialResolutionError["code"], providerId: ProviderId, retryable?: boolean);
+}
+/**
+ * Host-owned OAuth/ADC extension. It retains only a refreshable bearer in process memory,
+ * never exposes refresh-token material, and coalesces concurrent refreshes for one provider.
+ */
+export declare class OAuthCredentialResolver {
+    private readonly providerId;
+    private readonly refresh;
+    private readonly requiredScopes;
+    private readonly audience?;
+    private readonly clock;
+    private token?;
+    private refreshInFlight?;
+    private revoked;
+    constructor(options: OAuthCredentialResolverOptions);
+    /** An arrow field intentionally remains bound when passed as `credentialResolver`. */
+    readonly resolve: CredentialResolver;
+    revoke(): void;
+    status(): {
+        providerId: ProviderId;
+        revoked: boolean;
+        hasUsableToken: boolean;
+    };
+    private usable;
+    private refreshToken;
+    private assertUsable;
+}
+/** Safe for diagnostics and event metadata. It intentionally has no credential value. */
+export declare function redactCredential(credential: ProviderCredential): {
+    type: ProviderCredential["type"];
+};
+export declare function resolveCredential(request: CredentialRequest, options: CredentialOptions): Promise<ProviderCredential>;
+/**
+ * The synchronous factory remains synchronous. A resolver which performs I/O must use
+ * `resolveProviderRuntimeAsync` / `createProviderAsync` instead of risking an implicit request.
+ */
+export declare function resolveCredentialSync(request: CredentialRequest, options: CredentialOptions): ProviderCredential;

package/dist/providers/credentials.js

@@ -0,0 +1,190 @@
+/** A deliberately non-sensitive credential failure. Never add resolver output to this error. */
+export class CredentialResolutionError extends Error {
+    code;
+    providerId;
+    retryable;
+    constructor(code, providerId, retryable = false) {
+        super(messageForCredentialError(code, providerId));
+        this.name = "CredentialResolutionError";
+        this.code = code;
+        this.providerId = providerId;
+        this.retryable = retryable;
+    }
+}
+/**
+ * Host-owned OAuth/ADC extension. It retains only a refreshable bearer in process memory,
+ * never exposes refresh-token material, and coalesces concurrent refreshes for one provider.
+ */
+export class OAuthCredentialResolver {
+    providerId;
+    refresh;
+    requiredScopes;
+    audience;
+    clock;
+    token;
+    refreshInFlight;
+    revoked = false;
+    constructor(options) {
+        this.providerId = options.providerId;
+        this.refresh = options.refresh;
+        this.requiredScopes = [...(options.requiredScopes ?? [])];
+        this.audience = options.audience;
+        this.clock = options.clock ?? Date.now;
+    }
+    /** An arrow field intentionally remains bound when passed as `credentialResolver`. */
+    resolve = async (request) => {
+        if (request.providerId !== this.providerId)
+            throw unavailable(request.providerId);
+        if (this.revoked)
+            throw new CredentialResolutionError("credential_revoked", this.providerId);
+        const token = this.usable(this.token) ? this.token : await this.refreshToken();
+        this.assertUsable(token);
+        if (this.revoked)
+            throw new CredentialResolutionError("credential_revoked", this.providerId);
+        return { type: "bearer", value: token.accessToken };
+    };
+    revoke() {
+        this.revoked = true;
+        this.token = undefined;
+    }
+    status() {
+        return {
+            providerId: this.providerId,
+            revoked: this.revoked,
+            hasUsableToken: !this.revoked && this.usable(this.token),
+        };
+    }
+    usable(token) {
+        return token !== undefined && Number.isFinite(token.expiresAt) && token.expiresAt > this.clock();
+    }
+    async refreshToken() {
+        if (!this.refreshInFlight) {
+            this.refreshInFlight = Promise.resolve()
+                .then(() => this.refresh({
+                providerId: this.providerId,
+                ...(this.audience === undefined ? {} : { audience: this.audience }),
+                requiredScopes: this.requiredScopes,
+            }))
+                .then(token => {
+                this.assertUsable(token);
+                if (this.revoked)
+                    throw new CredentialResolutionError("credential_revoked", this.providerId);
+                this.token = token;
+                return token;
+            })
+                .catch(error => {
+                if (error instanceof CredentialResolutionError)
+                    throw error;
+                throw new CredentialResolutionError("credential_refresh_failed", this.providerId, true);
+            })
+                .finally(() => { this.refreshInFlight = undefined; });
+        }
+        return this.refreshInFlight;
+    }
+    assertUsable(token) {
+        if (!token
+            || typeof token.accessToken !== "string"
+            || token.accessToken.trim() === ""
+            || !Number.isFinite(token.expiresAt)
+            || token.expiresAt <= this.clock()) {
+            throw new CredentialResolutionError("credential_invalid", this.providerId);
+        }
+        if (this.audience !== undefined && token.audience !== this.audience) {
+            throw new CredentialResolutionError("credential_oauth_audience_mismatch", this.providerId);
+        }
+        const tokenScopes = new Set(token.scopes ?? []);
+        if (this.requiredScopes.some(scope => !tokenScopes.has(scope))) {
+            throw new CredentialResolutionError("credential_oauth_scope_mismatch", this.providerId);
+        }
+    }
+}
+/** Safe for diagnostics and event metadata. It intentionally has no credential value. */
+export function redactCredential(credential) {
+    return { type: credential.type };
+}
+export async function resolveCredential(request, options) {
+    const configured = configuredCredential(request.providerId, options);
+    if (configured)
+        return configured;
+    if (!options.credentialResolver)
+        throw unavailable(request.providerId);
+    let resolved;
+    try {
+        resolved = await options.credentialResolver(request);
+    }
+    catch (error) {
+        if (error instanceof CredentialResolutionError)
+            throw error;
+        throw new CredentialResolutionError("credential_resolver_failed", request.providerId);
+    }
+    return validateCredential(resolved, request.providerId);
+}
+/**
+ * The synchronous factory remains synchronous. A resolver which performs I/O must use
+ * `resolveProviderRuntimeAsync` / `createProviderAsync` instead of risking an implicit request.
+ */
+export function resolveCredentialSync(request, options) {
+    const configured = configuredCredential(request.providerId, options);
+    if (configured)
+        return configured;
+    if (!options.credentialResolver)
+        throw unavailable(request.providerId);
+    let resolved;
+    try {
+        resolved = options.credentialResolver(request);
+    }
+    catch (error) {
+        if (error instanceof CredentialResolutionError)
+            throw error;
+        throw new CredentialResolutionError("credential_resolver_failed", request.providerId);
+    }
+    if (isPromise(resolved)) {
+        throw new CredentialResolutionError("credential_resolver_failed", request.providerId);
+    }
+    return validateCredential(resolved, request.providerId);
+}
+function configuredCredential(providerId, options) {
+    const sources = [
+        options.apiKey === undefined ? undefined : { type: "api_key", value: options.apiKey },
+        options.bearerToken === undefined ? undefined : { type: "bearer", value: options.bearerToken },
+    ].filter((value) => value !== undefined);
+    if (sources.length > 1)
+        throw new CredentialResolutionError("credential_invalid", providerId);
+    return sources.length === 1 ? validateCredential(sources[0], providerId) : undefined;
+}
+function validateCredential(credential, providerId) {
+    if (!credential)
+        throw unavailable(providerId);
+    if ((credential.type !== "api_key" && credential.type !== "bearer")
+        || typeof credential.value !== "string"
+        || credential.value.trim() === "") {
+        throw new CredentialResolutionError("credential_invalid", providerId);
+    }
+    return credential;
+}
+function unavailable(providerId) {
+    return new CredentialResolutionError("credential_unavailable", providerId);
+}
+function messageForCredentialError(code, providerId) {
+    switch (code) {
+        case "credential_unavailable":
+            return `Missing credential for provider ${providerId}`;
+        case "credential_invalid":
+            return `Invalid credential for provider ${providerId}`;
+        case "credential_refresh_failed":
+            return `Credential refresh failed for provider ${providerId}`;
+        case "credential_oauth_scope_mismatch":
+            return `Credential scope does not satisfy provider ${providerId}`;
+        case "credential_oauth_audience_mismatch":
+            return `Credential audience does not match provider ${providerId}`;
+        case "credential_revoked":
+            return `Credential was revoked for provider ${providerId}`;
+        case "credential_auth_mode_unsupported":
+            return `Credential authentication mode is unsupported for provider ${providerId}`;
+        case "credential_resolver_failed":
+            return `Credential resolution failed for provider ${providerId}`;
+    }
+}
+function isPromise(value) {
+    return Boolean(value) && typeof value.then === "function";
+}

package/dist/providers/endpoints.d.ts

@@ -0,0 +1,137 @@
+export type ProviderId = "anthropic" | "openai" | "minimax" | "deepseek" | "kimi" | "qwen" | "gemini" | "glm" | "baai" | "ollama";
+export type EndpointProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "openai-embeddings" | "dashscope-multimodal-embeddings" | "gemini" | "gemini-embeddings" | "self-hosted-embeddings" | "ollama-chat";
+export interface EndpointProfile {
+    id: string;
+    providerId: ProviderId;
+    protocol: EndpointProtocol;
+    baseURL: string;
+}
+export declare const endpointProfiles: {
+    readonly "anthropic.messages": {
+        readonly id: "anthropic.messages";
+        readonly providerId: "anthropic";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.anthropic.com";
+    };
+    readonly "openai.chat": {
+        readonly id: "openai.chat";
+        readonly providerId: "openai";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "openai.responses": {
+        readonly id: "openai.responses";
+        readonly providerId: "openai";
+        readonly protocol: "openai-responses";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "openai.embeddings": {
+        readonly id: "openai.embeddings";
+        readonly providerId: "openai";
+        readonly protocol: "openai-embeddings";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "minimax.anthropic": {
+        readonly id: "minimax.anthropic";
+        readonly providerId: "minimax";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.minimaxi.com/anthropic";
+    };
+    readonly "minimax.openai": {
+        readonly id: "minimax.openai";
+        readonly providerId: "minimax";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.minimaxi.com/v1";
+    };
+    readonly "deepseek.anthropic": {
+        readonly id: "deepseek.anthropic";
+        readonly providerId: "deepseek";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.deepseek.com/anthropic";
+    };
+    readonly "deepseek.openai": {
+        readonly id: "deepseek.openai";
+        readonly providerId: "deepseek";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.deepseek.com";
+    };
+    readonly "kimi.anthropic": {
+        readonly id: "kimi.anthropic";
+        readonly providerId: "kimi";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.moonshot.cn/anthropic";
+    };
+    readonly "kimi.openai": {
+        readonly id: "kimi.openai";
+        readonly providerId: "kimi";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.moonshot.cn/v1";
+    };
+    readonly "qwen.anthropic": {
+        readonly id: "qwen.anthropic";
+        readonly providerId: "qwen";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://dashscope-intl.aliyuncs.com/apps/anthropic";
+    };
+    readonly "qwen.dashscope": {
+        readonly id: "qwen.dashscope";
+        readonly providerId: "qwen";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    };
+    readonly "qwen.dashscope.embeddings": {
+        readonly id: "qwen.dashscope.embeddings";
+        readonly providerId: "qwen";
+        readonly protocol: "openai-embeddings";
+        readonly baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    };
+    readonly "qwen.dashscope.multimodal-embeddings": {
+        readonly id: "qwen.dashscope.multimodal-embeddings";
+        readonly providerId: "qwen";
+        readonly protocol: "dashscope-multimodal-embeddings";
+        readonly baseURL: "https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding";
+    };
+    readonly "gemini.google": {
+        readonly id: "gemini.google";
+        readonly providerId: "gemini";
+        readonly protocol: "gemini";
+        readonly baseURL: "https://generativelanguage.googleapis.com";
+    };
+    readonly "gemini.google.embeddings": {
+        readonly id: "gemini.google.embeddings";
+        readonly providerId: "gemini";
+        readonly protocol: "gemini-embeddings";
+        readonly baseURL: "https://generativelanguage.googleapis.com";
+    };
+    readonly "glm.anthropic": {
+        readonly id: "glm.anthropic";
+        readonly providerId: "glm";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://open.bigmodel.cn/api/anthropic";
+    };
+    readonly "glm.openai": {
+        readonly id: "glm.openai";
+        readonly providerId: "glm";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://open.bigmodel.cn/api/paas/v4";
+    };
+    readonly "glm.openai.embeddings": {
+        readonly id: "glm.openai.embeddings";
+        readonly providerId: "glm";
+        readonly protocol: "openai-embeddings";
+        readonly baseURL: "https://open.bigmodel.cn/api/paas/v4";
+    };
+    readonly "baai.self-hosted.embeddings": {
+        readonly id: "baai.self-hosted.embeddings";
+        readonly providerId: "baai";
+        readonly protocol: "self-hosted-embeddings";
+        readonly baseURL: "https://huggingface.co/BAAI";
+    };
+    readonly "ollama.local": {
+        readonly id: "ollama.local";
+        readonly providerId: "ollama";
+        readonly protocol: "ollama-chat";
+        readonly baseURL: "http://localhost:11434";
+    };
+};
+export type EndpointProfileId = keyof typeof endpointProfiles;

package/dist/providers/endpoints.js

@@ -0,0 +1,128 @@
+export const endpointProfiles = {
+    "anthropic.messages": {
+        id: "anthropic.messages",
+        providerId: "anthropic",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.anthropic.com",
+    },
+    "openai.chat": {
+        id: "openai.chat",
+        providerId: "openai",
+        protocol: "openai-chat",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "openai.responses": {
+        id: "openai.responses",
+        providerId: "openai",
+        protocol: "openai-responses",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "openai.embeddings": {
+        id: "openai.embeddings",
+        providerId: "openai",
+        protocol: "openai-embeddings",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "minimax.anthropic": {
+        id: "minimax.anthropic",
+        providerId: "minimax",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.minimaxi.com/anthropic",
+    },
+    "minimax.openai": {
+        id: "minimax.openai",
+        providerId: "minimax",
+        protocol: "openai-chat",
+        baseURL: "https://api.minimaxi.com/v1",
+    },
+    "deepseek.anthropic": {
+        id: "deepseek.anthropic",
+        providerId: "deepseek",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.deepseek.com/anthropic",
+    },
+    "deepseek.openai": {
+        id: "deepseek.openai",
+        providerId: "deepseek",
+        protocol: "openai-chat",
+        baseURL: "https://api.deepseek.com",
+    },
+    "kimi.anthropic": {
+        id: "kimi.anthropic",
+        providerId: "kimi",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.moonshot.cn/anthropic",
+    },
+    "kimi.openai": {
+        id: "kimi.openai",
+        providerId: "kimi",
+        protocol: "openai-chat",
+        baseURL: "https://api.moonshot.cn/v1",
+    },
+    "qwen.anthropic": {
+        id: "qwen.anthropic",
+        providerId: "qwen",
+        protocol: "anthropic-messages",
+        baseURL: "https://dashscope-intl.aliyuncs.com/apps/anthropic",
+    },
+    "qwen.dashscope": {
+        id: "qwen.dashscope",
+        providerId: "qwen",
+        protocol: "openai-chat",
+        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    },
+    "qwen.dashscope.embeddings": {
+        id: "qwen.dashscope.embeddings",
+        providerId: "qwen",
+        protocol: "openai-embeddings",
+        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    },
+    "qwen.dashscope.multimodal-embeddings": {
+        id: "qwen.dashscope.multimodal-embeddings",
+        providerId: "qwen",
+        protocol: "dashscope-multimodal-embeddings",
+        baseURL: "https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding",
+    },
+    "gemini.google": {
+        id: "gemini.google",
+        providerId: "gemini",
+        protocol: "gemini",
+        baseURL: "https://generativelanguage.googleapis.com",
+    },
+    "gemini.google.embeddings": {
+        id: "gemini.google.embeddings",
+        providerId: "gemini",
+        protocol: "gemini-embeddings",
+        baseURL: "https://generativelanguage.googleapis.com",
+    },
+    "glm.anthropic": {
+        id: "glm.anthropic",
+        providerId: "glm",
+        protocol: "anthropic-messages",
+        baseURL: "https://open.bigmodel.cn/api/anthropic",
+    },
+    "glm.openai": {
+        id: "glm.openai",
+        providerId: "glm",
+        protocol: "openai-chat",
+        baseURL: "https://open.bigmodel.cn/api/paas/v4",
+    },
+    "glm.openai.embeddings": {
+        id: "glm.openai.embeddings",
+        providerId: "glm",
+        protocol: "openai-embeddings",
+        baseURL: "https://open.bigmodel.cn/api/paas/v4",
+    },
+    "baai.self-hosted.embeddings": {
+        id: "baai.self-hosted.embeddings",
+        providerId: "baai",
+        protocol: "self-hosted-embeddings",
+        baseURL: "https://huggingface.co/BAAI",
+    },
+    "ollama.local": {
+        id: "ollama.local",
+        providerId: "ollama",
+        protocol: "ollama-chat",
+        baseURL: "http://localhost:11434",
+    },
+};

package/dist/providers/factories.js

@@ -1,7 +1,11 @@
 import { PROVIDER_REGISTRY } from "./registry.js";
 import { OllamaProvider } from "./ollama.js";
+import { defaultModelForProvider, getRuntimePolicy, isKnownProviderId } from "./model-registry.js";
 function build(providerId, protocol, o) {
-    return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, o.model, o.retry, o.baseURL);
+    if (!isKnownProviderId(providerId))
+        throw new Error(`Unknown provider: ${providerId}`);
+    const model = o.model ?? defaultModelForProvider(providerId);
+    return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, model, o.retry, o.baseURL, getRuntimePolicy(providerId, model));
 }
 /** DeepSeek. Defaults to the OpenAI-compatible wire (richer reasoning-replay handling). */
 export function deepseek(o) {
@@ -25,9 +29,11 @@ export function minimax(o) {
 }
 /** Google Gemini (single wire). */
 export function gemini(o) {
-    return PROVIDER_REGISTRY["gemini:gemini"](o.apiKey, o.model, o.retry, o.baseURL);
+    const model = o.model ?? defaultModelForProvider("gemini");
+    return PROVIDER_REGISTRY["gemini:gemini"](o.apiKey, model, o.retry, o.baseURL, getRuntimePolicy("gemini", model));
 }
 /** Local Ollama (single wire, no API key). */
 export function ollama(o = {}) {
-    return new OllamaProvider(o.model, o.baseURL);
+    const model = o.model ?? defaultModelForProvider("ollama");
+    return new OllamaProvider(model, o.baseURL, getRuntimePolicy("ollama", model));
 }

package/dist/providers/gemini-adapter.d.ts

@@ -0,0 +1,33 @@
+import type { Content, GenerateContentRequest, GenerateContentResponse, ModelParams, Tool } from "@google/generative-ai";
+import type { Message, ProviderUsage } from "../types.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
+import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+export interface GeminiRequestPlan {
+    modelParams: ModelParams & Record<string, unknown>;
+    request: GenerateContentRequest;
+}
+export interface GeminiStreamState {
+    readonly input: CanonicalAdapterInput;
+    readonly toolCalls: Array<{
+        name: string;
+        args: Record<string, unknown>;
+    }>;
+}
+export declare function canonicalGeminiContents(context: CanonicalAdapterInput["context"]): Content[];
+export declare function geminiVendorConfig(extensions: Readonly<Record<string, unknown>>): {
+    tools?: Tool[];
+    generationConfig?: Record<string, unknown>;
+};
+export declare class GeminiAdapter implements ProtocolAdapter<GeminiRequestPlan, GenerateContentResponse, GenerateContentResponse, GeminiStreamState, GenerateContentResponse> {
+    readonly protocol: "gemini";
+    readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput): GeminiRequestPlan;
+    decodeComplete(raw: GenerateContentResponse, _input: AdapterDecodeInput): {
+        message: Message;
+    };
+    createStreamState(input: AdapterStreamInput): GeminiStreamState;
+    pushStreamChunk(chunk: GenerateContentResponse, state: GeminiStreamState): AdapterOutput;
+    finishStream(state: GeminiStreamState, final: GenerateContentResponse): AdapterOutput;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+}