@deepstrike/sdk 0.2.31 → 0.2.33

package/dist/providers/gemini.d.ts

@@ -16,4 +16,16 @@ export declare class GeminiProvider implements LLMProvider {
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     private modelExtensions;
+    /**
+     * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
+     * extension keys for a consistent cross-SDK API):
+     *  - `google_search` (truthy → default, object → config): Google Search grounding server tool
+     *    (gemini-2.0+), appended to tools[].
+     *  - `response_mime_type` / `response_schema`: structured output → `generationConfig` (the API rejects
+     *    pairing this with google_search).
+     */
+    vendorConfig(extensions?: Record<string, unknown>): {
+        tools?: unknown[];
+        generationConfig?: Record<string, unknown>;
+    };
 }

package/dist/providers/gemini.js

@@ -116,11 +116,14 @@ export class GeminiProvider {
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
+                const vc = this.vendorConfig(extensions);
+                const allTools = [...geminiTools, ...(vc.tools ?? [])];
                 const m = this.genAI.getGenerativeModel({
                     ...this.modelExtensions(extensions),
                     model: this.model,
                     ...(system ? { systemInstruction: system } : {}),
-                    ...(geminiTools.length ? { tools: geminiTools } : {}),
+                    ...(allTools.length ? { tools: allTools } : {}),
+                    ...(vc.generationConfig ? { generationConfig: vc.generationConfig } : {}),
                 }, this.requestOptions);
                 const resp = await m.generateContent({ contents });
                 this.circuit.recordSuccess();
@@ -157,11 +160,14 @@ export class GeminiProvider {
         const system = context.systemText || undefined;
         const contents = buildContents(turnsWithStateAppended(context));
         const geminiTools = buildTools(tools);
+        const vc = this.vendorConfig(extensions);
+        const allTools = [...geminiTools, ...(vc.tools ?? [])];
         const m = this.genAI.getGenerativeModel({
             ...this.modelExtensions(extensions),
             model: this.model,
             ...(system ? { systemInstruction: system } : {}),
-            ...(geminiTools.length ? { tools: geminiTools } : {}),
+            ...(allTools.length ? { tools: allTools } : {}),
+            ...(vc.generationConfig ? { generationConfig: vc.generationConfig } : {}),
         }, this.requestOptions);
         const result = await m.generateContentStream({ contents });
         const toolCalls = [];
@@ -195,7 +201,36 @@ export class GeminiProvider {
     modelExtensions(extensions) {
         if (!extensions)
             return {};
-        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, ...rest } = extensions;
+        // Strip keys handled explicitly elsewhere (incl. the vendor server-tool / structured-output keys
+        // consumed by `vendorConfig`) so they never leak raw into getGenerativeModel.
+        // Strip keys handled explicitly: the SDK fields set below + the named vendor keys consumed by
+        // `vendorConfig`. A caller-provided raw `generationConfig` still passes through (and is merged with
+        // any structured-output config at the call site).
+        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, google_search: _gs, response_mime_type: _rmt, response_schema: _rs, ...rest } = extensions;
         return rest;
     }
+    /**
+     * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
+     * extension keys for a consistent cross-SDK API):
+     *  - `google_search` (truthy → default, object → config): Google Search grounding server tool
+     *    (gemini-2.0+), appended to tools[].
+     *  - `response_mime_type` / `response_schema`: structured output → `generationConfig` (the API rejects
+     *    pairing this with google_search).
+     */
+    vendorConfig(extensions) {
+        const ext = extensions ?? {};
+        const tools = [];
+        if (ext.google_search)
+            tools.push({ googleSearch: typeof ext.google_search === "object" ? ext.google_search : {} });
+        // Seed from any caller-provided raw generationConfig, then layer the named structured-output keys.
+        const gc = { ...ext.generationConfig };
+        if (ext.response_mime_type != null)
+            gc.responseMimeType = ext.response_mime_type;
+        if (ext.response_schema != null)
+            gc.responseSchema = ext.response_schema;
+        return {
+            ...(tools.length ? { tools } : {}),
+            ...(Object.keys(gc).length ? { generationConfig: gc } : {}),
+        };
+    }
 }

package/dist/providers/glm.d.ts

@@ -20,4 +20,6 @@ export declare class GLMProvider extends OpenAIChatProvider {
     }, 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

@@ -14,7 +14,7 @@ export class GLMAnthropicProvider extends AnthropicCompatibleProvider {
     }
 }
 export class GLMProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "glm-5.1", retry, baseURL = endpointProfiles["glm.openai"].baseURL) {
+    constructor(apiKey, model = "glm-5.2", retry, baseURL = endpointProfiles["glm.openai"].baseURL) {
         super(apiKey, model, retry, baseURL);
     }
     runtimePolicy() {
@@ -27,4 +27,22 @@ export class GLMProvider extends OpenAIChatProvider {
             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/minimax.js

@@ -25,7 +25,7 @@ export class MiniMaxAnthropicProvider extends AnthropicCompatibleProvider {
  * tool-call machinery is inherited from the base class.
  */
 export class MiniMaxOpenAIProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "MiniMax-M2.7", retry, baseURL = endpointProfiles["minimax.openai"].baseURL) {
+    constructor(apiKey, model = "MiniMax-M3", retry, baseURL = endpointProfiles["minimax.openai"].baseURL) {
         super(apiKey, model, retry, baseURL);
     }
     runtimePolicy() {

package/dist/providers/openai-responses.d.ts

@@ -40,5 +40,11 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
     private requestExtensions;
+    /** Responses API built-in server tools from extensions (live in the same tools[] as function tools):
+     *  `web_search: true` (or a config object), plus a `builtin_tools` list passed through verbatim for
+     *  file_search / code_interpreter. They run server-side; results return inline. Mirrors py. */
+    private builtinTools;
+    /** Function tools + built-in server tools merged into the wire tools[] (undefined when empty). */
+    private allTools;
     private asRunState;
 }

package/dist/providers/openai-responses.js

@@ -176,7 +176,7 @@ export class OpenAIResponsesProvider {
                     model: this.model,
                     input: this.responses.buildInput(context),
                     ...(instructions ? { instructions } : {}),
-                    ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
+                    ...((t => t ? { tools: t } : {})(this.allTools(tools, extensions))),
                 });
                 this.circuit.recordSuccess();
                 const decoded = this.responses.decodeOutput(resp.output);
@@ -206,7 +206,7 @@ export class OpenAIResponsesProvider {
             input: this.responses.buildInput(context, runState),
             ...(instructions ? { instructions } : {}),
             ...(runState.previousResponseId ? { previous_response_id: runState.previousResponseId } : {}),
-            ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
+            ...((t => t ? { tools: t } : {})(this.allTools(tools, extensions))),
             stream: true,
         });
         for await (const evt of stream) {
@@ -266,8 +266,28 @@ export class OpenAIResponsesProvider {
     requestExtensions(extensions) {
         return omitExtensionKeys(extensions, [
             "model", "input", "instructions", "tools", "stream", "previous_response_id",
+            "web_search", "builtin_tools",
         ]);
     }
+    /** Responses API built-in server tools from extensions (live in the same tools[] as function tools):
+     *  `web_search: true` (or a config object), plus a `builtin_tools` list passed through verbatim for
+     *  file_search / code_interpreter. They run server-side; results return inline. Mirrors py. */
+    builtinTools(extensions) {
+        const ext = extensions ?? {};
+        const out = [];
+        const ws = ext.web_search;
+        if (ws)
+            out.push(typeof ws === "object" ? { type: "web_search", ...ws } : { type: "web_search" });
+        if (Array.isArray(ext.builtin_tools))
+            out.push(...ext.builtin_tools);
+        return out;
+    }
+    /** Function tools + built-in server tools merged into the wire tools[] (undefined when empty). */
+    allTools(tools, extensions) {
+        const fnTools = tools.length ? this.responses.buildTools(tools) : [];
+        const all = [...fnTools, ...this.builtinTools(extensions)];
+        return all.length ? all : undefined;
+    }
     asRunState(state) {
         if (!state)
             return this.createRunState();

package/dist/providers/openai.d.ts

@@ -51,6 +51,15 @@ export declare class OpenAIChatProvider implements LLMProvider {
     /** Extra top-level request-body fields merged into the chat.completions call (vendor thinking
      *  knobs like `reasoning_effort`, `extra_body`, `reasoning_split`). Default: none. */
     protected requestBodyExtras(_extensions?: Record<string, unknown>): Record<string, unknown>;
+    /** Vendor server tools (e.g. web search) injected into the `tools[]` array alongside the function
+     *  tools, driven by caller `extensions`. These run server-side — the model invokes them and the
+     *  results come back inline, with no client tool-loop round-trip. Default: none. Vendors that ship
+     *  built-in tools (GLM web_search, …) override this and strip the consumed key in `prepareExtensions`
+     *  so it does not also leak into the request body. */
+    protected serverTools(_extensions?: Record<string, unknown>): unknown[];
+    /** Merge function tools + vendor server tools into the wire `tools[]` (undefined when empty). Server
+     *  tools (e.g. web_search) are non-standard wire entries, so the array is cast to the SDK tool type. */
+    protected assembleTools(tools: ToolSchema[], extensions?: Record<string, unknown>): OpenAI.Chat.Completions.ChatCompletionTool[] | undefined;
     /** Request-body params controlling prompt caching. Default sends OpenAI's `prompt_cache_key`;
      *  vendors whose endpoints reject unknown params (e.g. DeepSeek 400s) override to `{}`. */
     protected cacheKeyParams(context: RenderedContext, tools: ToolSchema[]): Record<string, unknown>;

package/dist/providers/openai.js

@@ -97,6 +97,21 @@ export class OpenAIChatProvider {
     requestBodyExtras(_extensions) {
         return {};
     }
+    /** Vendor server tools (e.g. web search) injected into the `tools[]` array alongside the function
+     *  tools, driven by caller `extensions`. These run server-side — the model invokes them and the
+     *  results come back inline, with no client tool-loop round-trip. Default: none. Vendors that ship
+     *  built-in tools (GLM web_search, …) override this and strip the consumed key in `prepareExtensions`
+     *  so it does not also leak into the request body. */
+    serverTools(_extensions) {
+        return [];
+    }
+    /** Merge function tools + vendor server tools into the wire `tools[]` (undefined when empty). Server
+     *  tools (e.g. web_search) are non-standard wire entries, so the array is cast to the SDK tool type. */
+    assembleTools(tools, extensions) {
+        const fnTools = tools.length ? this.chat.buildTools(tools) : [];
+        const all = [...fnTools, ...this.serverTools(extensions)];
+        return all.length ? all : undefined;
+    }
     /** Request-body params controlling prompt caching. Default sends OpenAI's `prompt_cache_key`;
      *  vendors whose endpoints reject unknown params (e.g. DeepSeek 400s) override to `{}`. */
     cacheKeyParams(context, tools) {
@@ -162,7 +177,7 @@ export class OpenAIChatProvider {
                     ...this.requestBodyExtras(extensions),
                     model: this.model,
                     messages: msgs,
-                    ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
+                    ...((t => t ? { tools: t } : {})(this.assembleTools(tools, extensions))),
                 });
                 this.circuit.recordSuccess();
                 const choice = resp.choices[0].message;
@@ -202,7 +217,7 @@ export class OpenAIChatProvider {
             ...this.requestBodyExtras(extensions),
             model: this.model,
             messages: msgs,
-            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
+            ...((t => t ? { tools: t } : {})(this.assembleTools(tools, extensions))),
             stream: true,
             stream_options: { include_usage: true },
             // #2-B-ii: forward the abort signal so a preempt cancels the in-flight HTTP request.

package/dist/providers/profiles.d.ts

@@ -81,7 +81,7 @@ export declare const endpointProfiles: {
         readonly id: "kimi.anthropic";
         readonly providerId: "kimi";
         readonly protocol: "anthropic-messages";
-        readonly baseURL: "https://api.moonshot.ai/anthropic";
+        readonly baseURL: "https://api.moonshot.cn/anthropic";
     };
     readonly "kimi.openai": {
         readonly id: "kimi.openai";
@@ -129,7 +129,7 @@ export declare const endpointProfiles: {
         readonly id: "glm.anthropic";
         readonly providerId: "glm";
         readonly protocol: "anthropic-messages";
-        readonly baseURL: "https://api.z.ai/api/anthropic";
+        readonly baseURL: "https://open.bigmodel.cn/api/anthropic";
     };
     readonly "glm.openai": {
         readonly id: "glm.openai";
@@ -729,6 +729,46 @@ export declare const modelProfiles: {
             readonly preserveAcrossToolTurns: false;
         };
     };
+    readonly "minimax/MiniMax-M3": {
+        readonly id: "minimax/MiniMax-M3";
+        readonly providerId: "minimax";
+        readonly defaultEndpointId: "minimax.anthropic";
+        readonly contextWindow: 204800;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+        readonly policy: {
+            readonly maxTurns: 35;
+        };
+    };
+    readonly "minimax/MiniMax-M3-highspeed": {
+        readonly id: "minimax/MiniMax-M3-highspeed";
+        readonly providerId: "minimax";
+        readonly defaultEndpointId: "minimax.anthropic";
+        readonly contextWindow: 204800;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+        readonly policy: {
+            readonly maxTurns: 35;
+        };
+    };
     readonly "minimax/MiniMax-M2.7": {
         readonly id: "minimax/MiniMax-M2.7";
         readonly providerId: "minimax";
@@ -1650,6 +1690,26 @@ export declare const modelProfiles: {
             readonly preserveAcrossToolTurns: false;
         };
     };
+    readonly "glm/glm-5.2": {
+        readonly id: "glm/glm-5.2";
+        readonly providerId: "glm";
+        readonly defaultEndpointId: "glm.anthropic";
+        readonly contextWindow: 200000;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+        readonly policy: {
+            readonly maxTurns: 50;
+        };
+    };
     readonly "glm/glm-5.1": {
         readonly id: "glm/glm-5.1";
         readonly providerId: "glm";

package/dist/providers/profiles.js

@@ -47,11 +47,17 @@ export const endpointProfiles = {
         protocol: "openai-chat",
         baseURL: "https://api.deepseek.com",
     },
+    // CN vendors (Kimi/GLM) are region-split: mainland (.cn hosts) and international (.ai/z.ai) are
+    // SEPARATE accounts with SEPARATE keys — a mainland key 401s on the international host & vice-versa.
+    // There is no `region` concept in this SDK: baseURL IS the host axis. These ids carry the DEFAULT =
+    // mainland (cn); international users pass their own `baseURL` (with their international key). Keeping
+    // both wires on the same region (cn) also fixes the prior split where openai=cn but anthropic=intl,
+    // which 401'd a mainland key on the default anthropic wire.
     "kimi.anthropic": {
         id: "kimi.anthropic",
         providerId: "kimi",
         protocol: "anthropic-messages",
-        baseURL: "https://api.moonshot.ai/anthropic",
+        baseURL: "https://api.moonshot.cn/anthropic",
     },
     "kimi.openai": {
         id: "kimi.openai",
@@ -99,7 +105,9 @@ export const endpointProfiles = {
         id: "glm.anthropic",
         providerId: "glm",
         protocol: "anthropic-messages",
-        baseURL: "https://api.z.ai/api/anthropic",
+        // Default = mainland (consistent with the already-mainland glm.openai). International: pass baseURL
+        // "https://api.z.ai/api/anthropic" with an international (z.ai) key.
+        baseURL: "https://open.bigmodel.cn/api/anthropic",
     },
     "glm.openai": {
         id: "glm.openai",
@@ -341,6 +349,21 @@ export const modelProfiles = {
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     // ── MiniMax ────────────────────────────────────────────────────────────────
+    "minimax/MiniMax-M3": {
+        id: "minimax/MiniMax-M3", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
+        contextWindow: 204_800,
+        // Natively multimodal — image input verified live via the Anthropic image-block path.
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 35 },
+    },
+    "minimax/MiniMax-M3-highspeed": {
+        id: "minimax/MiniMax-M3-highspeed", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
+        contextWindow: 204_800,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 35 },
+    },
     "minimax/MiniMax-M2.7": {
         id: "minimax/MiniMax-M2.7", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
         contextWindow: 204_800,
@@ -668,6 +691,13 @@ export const modelProfiles = {
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     // ── GLM ────────────────────────────────────────────────────────────────────
+    "glm/glm-5.2": {
+        id: "glm/glm-5.2", providerId: "glm", defaultEndpointId: "glm.anthropic",
+        contextWindow: 200_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
+    },
     "glm/glm-5.1": {
         id: "glm/glm-5.1", providerId: "glm", defaultEndpointId: "glm.anthropic",
         contextWindow: 200_000,

package/dist/providers/qwen.d.ts

@@ -31,6 +31,7 @@ export declare class QwenProvider extends OpenAIChatProvider {
     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

@@ -52,15 +52,27 @@ export class QwenProvider extends OpenAIChatProvider {
         return false;
     }
     requestBodyExtras(extensions) {
-        const extraBody = this.thinkingExtraBody(extensions);
-        return extraBody ? { extra_body: extraBody } : {};
+        // 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))

package/dist/providers/vendor-profiles.js

@@ -30,6 +30,8 @@ export const QWEN_POLICIES = {
     "qwen3.5-27b": { maxTurns: 20 },
 };
 export const GLM_POLICIES = {
+    "glm-5.2": { maxTurns: 50 },
+    "glm/glm-5.2": { maxTurns: 50 },
     "glm-5.1": { maxTurns: 50 },
     "glm/glm-5.1": { maxTurns: 50 },
     "glm-4-plus": { maxTurns: 35 },
@@ -40,6 +42,8 @@ export const GLM_POLICIES = {
     "glm/glm-4-air": { maxTurns: 20 },
 };
 export const MINIMAX_POLICIES = {
+    "MiniMax-M3": { maxTurns: 35 },
+    "MiniMax-M3-highspeed": { maxTurns: 35 },
     "MiniMax-M2.7": { maxTurns: 35 },
     "MiniMax-M2.7-highspeed": { maxTurns: 35 },
     "MiniMax-M2.5": { maxTurns: 25 },
@@ -53,8 +57,8 @@ export const anthropicVendorProfiles = {
     deepseek: { providerId: "deepseek", defaultModel: "deepseek-v4-flash", baseURLProfileKey: "deepseek.anthropic", policies: DEEPSEEK_POLICIES },
     kimi: { providerId: "kimi", defaultModel: "kimi-k2.6", baseURLProfileKey: "kimi.anthropic", policies: KIMI_POLICIES },
     qwen: { providerId: "qwen", defaultModel: "qwen3.6-plus", baseURLProfileKey: "qwen.anthropic", policies: QWEN_POLICIES },
-    glm: { providerId: "glm", defaultModel: "glm-5.1", baseURLProfileKey: "glm.anthropic", policies: GLM_POLICIES },
-    minimax: { providerId: "minimax", defaultModel: "MiniMax-M2.7", baseURLProfileKey: "minimax.anthropic", policies: MINIMAX_POLICIES },
+    glm: { providerId: "glm", defaultModel: "glm-5.2", baseURLProfileKey: "glm.anthropic", policies: GLM_POLICIES },
+    minimax: { providerId: "minimax", defaultModel: "MiniMax-M3", baseURLProfileKey: "minimax.anthropic", policies: MINIMAX_POLICIES },
 };
 /** Resolve the Anthropic-compatible base URL for a vendor profile. */
 export function anthropicVendorBaseURL(profile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.31",
+  "version": "0.2.33",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -72,7 +72,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.31",
+    "@deepstrike/core": "0.2.33",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },