@deepstrike/sdk 0.2.51 → 0.2.60

package/dist/providers/deepseek.d.ts

@@ -1,46 +0,0 @@
-import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { OpenAIChatProvider, type OpenAIChatTurnReasoning } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-/**
- * DeepSeek over its Anthropic-compatible endpoint.
- * @deprecated Prefer `deepseek({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.deepseek`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export declare class DeepSeekAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-}
-/**
- * DeepSeek over its OpenAI-compatible endpoint. Reasoning is carried out-of-band as
- * `reasoning_content`; replay persists DeepSeek's schema_version-2 envelope (with the
- * native `tool_calls` blocks). Request shaping (`reasoning_effort` + `extra_body.thinking`)
- * and replay are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
- * tool-call machinery is inherited from the base class.
- */
-export declare class DeepSeekProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-    runtimePolicy(): RuntimePolicy;
-    descriptor(): ProviderDescriptor;
-    protected requireNonEmptyReasoningReplayForToolTurns(extensions?: Record<string, unknown>): boolean;
-    protected cacheKeyParams(): Record<string, unknown>;
-    protected usesInlineThinkingTags(): boolean;
-    protected exposeReasoningDelta(extensions?: Record<string, unknown>): boolean;
-    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
-    protected rememberCompleteReplay(content: string, toolCalls: Array<{
-        id: string;
-        name: string;
-        arguments: string;
-    }>, r: OpenAIChatTurnReasoning): void;
-    protected rememberStreamReplay(content: string, toolCalls: Array<{
-        id: string;
-        name: string;
-        arguments: string;
-    }>, r: OpenAIChatTurnReasoning): void;
-    private rememberDeepSeekReplay;
-}

package/dist/providers/deepseek.js

@@ -1,97 +0,0 @@
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-import { endpointProfiles } from "./profiles.js";
-import { omitExtensionKeys } from "./base.js";
-import { DEEPSEEK_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
-/**
- * DeepSeek over its Anthropic-compatible endpoint.
- * @deprecated Prefer `deepseek({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.deepseek`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export class DeepSeekAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey, model, retry, baseURL) {
-        super(anthropicVendorProfiles.deepseek, apiKey, model, retry, baseURL);
-    }
-}
-/**
- * DeepSeek over its OpenAI-compatible endpoint. Reasoning is carried out-of-band as
- * `reasoning_content`; replay persists DeepSeek's schema_version-2 envelope (with the
- * native `tool_calls` blocks). Request shaping (`reasoning_effort` + `extra_body.thinking`)
- * and replay are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
- * tool-call machinery is inherited from the base class.
- */
-export class DeepSeekProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = endpointProfiles["deepseek.openai"].baseURL) {
-        super(apiKey, model, retry, baseURL);
-    }
-    runtimePolicy() {
-        return DEEPSEEK_POLICIES[this.model] ?? {};
-    }
-    descriptor() {
-        return {
-            provider: "deepseek",
-            protocol: "openai-chat",
-            model: this.model,
-            reasoning: {
-                supported: true,
-                preserveAcrossToolTurns: true,
-                requiresReplayForToolTurns: true,
-            },
-            toolCalls: {
-                supported: true,
-                requiresStrictPairing: true,
-            },
-        };
-    }
-    requireNonEmptyReasoningReplayForToolTurns(extensions) {
-        if (extensions?.__deepstrikeThinkingEnabled === false)
-            return false;
-        return extensions?.thinking !== false;
-    }
-    // DeepSeek strictly validates the request body and 400s on unknown params, so never send
-    // OpenAI's `prompt_cache_key` (DeepSeek auto prefix-caches anyway).
-    // Ref: https://api-docs.deepseek.com/quick_start/error_codes
-    cacheKeyParams() {
-        return {};
-    }
-    // Reasoning arrives out-of-band as `reasoning_content`, never as inline <thinking> tags.
-    usesInlineThinkingTags() {
-        return false;
-    }
-    exposeReasoningDelta(extensions) {
-        return (extensions?.exposeReasoning ?? false);
-    }
-    prepareExtensions(extensions) {
-        const thinking = extensions?.thinking === false ? "disabled" : "enabled";
-        const thinkingEnabled = thinking !== "disabled";
-        const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
-        return {
-            ...omitExtensionKeys(extensions, ["thinking", "reasoningEffort", "exposeReasoning", "extra_body", "reasoning_effort"]),
-            __deepstrikeThinkingEnabled: thinkingEnabled,
-            // Re-thread the degrade control flag (omitExtensionKeys strips internal keys) so
-            // buildChatMessages can honor it; the base requestExtensions omit keeps it off nothing.
-            ...(extensions?.degradeMissingReasoningReplay === true ? { degradeMissingReasoningReplay: true } : {}),
-            reasoning_effort: reasoningEffort,
-            extra_body: { thinking: { type: thinking } },
-        };
-    }
-    rememberCompleteReplay(content, toolCalls, r) {
-        this.rememberDeepSeekReplay(content, toolCalls, r.reasoningContent, r.nativeToolCalls);
-    }
-    rememberStreamReplay(content, toolCalls, r) {
-        this.rememberDeepSeekReplay(content, toolCalls, r.reasoningContent, r.nativeToolCalls);
-    }
-    rememberDeepSeekReplay(content, toolCalls, reasoningContent, nativeToolCalls) {
-        if (typeof reasoningContent !== "string" || !reasoningContent.trim())
-            return;
-        this.chat.rememberReplayFields({ content, toolCalls }, {
-            schema_version: 2,
-            provider: "deepseek",
-            protocol: "openai-chat",
-            model: this.model,
-            reasoning_content: reasoningContent,
-            ...(nativeToolCalls.length ? { tool_calls: nativeToolCalls } : {}),
-        });
-    }
-}

package/dist/providers/glm.d.ts

@@ -1,25 +0,0 @@
-import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-/**
- * GLM over its Anthropic-compatible endpoint.
- * @deprecated Prefer `glm({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.glm`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export declare class GLMAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-}
-export declare class GLMProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-    runtimePolicy(): RuntimePolicy;
-    descriptor(): ProviderDescriptor;
-    protected serverTools(extensions?: Record<string, unknown>): unknown[];
-    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown> | undefined;
-}

package/dist/providers/glm.js

@@ -1,48 +0,0 @@
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-import { endpointProfiles } from "./profiles.js";
-import { GLM_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
-/**
- * GLM over its Anthropic-compatible endpoint.
- * @deprecated Prefer `glm({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.glm`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export class GLMAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey, model, retry, baseURL) {
-        super(anthropicVendorProfiles.glm, apiKey, model, retry, baseURL);
-    }
-}
-export class GLMProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "glm-5.2", retry, baseURL = endpointProfiles["glm.openai"].baseURL) {
-        super(apiKey, model, retry, baseURL);
-    }
-    runtimePolicy() {
-        return GLM_POLICIES[this.model] ?? {};
-    }
-    descriptor() {
-        return {
-            ...super.descriptor(),
-            provider: "glm",
-            model: this.model,
-        };
-    }
-    // ── GLM web_search (Zhipu vendor server tool; OpenAI-wire only) ──────────────
-    // Enable with `extensions={ web_search: true }` (default config) or `{ web_search: {...} }`
-    // (passthrough: search_engine, search_recency_filter, search_domain_filter, count, …). Injected as a
-    // `{ type: "web_search", web_search: {...} }` entry in tools[]; the model searches server-side and
-    // the results come back inline (no client tool-loop). Mirrors the Python GLM provider.
-    serverTools(extensions) {
-        const ws = extensions?.web_search;
-        if (!ws)
-            return [];
-        return [{ type: "web_search", web_search: typeof ws === "object" ? ws : {} }];
-    }
-    // Strip `web_search` from the passthrough so it shapes tools[] only, never leaks as a body field.
-    prepareExtensions(extensions) {
-        if (!extensions || !("web_search" in extensions))
-            return extensions;
-        const { web_search: _omit, ...rest } = extensions;
-        return rest;
-    }
-}

package/dist/providers/kimi.d.ts

@@ -1,23 +0,0 @@
-import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-/**
- * Kimi over its Anthropic-compatible endpoint.
- * @deprecated Prefer `kimi({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.kimi`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export declare class KimiAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-}
-export declare class KimiProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-    runtimePolicy(): RuntimePolicy;
-    descriptor(): ProviderDescriptor;
-}

package/dist/providers/kimi.js

@@ -1,30 +0,0 @@
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-import { endpointProfiles } from "./profiles.js";
-import { KIMI_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
-/**
- * Kimi over its Anthropic-compatible endpoint.
- * @deprecated Prefer `kimi({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.kimi`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export class KimiAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey, model, retry, baseURL) {
-        super(anthropicVendorProfiles.kimi, apiKey, model, retry, baseURL);
-    }
-}
-export class KimiProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "kimi-k2.6", retry, baseURL = endpointProfiles["kimi.openai"].baseURL) {
-        super(apiKey, model, retry, baseURL);
-    }
-    runtimePolicy() {
-        return KIMI_POLICIES[this.model] ?? {};
-    }
-    descriptor() {
-        return {
-            ...super.descriptor(),
-            provider: "kimi",
-            model: this.model,
-        };
-    }
-}

package/dist/providers/minimax.d.ts

@@ -1,49 +0,0 @@
-import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { OpenAIChatProvider, type OpenAIChatTurnReasoning } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-/**
- * MiniMax over its Anthropic-compatible endpoint. Replay is carried as Anthropic
- * `native_blocks` (thinking/text/tool_use), identical to the first-party
- * Anthropic provider.
- * @deprecated Prefer `minimax({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.minimax`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export declare class MiniMaxAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-}
-/**
- * MiniMax over its OpenAI-compatible endpoint. Replay is carried as
- * `reasoning_content` / `reasoning_details` (split reasoning) in a schema_version-2
- * envelope; requests default to `reasoning_split: true` so reasoning is returned
- * out-of-band rather than embedded in the message content. Request shaping and replay
- * are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
- * tool-call machinery is inherited from the base class.
- */
-export declare class MiniMaxOpenAIProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-    runtimePolicy(): RuntimePolicy;
-    descriptor(): ProviderDescriptor;
-    protected requireNonEmptyReasoningReplayForToolTurns(extensions?: Record<string, unknown>): boolean;
-    protected cacheKeyParams(): Record<string, unknown>;
-    protected usesInlineThinkingTags(): boolean;
-    protected exposeReasoningDelta(extensions?: Record<string, unknown>): boolean;
-    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
-    protected rememberCompleteReplay(content: string, toolCalls: Array<{
-        id: string;
-        name: string;
-        arguments: string;
-    }>, r: OpenAIChatTurnReasoning): void;
-    protected rememberStreamReplay(content: string, toolCalls: Array<{
-        id: string;
-        name: string;
-        arguments: string;
-    }>, r: OpenAIChatTurnReasoning): void;
-    private rememberMiniMaxReplay;
-}

package/dist/providers/minimax.js

@@ -1,98 +0,0 @@
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-import { endpointProfiles } from "./profiles.js";
-import { omitExtensionKeys } from "./base.js";
-import { MINIMAX_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
-/**
- * MiniMax over its Anthropic-compatible endpoint. Replay is carried as Anthropic
- * `native_blocks` (thinking/text/tool_use), identical to the first-party
- * Anthropic provider.
- * @deprecated Prefer `minimax({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.minimax`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export class MiniMaxAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey, model, retry, baseURL) {
-        super(anthropicVendorProfiles.minimax, apiKey, model, retry, baseURL);
-    }
-}
-/**
- * MiniMax over its OpenAI-compatible endpoint. Replay is carried as
- * `reasoning_content` / `reasoning_details` (split reasoning) in a schema_version-2
- * envelope; requests default to `reasoning_split: true` so reasoning is returned
- * out-of-band rather than embedded in the message content. Request shaping and replay
- * are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
- * tool-call machinery is inherited from the base class.
- */
-export class MiniMaxOpenAIProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "MiniMax-M3", retry, baseURL = endpointProfiles["minimax.openai"].baseURL) {
-        super(apiKey, model, retry, baseURL);
-    }
-    runtimePolicy() {
-        return MINIMAX_POLICIES[this.model] ?? {};
-    }
-    descriptor() {
-        return {
-            provider: "minimax",
-            protocol: "openai-chat",
-            model: this.model,
-            reasoning: {
-                supported: true,
-                preserveAcrossToolTurns: true,
-                requiresReplayForToolTurns: true,
-            },
-            toolCalls: {
-                supported: true,
-                requiresStrictPairing: true,
-            },
-        };
-    }
-    requireNonEmptyReasoningReplayForToolTurns(extensions) {
-        if (extensions?.__deepstrikeThinkingEnabled === false)
-            return false;
-        return extensions?.reasoning_split !== false;
-    }
-    // MiniMax auto prefix-caches and does not accept OpenAI's `prompt_cache_key`; omit it.
-    cacheKeyParams() {
-        return {};
-    }
-    // Reasoning arrives out-of-band (reasoning_content / reasoning_details), never inline tags.
-    usesInlineThinkingTags() {
-        return false;
-    }
-    exposeReasoningDelta(extensions) {
-        return (extensions?.exposeReasoning ?? false);
-    }
-    prepareExtensions(extensions) {
-        const reasoningSplit = extensions?.reasoning_split !== false;
-        return {
-            ...omitExtensionKeys(extensions, ["reasoning_split", "exposeReasoning"]),
-            __deepstrikeThinkingEnabled: reasoningSplit,
-            // Re-thread the degrade control flag (omitExtensionKeys strips internal keys) so
-            // buildChatMessages can honor it; the wire-request omit drops it.
-            ...(extensions?.degradeMissingReasoningReplay === true ? { degradeMissingReasoningReplay: true } : {}),
-            reasoning_split: reasoningSplit,
-        };
-    }
-    rememberCompleteReplay(content, toolCalls, r) {
-        this.rememberMiniMaxReplay(content, toolCalls, r.reasoningContent, r.reasoningDetails, r.nativeToolCalls);
-    }
-    rememberStreamReplay(content, toolCalls, r) {
-        this.rememberMiniMaxReplay(content, toolCalls, r.reasoningContent, r.reasoningDetails, r.nativeToolCalls);
-    }
-    rememberMiniMaxReplay(content, toolCalls, reasoningContent, reasoningDetails, nativeToolCalls) {
-        const hasReasoning = typeof reasoningContent === "string" && reasoningContent.trim().length > 0;
-        const hasDetails = reasoningDetails !== undefined && reasoningDetails !== null;
-        if (!hasReasoning && !hasDetails)
-            return;
-        this.chat.rememberReplayFields({ content, toolCalls }, {
-            schema_version: 2,
-            provider: "minimax",
-            protocol: "openai-chat",
-            model: this.model,
-            ...(hasReasoning ? { reasoning_content: reasoningContent } : {}),
-            ...(hasDetails ? { reasoning_details: reasoningDetails } : {}),
-            ...(nativeToolCalls.length ? { tool_calls: nativeToolCalls } : {}),
-        });
-    }
-}