@kernl-sdk/ai 0.1.1

package/src/convert/message.ts

@@ -0,0 +1,150 @@
+import type { Codec, LanguageModelItem } from "@kernl-sdk/protocol";
+import type {
+  LanguageModelV3Message,
+  LanguageModelV3TextPart,
+  LanguageModelV3FilePart,
+  LanguageModelV3ReasoningPart,
+  LanguageModelV3ToolCallPart,
+} from "@ai-sdk/provider";
+
+export const MESSAGE: Codec<LanguageModelItem, LanguageModelV3Message> = {
+  encode: (item) => {
+    switch (item.kind) {
+      case "message": {
+        switch (item.role) {
+          case "system": {
+            const content = item.content
+              .filter((part) => part.kind === "text")
+              .map((part) => (part.kind === "text" ? part.text : ""))
+              .join("\n");
+
+            return {
+              role: "system",
+              content: content,
+              providerOptions: item.providerMetadata,
+            };
+          }
+
+          case "user": {
+            const content: Array<
+              LanguageModelV3TextPart | LanguageModelV3FilePart
+            > = [];
+
+            for (const part of item.content) {
+              if (part.kind === "text") {
+                content.push({
+                  type: "text",
+                  text: part.text,
+                  providerOptions: part.providerMetadata,
+                });
+              } else if (part.kind === "file") {
+                content.push({
+                  type: "file",
+                  filename: part.filename,
+                  data: part.data,
+                  mediaType: part.mimeType,
+                  providerOptions: part.providerMetadata,
+                });
+              }
+            }
+
+            return {
+              role: "user",
+              content,
+              providerOptions: item.providerMetadata,
+            };
+          }
+
+          case "assistant": {
+            const content: Array<
+              | LanguageModelV3TextPart
+              | LanguageModelV3FilePart
+              | LanguageModelV3ReasoningPart
+              | LanguageModelV3ToolCallPart
+            > = [];
+
+            for (const part of item.content) {
+              if (part.kind === "text") {
+                content.push({
+                  type: "text",
+                  text: part.text,
+                  providerOptions: part.providerMetadata,
+                });
+              } else if (part.kind === "file") {
+                content.push({
+                  type: "file",
+                  filename: part.filename,
+                  data: part.data,
+                  mediaType: part.mimeType,
+                  providerOptions: part.providerMetadata,
+                });
+              }
+            }
+
+            return {
+              role: "assistant",
+              content,
+              providerOptions: item.providerMetadata,
+            };
+          }
+        }
+        break;
+      }
+
+      case "reasoning": {
+        return {
+          role: "assistant",
+          content: [
+            {
+              type: "reasoning",
+              text: "text" in item ? item.text : "",
+              providerOptions: item.providerMetadata,
+            },
+          ],
+        };
+      }
+
+      case "tool-call": {
+        return {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: item.callId,
+              toolName: item.toolId,
+              input: JSON.parse(item.arguments),
+              providerOptions: item.providerMetadata,
+            },
+          ],
+        };
+      }
+
+      case "tool-result": {
+        return {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: item.callId,
+              toolName: item.toolId,
+              output: {
+                type: "json",
+                value: item.result,
+              },
+              providerOptions: item.providerMetadata,
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(
+          `Unsupported LanguageModelItem kind: ${(item as any).kind}`,
+        );
+    }
+  },
+
+  decode: () => {
+    throw new Error("codec:unimplemented");
+  },
+};

package/src/convert/response.ts

@@ -0,0 +1,144 @@
+import type {
+  Codec,
+  LanguageModelResponse,
+  LanguageModelResponseItem,
+  LanguageModelFinishReason,
+  LanguageModelUsage,
+  LanguageModelWarning,
+  SharedProviderMetadata,
+} from "@kernl-sdk/protocol";
+import { randomID } from "@kernl-sdk/shared/lib";
+import type {
+  LanguageModelV3Content,
+  LanguageModelV3FinishReason,
+  LanguageModelV3Usage,
+  LanguageModelV3CallWarning,
+} from "@ai-sdk/provider";
+
+/**
+ * AI SDK generate result structure
+ */
+export interface AISdkGenerateResult {
+  content: Array<LanguageModelV3Content>;
+  finishReason: LanguageModelV3FinishReason;
+  usage: LanguageModelV3Usage;
+  providerMetadata?: Record<string, unknown>;
+  warnings: Array<LanguageModelV3CallWarning>;
+}
+
+export const MODEL_RESPONSE: Codec<LanguageModelResponse, AISdkGenerateResult> =
+  {
+    encode: () => {
+      throw new Error("codec:unimplemented");
+    },
+
+    decode: (result: AISdkGenerateResult) => {
+      const content: LanguageModelResponseItem[] = [];
+
+      for (const item of result.content) {
+        if (item.type === "text") {
+          content.push({
+            kind: "message",
+            role: "assistant",
+            id: randomID(),
+            content: [
+              {
+                kind: "text",
+                text: item.text,
+                providerMetadata: item.providerMetadata,
+              },
+            ],
+            providerMetadata: item.providerMetadata,
+          });
+        } else if (item.type === "reasoning") {
+          content.push({
+            kind: "reasoning",
+            text: item.text,
+            providerMetadata: item.providerMetadata,
+          });
+        } else if (item.type === "tool-call") {
+          content.push({
+            kind: "tool-call",
+            callId: item.toolCallId,
+            toolId: item.toolName,
+            state: "completed",
+            arguments: JSON.stringify(item.input),
+            providerMetadata: item.providerMetadata,
+          });
+        } else if (item.type === "file") {
+          content.push({
+            kind: "message",
+            role: "assistant",
+            id: randomID(),
+            content: [
+              {
+                kind: "file",
+                mimeType: item.mediaType,
+                data: item.data,
+              },
+            ],
+          });
+        }
+        // TODO: Handle other content types (source, tool-result)
+      }
+
+      const finishReason = FINISH_REASON.decode(result.finishReason);
+      const usage = USAGE.decode(result.usage);
+      const warnings = result.warnings.map(WARNING.decode);
+
+      return {
+        content,
+        finishReason,
+        usage,
+        warnings,
+        providerMetadata: result.providerMetadata as
+          | SharedProviderMetadata
+          | undefined,
+      };
+    },
+  };
+
+const FINISH_REASON: Codec<
+  LanguageModelFinishReason,
+  LanguageModelV3FinishReason
+> = {
+  encode: () => {
+    throw new Error("codec:unimplemented");
+  },
+  decode: (reason) => reason as LanguageModelFinishReason,
+};
+
+const USAGE: Codec<LanguageModelUsage, LanguageModelV3Usage> = {
+  encode: () => {
+    throw new Error("codec:unimplemented");
+  },
+  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",
+          };
+      }
+    },
+  };

package/src/convert/settings.ts

@@ -0,0 +1,62 @@
+import type { Codec, LanguageModelRequestSettings } from "@kernl-sdk/protocol";
+import type {
+  LanguageModelV3ToolChoice,
+  SharedV3ProviderOptions,
+} from "@ai-sdk/provider";
+
+import { TOOL_CHOICE } from "./tools";
+
+/**
+ * Partial AI SDK call options extracted from settings.
+ */
+export interface AISdkCallOptions {
+  temperature?: number;
+  topP?: number;
+  maxOutputTokens?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  toolChoice?: LanguageModelV3ToolChoice;
+  providerOptions?: SharedV3ProviderOptions;
+}
+
+export const MODEL_SETTINGS: Codec<
+  LanguageModelRequestSettings,
+  AISdkCallOptions
+> = {
+  encode: (settings: LanguageModelRequestSettings) => {
+    const options: AISdkCallOptions = {};
+
+    if (settings.temperature !== undefined) {
+      options.temperature = settings.temperature;
+    }
+    if (settings.topP !== undefined) {
+      options.topP = settings.topP;
+    }
+    if (settings.maxTokens !== undefined) {
+      options.maxOutputTokens = settings.maxTokens;
+    }
+    if (settings.frequencyPenalty !== undefined) {
+      options.frequencyPenalty = settings.frequencyPenalty;
+    }
+    if (settings.presencePenalty !== undefined) {
+      options.presencePenalty = settings.presencePenalty;
+    }
+    if (settings.toolChoice !== undefined) {
+      options.toolChoice = TOOL_CHOICE.encode(settings.toolChoice);
+    }
+    if (settings.providerOptions !== undefined) {
+      options.providerOptions =
+        settings.providerOptions as SharedV3ProviderOptions;
+    }
+
+    // TODO: Handle reasoning settings (settings.reasoning)
+    // TODO: Handle text settings (settings.text)
+    // TODO: Handle parallelToolCalls (not in AI SDK v3 base interface)
+    // These may need to be mapped to provider-specific options
+
+    return options;
+  },
+  decode: () => {
+    throw new Error("codec:unimplemented");
+  },
+};

package/src/convert/stream.ts

@@ -0,0 +1,181 @@
+import type { Codec, LanguageModelStreamEvent } from "@kernl-sdk/protocol";
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import { WARNING } from "./response";
+
+/**
+ * Convert AI SDK stream to async iterable of kernl stream events.
+ */
+export async function* convertStream(
+  stream: ReadableStream<LanguageModelV3StreamPart>,
+): AsyncIterable<LanguageModelStreamEvent> {
+  const reader = stream.getReader();
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const event = STREAM_PART.decode(value);
+      if (event) {
+        yield event;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/**
+ * Codec for converting individual stream parts.
+ */
+export const STREAM_PART: Codec<
+  LanguageModelStreamEvent | null,
+  LanguageModelV3StreamPart
+> = {
+  encode: () => {
+    throw new Error("codec:unimplemented");
+  },
+
+  decode: (part) => {
+    switch (part.type) {
+      case "text-start":
+        return {
+          kind: "text-start",
+          id: part.id,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "text-delta":
+        return {
+          kind: "text-delta",
+          id: part.id,
+          text: part.delta,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "text-end":
+        return {
+          kind: "text-end",
+          id: part.id,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "reasoning-start":
+        return {
+          kind: "reasoning-start",
+          id: part.id,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "reasoning-delta":
+        return {
+          kind: "reasoning-delta",
+          id: part.id,
+          text: part.delta,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "reasoning-end":
+        return {
+          kind: "reasoning-end",
+          id: part.id,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "tool-input-start":
+        return {
+          kind: "tool-input-start",
+          id: part.id,
+          toolName: part.toolName,
+          title: part.title,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "tool-input-delta":
+        return {
+          kind: "tool-input-delta",
+          id: part.id,
+          delta: part.delta,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "tool-input-end":
+        return {
+          kind: "tool-input-end",
+          id: part.id,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "tool-call":
+        return {
+          kind: "tool-call",
+          id: part.toolCallId,
+          toolName: part.toolName,
+          arguments: part.input,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "tool-result":
+        // Provider-defined tools can stream tool results
+        return {
+          kind: "tool-result",
+          callId: part.toolCallId,
+          toolId: part.toolName,
+          state: part.isError ? "failed" : "completed",
+          result: part.result,
+          error: part.isError ? String(part.result) : null,
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "file":
+      case "source":
+        // These don't have direct Kernl equivalents in streaming
+        // Could be handled as raw events
+        return {
+          kind: "raw",
+          rawValue: part,
+        };
+
+      case "stream-start":
+        return {
+          kind: "stream-start",
+          warnings: part.warnings.map(WARNING.decode),
+        };
+
+      case "finish":
+        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,
+          },
+          providerMetadata: part.providerMetadata,
+        };
+
+      case "error":
+        return {
+          kind: "error",
+          error: part.error,
+        };
+
+      case "raw":
+        return {
+          kind: "raw",
+          rawValue: part.rawValue,
+        };
+
+      case "response-metadata":
+        // Kernl doesn't have a specific event for response metadata
+        // Could be passed through as raw or ignored
+        return null;
+
+      default:
+        // Unknown event type
+        return null;
+    }
+  },
+};

package/src/convert/tools.ts

@@ -0,0 +1,59 @@
+import type {
+  Codec,
+  LanguageModelTool,
+  LanguageModelToolChoice,
+} from "@kernl-sdk/protocol";
+import type {
+  LanguageModelV3FunctionTool,
+  LanguageModelV3ProviderDefinedTool,
+  LanguageModelV3ToolChoice,
+} from "@ai-sdk/provider";
+
+export const TOOL: Codec<
+  LanguageModelTool,
+  LanguageModelV3FunctionTool | LanguageModelV3ProviderDefinedTool
+> = {
+  encode: (tool) => {
+    if (tool.kind === "function") {
+      return {
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.parameters,
+        providerOptions: tool.providerOptions,
+      } satisfies LanguageModelV3FunctionTool;
+    } else {
+      // provider-defined
+      return {
+        type: "provider-defined",
+        id: tool.id,
+        name: tool.name,
+        args: tool.args,
+      } satisfies LanguageModelV3ProviderDefinedTool;
+    }
+  },
+  decode: () => {
+    throw new Error("codec:unimplemented");
+  },
+};
+
+export const TOOL_CHOICE: Codec<
+  LanguageModelToolChoice,
+  LanguageModelV3ToolChoice
+> = {
+  encode: (choice) => {
+    switch (choice.kind) {
+      case "auto":
+        return { type: "auto" };
+      case "none":
+        return { type: "none" };
+      case "required":
+        return { type: "required" };
+      case "tool":
+        return { type: "tool", toolName: choice.toolId };
+    }
+  },
+  decode: () => {
+    throw new Error("codec:unimplemented");
+  },
+};

package/src/error.ts

@@ -0,0 +1,16 @@
+/**
+ * Wrap AI SDK errors with additional context.
+ *
+ * @param error - The error from AI SDK
+ * @param context - Additional context about where the error occurred
+ */
+export function wrapError(error: unknown, context: string): Error {
+  if (error instanceof Error) {
+    const wrapped = new Error(`AI SDK error in ${context}: ${error.message}`);
+    wrapped.stack = error.stack;
+    wrapped.cause = error;
+    return wrapped;
+  }
+
+  return new Error(`AI SDK error in ${context}: ${String(error)}`);
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * @kernl-sdk/ai - AI SDK adapter for Kernl
+ *
+ * Universal provider support via Vercel AI SDK v5.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from '@kernl-sdk/ai/anthropic';
+ *
+ * const claude = anthropic('claude-3-5-sonnet-20241022');
+ * const response = await claude.generate([...], {});
+ * ```
+ */
+
+export { AISDKLanguageModel } from "./language-model";
+
+// Re-export codecs for custom provider implementations
+export { MESSAGE } from "./convert/message";
+export { TOOL, TOOL_CHOICE } from "./convert/tools";
+export { MODEL_SETTINGS } from "./convert/settings";
+export { MODEL_RESPONSE, WARNING } from "./convert/response";
+export { convertStream } from "./convert/stream";