@capekai/core 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capekai/core",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Bun-native composable agent runtime and framework for Capek.",
   "license": "MIT",
   "repository": {
@@ -75,8 +75,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@ai-sdk/deepseek": "^2.0.35",
+    "@ai-sdk/anthropic": "^3.0.116",
     "@ai-sdk/openai": "^3.0.84",
+    "@ai-sdk/openai-compatible": "^2.0.74",
     "@capekai/tool": "^1.0.3",
     "@capekai/types": "^1.0.3",
     "@openrouter/ai-sdk-provider": "^2.3.3",
@@ -84,9 +85,7 @@
     "ai": "^6.0.116",
     "ignore": "^7.0.3",
     "picomatch": "^4.0.2",
-    "tar": "^7.5.13",
-    "vercel-minimax-ai-provider": "^0.0.2",
-    "zhipu-ai-provider": "^0.2.2"
+    "tar": "^7.5.13"
   },
   "scripts": {
     "build": "tsc --noEmit",

package/src/adapters/ai-sdk.ts

@@ -1,15 +1,16 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import {
+  wrapLanguageModel,
   dynamicTool,
   jsonSchema,
   streamText,
   type JSONSchema7,
-  type LanguageModel,
   type Tool,
 } from 'ai';
 import { getModelWithMetadata } from '../core/model-utils';
 import { openAiModelOmitsTemperature } from '../core/provider-utils';
 import type { ModelFactoryResult } from '../providers/types';
+import { codexNetworkRetryMiddleware } from './codex-network-retry';
 
 export interface TextModelRequest {
   modelId?: string;
@@ -55,7 +56,10 @@ export function createOpenAiResponsesModel(request: OpenAiResponsesModelRequest)
     fetch: request.fetch,
   });
   return {
-    model: openai.responses(request.modelId) as unknown as LanguageModel,
+    model: wrapLanguageModel({
+      model: openai.responses(request.modelId),
+      middleware: codexNetworkRetryMiddleware,
+    }),
     useProviderInstructions: true,
     omitMaxOutputTokens: true,
     omitTemperature: openAiModelOmitsTemperature(request.modelId),

package/src/adapters/codex-network-retry.ts

@@ -0,0 +1,25 @@
+import { APICallError, type LanguageModelMiddleware } from 'ai';
+import { ApiErrorType, classifyApiError } from '../utils/errors';
+
+export const codexNetworkRetryMiddleware: LanguageModelMiddleware = {
+  specificationVersion: 'v3',
+  wrapStream: async ({ doStream, params }) => {
+    try {
+      return await doStream();
+    } catch (error: unknown) {
+      if (params.abortSignal?.aborted || APICallError.isInstance(error)
+        || (error instanceof Error && error.name === 'AbortError')) throw error;
+      const classified = classifyApiError(error);
+      if (classified.type !== ApiErrorType.Network) throw error;
+      // OpenAI's early stream probe can throw a raw socket error. Normalize
+      // only before stream handoff so SDK retries this request, not prior tools.
+      throw new APICallError({
+        message: classified.message,
+        url: 'https://chatgpt.com/backend-api/codex/responses',
+        requestBodyValues: undefined,
+        cause: error,
+        isRetryable: true,
+      });
+    }
+  },
+};

package/src/core/agent.ts

@@ -144,7 +144,7 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<(Message
     selfDelegationAvailable,
   });
 
-  const { model, useProviderInstructions, omitMaxOutputTokens, omitTemperature, providerOptions: baseProviderOptions } =
+  const { model, replayReasoning, useProviderInstructions, omitMaxOutputTokens, omitTemperature, providerOptions: baseProviderOptions } =
     await getModelWithMetadata({
       modelId: resolvedModelId,
       providerId,
@@ -157,7 +157,7 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<(Message
 
   // Convert messages for ai-sdk
   const modelDef = resolvedModelId ? findModel(resolvedModelId) : undefined;
-  const aiMessages = await convertToAiSdkMessages(messages, modelDef?.capabilities);
+  const aiMessages = await convertToAiSdkMessages(messages, modelDef?.capabilities, { replayReasoning });
   if (options.continueFromCompaction) {
     // Execution instruction only: do not persist it as another user request.
     aiMessages.push({ role: 'user', content: 'Continue the existing task from the checkpoint above. Preserve completed work and tool outcomes; do not restart or repeat completed actions. Follow the remaining steps, or report completion if nothing remains.' });

package/src/core/message-utils.ts

@@ -47,6 +47,7 @@ async function resolveAttachmentPath(part: ImagePart | FilePart): Promise<{ abso
 export async function convertToAiSdkMessages(
   messages: MessageWithParts[],
   modelCapabilities?: ModelCapabilities,
+  options: { replayReasoning?: boolean } = {},
 ): Promise<ModelMessage[]> {
   const result: { role: 'user' | 'assistant' | 'system' | 'tool'; content: AiSdkContent }[] = [];
 
@@ -54,6 +55,11 @@ export async function convertToAiSdkMessages(
     const msg = msgWithParts.message;
     const parts = msgWithParts.parts;
 
+    const reasoningOptions = options.replayReasoning && msg.role === 'assistant'
+      ? { providerOptions: { openaiCompatible: {
+        reasoning_content: parts.filter((part) => part.type === 'reasoning').map((part) => part.text).join(''),
+      } } }
+      : {};
     const textBlocks: string[] = [];
     const toolCallBlocks: Array<{
       type: 'tool-call';
@@ -243,6 +249,7 @@ export async function convertToAiSdkMessages(
       result.push({
         role: hasCompactionTrigger ? 'user' : (msg.role as 'user' | 'assistant' | 'system'),
         content,
+        ...(!hasCompactionTrigger ? reasoningOptions : {}),
       });
       continue;
     }
@@ -250,6 +257,7 @@ export async function convertToAiSdkMessages(
     result.push({
       role: msg.role as 'user' | 'assistant' | 'system',
       content: contentParts,
+      ...reasoningOptions,
     });
 
     for (const toolResult of toolResultBlocks) {

package/src/core/model-utils.ts

@@ -7,6 +7,8 @@ import { isSandboxActive } from '../runtime/host-dependencies';
 
 export interface ModelWithMetadata {
   model: LanguageModel;
+  /** Replay stored reasoning only for adapters that accept unsigned reasoning text. */
+  replayReasoning?: boolean;
   useProviderInstructions?: boolean;
   omitMaxOutputTokens?: boolean;
   omitTemperature?: boolean;
@@ -97,34 +99,16 @@ export async function getModelWithMetadata(
       return { model: openrouter.chat(model) as unknown as LanguageModel };
     }
 
-    case 'minimax': {
-      const { createMinimax } = await import('vercel-minimax-ai-provider');
-      const minimax = createMinimax({ apiKey });
-      return { model: minimax.chat(model) as unknown as LanguageModel };
-    }
-
-    case 'zhipu': {
-      const { createZhipu } = await import('zhipu-ai-provider');
-      const zhipu = createZhipu({
-        apiKey,
-        baseURL: 'https://open.bigmodel.cn/api/paas/v4',
-      });
-      return { model: zhipu.chat(model) as unknown as LanguageModel };
-    }
-
+    case 'minimax':
+    case 'zhipu':
     case 'zhipu-coding': {
-      const { createZhipu } = await import('zhipu-ai-provider');
-      const zhipu = createZhipu({
-        apiKey,
-        baseURL: 'https://api.z.ai/api/coding/paas/v4',
-      });
-      return { model: zhipu.chat(model) as unknown as LanguageModel };
+      const { createProtocolModel } = await import('../providers/protocol-model');
+      return { model: createProtocolModel(provider, model, apiKey) };
     }
 
     case 'deepseek': {
-      const { createDeepSeek } = await import('@ai-sdk/deepseek');
-      const deepseek = createDeepSeek({ apiKey });
-      return { model: deepseek.chat(model) as unknown as LanguageModel };
+      const { createProtocolModel } = await import('../providers/protocol-model');
+      return { model: createProtocolModel(provider, model, apiKey), replayReasoning: true };
     }
 
     case 'openai':

package/src/core/stream/stream-config.ts

@@ -43,7 +43,11 @@ export function buildStreamConfig(options: StreamConfigOptions): StreamConfigRes
   // Determine the provider-specific providerOptions key
   const resolvedProvider = providerId || getModelsConfig().defaultProvider;
   const registered = resolvedProvider ? getProvider(resolvedProvider) : undefined;
-  const providerOptionsKey = registered?.descriptor.providerOptionsKey ?? resolvedProvider;
+  // Built-in MiniMax uses Anthropic's option namespace. Registered overrides
+  // retain their own namespace unless their descriptor explicitly changes it.
+  const providerOptionsKey = registered
+    ? registered.descriptor.providerOptionsKey ?? resolvedProvider
+    : resolvedProvider === 'minimax' ? 'anthropic' : resolvedProvider;
 
   // Build merged providerOptions
   let providerOptions: Record<string, Record<string, unknown>> | undefined;

package/src/providers/protocol-model.ts

@@ -0,0 +1,54 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { wrapLanguageModel, type LanguageModel } from 'ai';
+
+export type ProtocolProvider = 'minimax' | 'zhipu' | 'zhipu-coding' | 'deepseek';
+
+export function createProtocolModel(
+  providerId: ProtocolProvider,
+  modelId: string,
+  apiKey: string,
+  fetch?: NonNullable<Parameters<typeof createAnthropic>[0]>['fetch'],
+): LanguageModel {
+  if (providerId === 'minimax') {
+    return createAnthropic({ apiKey, baseURL: 'https://api.minimax.io/anthropic/v1', fetch })(modelId);
+  }
+  const model = createOpenAICompatible({
+    name: providerId,
+    apiKey,
+    baseURL: providerId === 'deepseek' ? 'https://api.deepseek.com/v1' : providerId === 'zhipu'
+      ? 'https://open.bigmodel.cn/api/paas/v4'
+      : 'https://api.z.ai/api/coding/paas/v4',
+    fetch,
+  })(modelId);
+  if (providerId !== 'deepseek') return model;
+  return wrapLanguageModel({
+    model,
+    middleware: {
+      specificationVersion: 'v3',
+      transformParams: async ({ params }) => ({
+        ...params,
+        prompt: params.prompt.map((message) => {
+          if (message.role !== 'assistant') return message;
+          const reasoning = message.content.filter((part) => part.type === 'reasoning');
+          const existing = message.providerOptions?.openaiCompatible?.reasoning_content;
+          return {
+            ...message,
+            content: message.content.filter((part) => part.type !== 'reasoning'),
+            providerOptions: {
+              ...message.providerOptions,
+              openaiCompatible: {
+                ...message.providerOptions?.openaiCompatible,
+                // The SDK omits empty reasoning by default. DeepSeek needs the field
+                // on tool continuations too, including SDK-generated assistant steps.
+                reasoning_content: reasoning.length > 0
+                  ? reasoning.map((part) => part.text).join('')
+                  : typeof existing === 'string' ? existing : '',
+              },
+            },
+          };
+        }),
+      }),
+    },
+  });
+}