@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/qwen.d.ts

@@ -1,38 +0,0 @@
-import type { Message, ProviderDescriptor, ProviderReplay, RuntimePolicy } from "../types.js";
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-/**
- * Qwen over its Anthropic-compatible endpoint.
- * @deprecated Prefer `qwen({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.qwen`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export declare class QwenAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-}
-/**
- * Qwen / DashScope over its OpenAI-compatible (DashScope) endpoint. Reasoning is carried
- * out-of-band as `reasoning_content`; thinking is opted into via `enable_thinking` /
- * `thinking_budget` (sent under `extra_body`). The streaming / tool-call machinery and the
- * default `{ reasoning_content }` replay are inherited from OpenAIChatProvider; only request
- * shaping and the (string-coerced) replay peek differ, supplied via the Template-Method hooks.
- */
-export declare class QwenProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
-    runtimePolicy(): RuntimePolicy;
-    descriptor(): ProviderDescriptor;
-    protected cacheKeyParams(): Record<string, unknown>;
-    protected usesInlineThinkingTags(): boolean;
-    protected requestBodyExtras(extensions?: Record<string, unknown>): Record<string, unknown>;
-    protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
-    private searchExtraBody;
-    peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
-    seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
-    private thinkingExtraBody;
-}

package/dist/providers/qwen.js

@@ -1,97 +0,0 @@
-import { OpenAIChatProvider } from "./openai.js";
-import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
-import { omitExtensionKeys } from "./base.js";
-import { endpointProfiles } from "./profiles.js";
-import { QWEN_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
-/**
- * Qwen over its Anthropic-compatible endpoint.
- * @deprecated Prefer `qwen({ protocol: "anthropic" })`. Behavior is now fully
- * data-driven via `anthropicVendorProfiles.qwen`; this thin shim is kept for
- * backward compatibility and `instanceof` checks.
- */
-export class QwenAnthropicProvider extends AnthropicCompatibleProvider {
-    constructor(apiKey, model, retry, baseURL) {
-        super(anthropicVendorProfiles.qwen, apiKey, model, retry, baseURL);
-    }
-}
-/**
- * Qwen / DashScope over its OpenAI-compatible (DashScope) endpoint. Reasoning is carried
- * out-of-band as `reasoning_content`; thinking is opted into via `enable_thinking` /
- * `thinking_budget` (sent under `extra_body`). The streaming / tool-call machinery and the
- * default `{ reasoning_content }` replay are inherited from OpenAIChatProvider; only request
- * shaping and the (string-coerced) replay peek differ, supplied via the Template-Method hooks.
- */
-export class QwenProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "qwen3.6-plus", retry, baseURL = endpointProfiles["qwen.dashscope"].baseURL) {
-        super(apiKey, model, retry, baseURL);
-    }
-    runtimePolicy() {
-        return QWEN_POLICIES[this.model] ?? {};
-    }
-    descriptor() {
-        return {
-            provider: "qwen",
-            protocol: "openai-chat",
-            model: this.model,
-            reasoning: {
-                supported: true,
-                preserveAcrossToolTurns: true,
-            },
-            toolCalls: {
-                supported: true,
-                requiresStrictPairing: true,
-            },
-        };
-    }
-    // DashScope auto prefix-caches and does not accept OpenAI's `prompt_cache_key`; omit it.
-    cacheKeyParams() {
-        return {};
-    }
-    // Reasoning arrives out-of-band as `reasoning_content`, never as inline <thinking> tags.
-    usesInlineThinkingTags() {
-        return false;
-    }
-    requestBodyExtras(extensions) {
-        // DashScope vendor knobs travel under `extra_body` in OpenAI-compat mode: thinking + web search.
-        const extraBody = { ...this.thinkingExtraBody(extensions), ...this.searchExtraBody(extensions) };
-        return Object.keys(extraBody).length ? { extra_body: extraBody } : {};
-    }
-    requestExtensions(extensions) {
-        return omitExtensionKeys(extensions, [
-            "model", "messages", "tools", "stream", "stream_options", "extra_body",
-            "enableThinking", "enable_thinking", "thinkingBudget", "thinking_budget",
-            "enable_search", "search_options",
-        ]);
-    }
-    // DashScope web search (Qwen vendor feature): `extensions={ enable_search: true }` + optional
-    // `search_options` (forced_search / search_strategy / enable_citation …). Mirrors the Python provider.
-    searchExtraBody(extensions) {
-        if (!extensions?.enable_search)
-            return {};
-        return {
-            enable_search: true,
-            ...(extensions.search_options != null ? { search_options: extensions.search_options } : {}),
-        };
-    }
-    peekProviderReplay(message) {
-        const fields = this.chat.peekReplayFields(message);
-        if (!fields || !("reasoning_content" in fields))
-            return undefined;
-        return { reasoning_content: String(fields.reasoning_content ?? "") };
-    }
-    seedProviderReplay(message, replay) {
-        if (replay.reasoning_content !== undefined) {
-            this.chat.rememberReplayFields(message, { reasoning_content: replay.reasoning_content });
-        }
-    }
-    thinkingExtraBody(extensions) {
-        const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);
-        const thinkingBudget = extensions?.thinkingBudget ?? extensions?.thinking_budget;
-        if (!enableThinking)
-            return undefined;
-        return {
-            enable_thinking: true,
-            ...(typeof thinkingBudget === "number" ? { thinking_budget: thinkingBudget } : {}),
-        };
-    }
-}