@kernl-sdk/ai 0.4.2 → 0.4.4

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

@@ -1,51 +1,53 @@
 import { describe, it, expect } from "vitest";
-import type { LanguageModelV3CallWarning } from "@ai-sdk/provider";
+import type { SharedV3Warning } from "@ai-sdk/provider";
 
 import { WARNING } from "../response";
 
 describe("WARNING codec", () => {
   describe("decode", () => {
-    it("should decode unsupported-setting warning", () => {
-      const aiWarning: LanguageModelV3CallWarning = {
-        type: "unsupported-setting",
-        setting: "someUnsupportedSetting",
-        details: "This setting is not supported by the provider",
+    it("should decode unsupported warning", () => {
+      const aiWarning: SharedV3Warning = {
+        type: "unsupported",
+        feature: "someUnsupportedFeature",
+        details: "This feature is not supported by the provider",
       };
 
       const result = WARNING.decode(aiWarning);
 
       expect(result).toEqual({
-        type: "unsupported-setting",
-        setting: "someUnsupportedSetting",
-        details: "This setting is not supported by the provider",
+        type: "unsupported",
+        feature: "someUnsupportedFeature",
+        details: "This feature is not supported by the provider",
       });
     });
 
-    it("should decode other warning", () => {
-      const aiWarning: LanguageModelV3CallWarning = {
-        type: "other",
-        message: "Some custom warning message",
+    it("should decode compatibility warning", () => {
+      const aiWarning: SharedV3Warning = {
+        type: "compatibility",
+        feature: "someFeature",
+        details: "Running in compatibility mode",
       };
 
       const result = WARNING.decode(aiWarning);
 
       expect(result).toEqual({
-        type: "other",
-        message: "Some custom warning message",
+        type: "compatibility",
+        feature: "someFeature",
+        details: "Running in compatibility mode",
       });
     });
 
-    it("should handle unknown warning type", () => {
-      const aiWarning = {
-        type: "unknown-type",
-        someField: "value",
-      } as any;
+    it("should decode other warning", () => {
+      const aiWarning: SharedV3Warning = {
+        type: "other",
+        message: "Some custom warning message",
+      };
 
       const result = WARNING.decode(aiWarning);
 
       expect(result).toEqual({
         type: "other",
-        message: "Unknown warning type",
+        message: "Some custom warning message",
       });
     });
   });

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/oauth/anthropic.ts

@@ -0,0 +1,87 @@
+import { appendFileSync } from "node:fs";
+import type { OAuthCredentials } from "./types";
+
+const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+function debug(msg: string) {
+  try {
+    appendFileSync("/tmp/popcorn-debug.log", `${new Date().toISOString()} [oauth/anthropic] ${msg}\n`);
+  } catch {
+    // ignore
+  }
+}
+
+interface TokenResponse {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+}
+
+/**
+ * Refresh Anthropic OAuth tokens.
+ */
+async function refresh(creds: OAuthCredentials): Promise<void> {
+  debug(`Refreshing token...`);
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      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,
+  });
+  debug(`Token refreshed successfully`);
+}
+
+/**
+ * Create a fetch wrapper for Anthropic OAuth.
+ *
+ * Uses the standard Anthropic API with OAuth bearer token.
+ */
+export function createOAuthFetch(creds: OAuthCredentials) {
+  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}`);
+    // Required beta header for OAuth
+    headers.set("anthropic-beta", "oauth-2025-04-20");
+
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    debug(`Request to: ${url}`);
+
+    const response = await fetch(input, { ...init, headers });
+
+    debug(`Response status: ${response.status}`);
+    if (!response.ok) {
+      const text = await response.clone().text();
+      debug(`Error response: ${text.slice(0, 1000)}`);
+    }
+
+    return response;
+  };
+}

package/src/oauth/openai.ts

@@ -0,0 +1,129 @@
+import { appendFileSync } from "node:fs";
+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";
+
+function debug(msg: string) {
+  try {
+    appendFileSync(
+      "/tmp/popcorn-debug.log",
+      `${new Date().toISOString()} [oauth/fetch] ${msg}\n`,
+    );
+  } catch {
+    // ignore
+  }
+}
+
+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);
+    }
+
+    // Debug: log request
+    const url =
+      typeof input === "string"
+        ? input
+        : input instanceof URL
+          ? input.toString()
+          : input.url;
+    debug(`Request to: ${url}`);
+    debug(`Redirecting to: ${CODEX_ENDPOINT}`);
+
+    // Transform request body for Codex API
+    // Codex requires "instructions" field instead of developer/system role in input
+    // Codex also requires "store: false"
+    let body = init?.body;
+    if (body && typeof body === "string") {
+      try {
+        const parsed = JSON.parse(body);
+
+        // Codex requires store: false
+        parsed.store = false;
+
+        // Extract developer/system message as instructions
+        if (parsed.input && Array.isArray(parsed.input)) {
+          const devIdx = parsed.input.findIndex(
+            (m: any) => 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);
+        debug(`Transformed body: ${body.slice(0, 500)}`);
+      } catch {
+        debug(`Failed to transform body`);
+      }
+    }
+
+    const response = await fetch(CODEX_ENDPOINT, { ...init, headers, body });
+
+    // Debug: log response
+    debug(`Response status: ${response.status}`);
+    if (!response.ok) {
+      const text = await response.clone().text();
+      debug(`Error response: ${text.slice(0, 1000)}`);
+    }
+
+    return response;
+  };
+}

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;
+}