@kernl-sdk/ai 0.4.3 → 0.4.5

package/src/convert/__tests__/stream.test.ts

@@ -259,8 +259,8 @@ describe("STREAM_PART codec", () => {
         type: "stream-start",
         warnings: [
           {
-            type: "unsupported-setting",
-            setting: "topK",
+            type: "unsupported",
+            feature: "topK",
           },
         ],
       };
@@ -271,9 +271,8 @@ describe("STREAM_PART codec", () => {
         kind: "stream.start",
         warnings: [
           {
-            type: "unsupported-setting",
-            setting: "topK",
-            details: undefined,
+            type: "unsupported",
+            feature: "topK",
           },
         ],
       });
@@ -282,11 +281,10 @@ describe("STREAM_PART codec", () => {
     it("should decode finish event", () => {
       const part: LanguageModelV3StreamPart = {
         type: "finish",
-        finishReason: "stop",
+        finishReason: { unified: "stop", raw: "stop" },
         usage: {
-          inputTokens: 10,
-          outputTokens: 20,
-          totalTokens: 30,
+          inputTokens: { total: 10, noCache: 8, cacheRead: 2, cacheWrite: undefined },
+          outputTokens: { total: 20, text: 18, reasoning: 2 },
         },
         providerMetadata: undefined,
       };
@@ -295,13 +293,10 @@ describe("STREAM_PART codec", () => {
 
       expect(result).toEqual({
         kind: "finish",
-        finishReason: "stop",
+        finishReason: { unified: "stop", raw: "stop" },
         usage: {
-          inputTokens: 10,
-          outputTokens: 20,
-          totalTokens: 30,
-          reasoningTokens: undefined,
-          cachedInputTokens: undefined,
+          inputTokens: { total: 10, noCache: 8, cacheRead: 2, cacheWrite: undefined },
+          outputTokens: { total: 20, text: 18, reasoning: 2 },
         },
         providerMetadata: undefined,
       });
@@ -405,8 +400,11 @@ describe("convertStream", () => {
       { type: "text-end", id: "text-1", providerMetadata: undefined },
       {
         type: "finish",
-        finishReason: "stop",
-        usage: { inputTokens: 5, outputTokens: 10, totalTokens: 15 },
+        finishReason: { unified: "stop", raw: "stop" },
+        usage: {
+          inputTokens: { total: 5, noCache: 5, cacheRead: undefined, cacheWrite: undefined },
+          outputTokens: { total: 10, text: 10, reasoning: undefined },
+        },
         providerMetadata: undefined,
       },
     ];
@@ -429,7 +427,7 @@ describe("convertStream", () => {
     expect(events[0]).toMatchObject({ kind: "text.start" });
     expect(events[1]).toMatchObject({ kind: "text.delta", text: "Hello" });
     expect(events[2]).toMatchObject({ kind: "text.end" });
-    expect(events[3]).toMatchObject({ kind: "finish", finishReason: "stop" });
+    expect(events[3]).toMatchObject({ kind: "finish", finishReason: { unified: "stop", raw: "stop" } });
   });
 
   it("should filter out null events", async () => {
@@ -445,8 +443,11 @@ describe("convertStream", () => {
       } as any, // This should be filtered out (returns null from default case)
       {
         type: "finish",
-        finishReason: "stop",
-        usage: { inputTokens: 5, outputTokens: 10, totalTokens: 15 },
+        finishReason: { unified: "stop", raw: "stop" },
+        usage: {
+          inputTokens: { total: 5, noCache: 5, cacheRead: undefined, cacheWrite: undefined },
+          outputTokens: { total: 10, text: 10, reasoning: undefined },
+        },
         providerMetadata: undefined,
       },
     ];

package/src/convert/__tests__/tools.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import type {
   LanguageModelV3FunctionTool,
-  LanguageModelV3ProviderDefinedTool,
+  LanguageModelV3ProviderTool,
   LanguageModelV3ToolChoice,
 } from "@ai-sdk/provider";
 
@@ -96,8 +96,8 @@ describe("TOOL codec", () => {
     });
   });
 
-  describe("encode - provider-defined tools", () => {
-    it("should encode provider-defined tool", () => {
+  describe("encode - provider tools", () => {
+    it("should encode provider tool", () => {
       const result = TOOL.encode({
         kind: "provider-defined",
         id: "mcp.tool-123",
@@ -106,14 +106,14 @@ describe("TOOL codec", () => {
       });
 
       expect(result).toEqual({
-        type: "provider-defined",
+        type: "provider",
         id: "mcp.tool-123",
         name: "custom_mcp_tool",
         args: { param1: "value1" },
       });
     });
 
-    it("should encode provider-defined tool without args", () => {
+    it("should encode provider tool without args", () => {
       const result = TOOL.encode({
         kind: "provider-defined",
         id: "mcp.tool-id",
@@ -122,7 +122,7 @@ describe("TOOL codec", () => {
       });
 
       expect(result).toEqual({
-        type: "provider-defined",
+        type: "provider",
         id: "mcp.tool-id",
         name: "tool_name",
         args: {},

package/src/convert/__tests__/ui-stream.test.ts

@@ -274,11 +274,10 @@ describe("STREAM_UI_PART codec", () => {
     it("should encode finish event", () => {
       const event: LanguageModelStreamEvent = {
         kind: "finish",
-        finishReason: "stop",
+        finishReason: { unified: "stop", raw: "stop" },
         usage: {
-          inputTokens: 100,
-          outputTokens: 50,
-          totalTokens: 150,
+          inputTokens: { total: 100, noCache: 100, cacheRead: undefined, cacheWrite: undefined },
+          outputTokens: { total: 50, text: 50, reasoning: undefined },
         },
       };
 
@@ -421,7 +420,14 @@ describe("toUIMessageStream", () => {
       { kind: "text.delta", id: "text-1", text: "Hello" },
       { kind: "text.delta", id: "text-1", text: " world" },
       { kind: "text.end", id: "text-1" },
-      { kind: "finish", finishReason: "stop", usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 } },
+      {
+        kind: "finish",
+        finishReason: { unified: "stop", raw: "stop" },
+        usage: {
+          inputTokens: { total: 10, noCache: 10, cacheRead: undefined, cacheWrite: undefined },
+          outputTokens: { total: 5, text: 5, reasoning: undefined },
+        },
+      },
     ];
 
     async function* generateEvents() {

package/src/convert/response.ts

@@ -8,7 +8,7 @@ import {
   type LanguageModelResponseType,
   type LanguageModelFinishReason,
   type LanguageModelUsage,
-  type LanguageModelWarning,
+  type SharedWarning,
   type SharedProviderMetadata,
 } from "@kernl-sdk/protocol";
 import { randomID } from "@kernl-sdk/shared/lib";
@@ -16,7 +16,7 @@ import type {
   LanguageModelV3Content,
   LanguageModelV3FinishReason,
   LanguageModelV3Usage,
-  LanguageModelV3CallWarning,
+  SharedV3Warning,
   JSONSchema7,
 } from "@ai-sdk/provider";
 
@@ -28,7 +28,7 @@ export interface AISdkGenerateResult {
   finishReason: LanguageModelV3FinishReason;
   usage: LanguageModelV3Usage;
   providerMetadata?: Record<string, unknown>;
-  warnings: Array<LanguageModelV3CallWarning>;
+  warnings: Array<SharedV3Warning>;
 }
 
 export const MODEL_RESPONSE: Codec<LanguageModelResponse, AISdkGenerateResult> =
@@ -147,33 +147,12 @@ const USAGE: Codec<LanguageModelUsage, LanguageModelV3Usage> = {
   decode: (usage) => usage as LanguageModelUsage,
 };
 
-export const WARNING: Codec<LanguageModelWarning, LanguageModelV3CallWarning> =
-  {
-    encode: () => {
-      throw new Error("codec:unimplemented");
-    },
-
-    decode: (warning: LanguageModelV3CallWarning) => {
-      switch (warning.type) {
-        case "unsupported-setting":
-          return {
-            type: "unsupported-setting",
-            setting: warning.setting as any,
-            details: warning.details,
-          };
-        case "other":
-          return {
-            type: "other",
-            message: warning.message,
-          };
-        default:
-          return {
-            type: "other",
-            message: "Unknown warning type",
-          };
-      }
-    },
-  };
+export const WARNING: Codec<SharedWarning, SharedV3Warning> = {
+  encode: () => {
+    throw new Error("codec:unimplemented");
+  },
+  decode: (warning) => warning as SharedWarning,
+};
 
 /**
  * AI SDK response format type.

package/src/convert/stream.ts

@@ -147,13 +147,7 @@ export const STREAM_PART: Codec<
         return {
           kind: "finish",
           finishReason: part.finishReason as any, // Types should match
-          usage: {
-            inputTokens: part.usage.inputTokens,
-            outputTokens: part.usage.outputTokens,
-            totalTokens: part.usage.totalTokens,
-            reasoningTokens: part.usage.reasoningTokens,
-            cachedInputTokens: part.usage.cachedInputTokens,
-          },
+          usage: part.usage,
           providerMetadata: part.providerMetadata,
         };
 

package/src/convert/tools.ts

@@ -5,13 +5,13 @@ import type {
 } from "@kernl-sdk/protocol";
 import type {
   LanguageModelV3FunctionTool,
-  LanguageModelV3ProviderDefinedTool,
+  LanguageModelV3ProviderTool,
   LanguageModelV3ToolChoice,
 } from "@ai-sdk/provider";
 
 export const TOOL: Codec<
   LanguageModelTool,
-  LanguageModelV3FunctionTool | LanguageModelV3ProviderDefinedTool
+  LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
 > = {
   encode: (tool) => {
     if (tool.kind === "function") {
@@ -23,13 +23,13 @@ export const TOOL: Codec<
         providerOptions: tool.providerOptions,
       } satisfies LanguageModelV3FunctionTool;
     } else {
-      // provider-defined
+      // provider tool
       return {
-        type: "provider-defined",
+        type: "provider",
         id: tool.id,
         name: tool.name,
         args: tool.args,
-      } satisfies LanguageModelV3ProviderDefinedTool;
+      } satisfies LanguageModelV3ProviderTool;
     }
   },
   decode: () => {

package/src/embedding-model.ts

@@ -10,16 +10,14 @@ import { EMBEDDING_SETTINGS } from "./convert/embedding";
 /**
  * EmbeddingModel adapter for the AI SDK EmbeddingModelV3.
  */
-export class AISDKEmbeddingModel<TValue = string>
-  implements EmbeddingModel<TValue>
-{
+export class AISDKEmbeddingModel implements EmbeddingModel<string> {
   readonly spec = "1.0" as const;
   readonly provider: string;
   readonly modelId: string;
   readonly maxEmbeddingsPerCall?: number;
   readonly supportsParallelCalls?: boolean;
 
-  constructor(private model: EmbeddingModelV3<TValue>) {
+  constructor(private model: EmbeddingModelV3) {
     this.provider = model.provider;
     this.modelId = model.modelId;
 
@@ -33,7 +31,7 @@ export class AISDKEmbeddingModel<TValue = string>
   }
 
   async embed(
-    request: EmbeddingModelRequest<TValue>,
+    request: EmbeddingModelRequest<string>,
   ): Promise<EmbeddingModelResponse> {
     const settings = request.settings
       ? EMBEDDING_SETTINGS.encode(request.settings)

package/src/language-model.ts

@@ -3,6 +3,7 @@ import type { LanguageModelV3 } from "@ai-sdk/provider";
 import type {
   LanguageModel,
   LanguageModelRequest,
+  LanguageModelRequestSettings,
   LanguageModelResponse,
   LanguageModelStreamEvent,
 } from "@kernl-sdk/protocol";
@@ -23,7 +24,14 @@ export class AISDKLanguageModel implements LanguageModel {
   readonly provider: string;
   readonly modelId: string;
 
-  constructor(private model: LanguageModelV3) {
+  /**
+   * @param model - The underlying AI SDK model
+   * @param settings - Default settings to apply to every request (overridden by per-request settings)
+   */
+  constructor(
+    private model: LanguageModelV3,
+    private settings?: Partial<LanguageModelRequestSettings>,
+  ) {
     this.provider = normalizeProvider(model.provider);
     this.modelId = model.modelId;
   }
@@ -36,15 +44,16 @@ export class AISDKLanguageModel implements LanguageModel {
   ): Promise<LanguageModelResponse> {
     const messages = request.input.map(MESSAGE.encode);
     const tools = request.tools ? request.tools.map(TOOL.encode) : undefined;
-    const settings = MODEL_SETTINGS.encode(request.settings);
+    const merged = { ...this.settings, ...request.settings };
+    const settings = MODEL_SETTINGS.encode(merged);
     const responseFormat = RESPONSE_FORMAT.encode(request.responseType);
 
     const result = await this.model.doGenerate({
       prompt: messages,
       tools,
-      ...settings,
       responseFormat,
       abortSignal: request.abort,
+      ...settings,
     });
 
     return MODEL_RESPONSE.decode(result);
@@ -58,15 +67,16 @@ export class AISDKLanguageModel implements LanguageModel {
   ): AsyncIterable<LanguageModelStreamEvent> {
     const messages = request.input.map(MESSAGE.encode);
     const tools = request.tools ? request.tools.map(TOOL.encode) : undefined;
-    const settings = MODEL_SETTINGS.encode(request.settings);
+    const merged = { ...this.settings, ...request.settings };
+    const settings = MODEL_SETTINGS.encode(merged);
     const responseFormat = RESPONSE_FORMAT.encode(request.responseType);
 
     const stream = await this.model.doStream({
       prompt: messages,
       tools,
-      ...settings,
       responseFormat,
       abortSignal: request.abort,
+      ...settings,
     });
 
     // text + reasoning buffers for delta accumulation

package/src/oauth/openai.ts

@@ -0,0 +1,94 @@
+import type { OpenAIOAuthCredentials } from "./types";
+
+const TOKEN_URL = "https://auth.openai.com/oauth/token";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const CODEX_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+
+interface TokenResponse {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+}
+
+/**
+ * Refresh OpenAI OAuth tokens.
+ */
+async function refresh(creds: OpenAIOAuthCredentials): Promise<void> {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: creds.refreshToken,
+      client_id: CLIENT_ID,
+    }),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Token refresh failed: ${res.status}`);
+  }
+
+  const data = (await res.json()) as TokenResponse;
+
+  creds.accessToken = data.access_token;
+  creds.refreshToken = data.refresh_token;
+  creds.expiresAt = Date.now() + data.expires_in * 1000;
+
+  creds.onRefresh?.({
+    accessToken: creds.accessToken,
+    refreshToken: creds.refreshToken,
+    expiresAt: creds.expiresAt,
+  });
+}
+
+/**
+ * Create a fetch wrapper for OpenAI Codex OAuth.
+ *
+ * Redirects all requests to the Codex endpoint and adds OAuth headers.
+ */
+export function createOAuthFetch(creds: OpenAIOAuthCredentials) {
+  return async (
+    input: string | URL | Request,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    // Refresh if expired (with 30s buffer)
+    if (Date.now() >= creds.expiresAt - 30_000) {
+      await refresh(creds);
+    }
+
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${creds.accessToken}`);
+
+    if (creds.accountId) {
+      headers.set("ChatGPT-Account-Id", creds.accountId);
+    }
+
+    // Transform request body for Codex API
+    // Codex requires "instructions" field instead of developer/system role in input
+    let body = init?.body;
+    if (body && typeof body === "string") {
+      try {
+        const parsed = JSON.parse(body);
+
+        // Extract developer/system message as instructions
+        if (parsed.input && Array.isArray(parsed.input)) {
+          const devIdx = parsed.input.findIndex(
+            (m: Record<string, unknown>) =>
+              m.role === "developer" || m.role === "system",
+          );
+          if (devIdx !== -1) {
+            const devMsg = parsed.input[devIdx];
+            parsed.instructions = devMsg.content;
+            parsed.input.splice(devIdx, 1);
+          }
+        }
+
+        body = JSON.stringify(parsed);
+      } catch {
+        // ignore parse errors
+      }
+    }
+
+    return fetch(CODEX_ENDPOINT, { ...init, headers, body });
+  };
+}

package/src/oauth/types.ts

@@ -0,0 +1,25 @@
+/**
+ * Base OAuth credentials.
+ */
+export interface OAuthCredentials {
+  /** Current access token */
+  accessToken: string;
+  /** Refresh token for obtaining new access tokens */
+  refreshToken: string;
+  /** Expiration timestamp in milliseconds */
+  expiresAt: number;
+  /** Called when tokens are refreshed - use to persist new tokens */
+  onRefresh?: (tokens: {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+  }) => void;
+}
+
+/**
+ * OpenAI OAuth credentials (ChatGPT Plus/Pro via Codex).
+ */
+export interface OpenAIOAuthCredentials extends OAuthCredentials {
+  /** Account ID for org/team subscriptions */
+  accountId?: string;
+}

package/src/providers/anthropic.ts

@@ -1,29 +1,49 @@
-import { anthropic as _anthropic } from "@ai-sdk/anthropic";
+import {
+  anthropic as _anthropic,
+  createAnthropic as _createAnthropic,
+} from "@ai-sdk/anthropic";
 import { AISDKLanguageModel } from "../language-model";
 
 /**
- * Anthropic model IDs.
+ * Anthropic model IDs (derived from @ai-sdk/anthropic).
  */
-export type AnthropicModelId =
-  | "claude-haiku-4-5"
-  | "claude-haiku-4-5-20251001"
-  | "claude-sonnet-4-5"
-  | "claude-sonnet-4-5-20250929"
-  | "claude-opus-4-1"
-  | "claude-opus-4-0"
-  | "claude-sonnet-4-0"
-  | "claude-opus-4-1-20250805"
-  | "claude-opus-4-20250514"
-  | "claude-sonnet-4-20250514"
-  | "claude-3-7-sonnet-latest"
-  | "claude-3-7-sonnet-20250219"
-  | "claude-3-5-haiku-latest"
-  | "claude-3-5-haiku-20241022"
-  | "claude-3-haiku-20240307"
-  | (string & {});
+export type AnthropicModelId = Parameters<typeof _anthropic>[0];
+
+/**
+ * Options for creating a custom Anthropic provider.
+ */
+export interface AnthropicProviderOptions {
+  /** API key for authentication */
+  apiKey?: string;
+  /** Custom base URL */
+  baseURL?: string;
+  /** Custom headers */
+  headers?: Record<string, string>;
+}
+
+/**
+ * Create a custom Anthropic provider with explicit credentials.
+ *
+ * @example
+ * ```ts
+ * const anthropic = createAnthropic({ apiKey: "sk-..." });
+ * const model = anthropic("claude-sonnet-4-5");
+ * ```
+ */
+export function createAnthropic(options: AnthropicProviderOptions = {}) {
+  const provider = _createAnthropic({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL,
+    headers: options.headers,
+  });
+
+  return (modelId: AnthropicModelId) =>
+    new AISDKLanguageModel(provider(modelId));
+}
 
 /**
  * Create a kernl-compatible Anthropic language model.
+ * Uses ANTHROPIC_API_KEY environment variable.
  *
  * @example
  * ```ts

package/src/providers/google.ts

@@ -1,45 +1,12 @@
 import { google as _google } from "@ai-sdk/google";
+import { registerEmbeddingProvider } from "@kernl-sdk/retrieval";
 import { AISDKLanguageModel } from "../language-model";
 import { AISDKEmbeddingModel } from "../embedding-model";
-import { registerEmbeddingProvider } from "@kernl-sdk/retrieval";
 
 /**
- * Google Generative AI model IDs.
+ * Google model IDs (derived from @ai-sdk/google).
  */
-type GoogleGenerativeAIModelId =
-  | "gemini-1.5-flash"
-  | "gemini-1.5-flash-latest"
-  | "gemini-1.5-flash-001"
-  | "gemini-1.5-flash-002"
-  | "gemini-1.5-flash-8b"
-  | "gemini-1.5-flash-8b-latest"
-  | "gemini-1.5-flash-8b-001"
-  | "gemini-1.5-pro"
-  | "gemini-1.5-pro-latest"
-  | "gemini-1.5-pro-001"
-  | "gemini-1.5-pro-002"
-  | "gemini-2.0-flash"
-  | "gemini-2.0-flash-001"
-  | "gemini-2.0-flash-live-001"
-  | "gemini-2.0-flash-lite"
-  | "gemini-2.0-pro-exp-02-05"
-  | "gemini-2.0-flash-thinking-exp-01-21"
-  | "gemini-2.0-flash-exp"
-  | "gemini-2.5-pro"
-  | "gemini-2.5-flash"
-  | "gemini-2.5-flash-image-preview"
-  | "gemini-2.5-flash-lite"
-  | "gemini-2.5-flash-lite-preview-09-2025"
-  | "gemini-2.5-flash-preview-04-17"
-  | "gemini-2.5-flash-preview-09-2025"
-  | "gemini-pro-latest"
-  | "gemini-flash-latest"
-  | "gemini-flash-lite-latest"
-  | "gemini-2.5-pro-exp-03-25"
-  | "gemini-exp-1206"
-  | "gemma-3-12b-it"
-  | "gemma-3-27b-it"
-  | (string & {});
+export type GoogleModelId = Parameters<typeof _google>[0];
 
 /**
  * Create a kernl-compatible Google Generative AI language model.
@@ -52,7 +19,7 @@ type GoogleGenerativeAIModelId =
  * const response = await gemini.generate([...], {});
  * ```
  */
-export function google(modelId: GoogleGenerativeAIModelId) {
+export function google(modelId: GoogleModelId) {
   const model = _google(modelId);
   return new AISDKLanguageModel(model);
 }