@kernl-sdk/ai 0.1.1

package/dist/convert/messages.js

@@ -0,0 +1,130 @@
+export const messages = {
+    encode: (kernlItems) => {
+        const aiMessages = [];
+        for (const item of kernlItems) {
+            if (item.kind === "message") {
+                // Convert Kernl Message to AI SDK Message
+                if (item.role === "system") {
+                    // System messages must have string content in AI SDK
+                    const textContent = item.content
+                        .filter((part) => part.kind === "text")
+                        .map((part) => (part.kind === "text" ? part.text : ""))
+                        .join("\n");
+                    aiMessages.push({
+                        role: "system",
+                        content: textContent,
+                        providerOptions: item.providerMetadata,
+                    });
+                }
+                else if (item.role === "user") {
+                    // User messages have array of text/file parts
+                    const content = [];
+                    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,
+                            });
+                        }
+                        // TODO: Handle DataPart
+                    }
+                    aiMessages.push({
+                        role: "user",
+                        content,
+                        providerOptions: item.providerMetadata,
+                    });
+                }
+                else if (item.role === "assistant") {
+                    // Assistant messages can have text, file, reasoning, tool call parts
+                    const content = [];
+                    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,
+                            });
+                        }
+                        // TODO: Handle DataPart
+                    }
+                    aiMessages.push({
+                        role: "assistant",
+                        content,
+                        providerOptions: item.providerMetadata,
+                    });
+                }
+            }
+            else if (item.kind === "reasoning") {
+                // Reasoning should be part of an assistant message
+                // For now, create a standalone assistant message with reasoning
+                aiMessages.push({
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "reasoning",
+                            text: item.text,
+                            providerOptions: item.providerMetadata,
+                        },
+                    ],
+                });
+            }
+            else if (item.kind === "tool-call") {
+                // Tool calls should be part of an assistant message
+                // For now, create a standalone assistant message with tool call
+                aiMessages.push({
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "tool-call",
+                            toolCallId: item.callId,
+                            toolName: item.toolId,
+                            input: JSON.parse(item.arguments),
+                            providerOptions: item.providerMetadata,
+                        },
+                    ],
+                });
+            }
+            else if (item.kind === "tool-result") {
+                // Tool results go into a separate 'tool' role message
+                aiMessages.push({
+                    role: "tool",
+                    content: [
+                        {
+                            type: "tool-result",
+                            toolCallId: item.callId,
+                            toolName: item.toolId,
+                            output: {
+                                type: "json",
+                                value: item.result,
+                            },
+                            providerOptions: item.providerMetadata,
+                        },
+                    ],
+                });
+            }
+        }
+        return aiMessages;
+    },
+    decode: () => {
+        throw new Error("codec:unimplemented");
+    },
+};

package/dist/convert/response.d.ts

@@ -0,0 +1,15 @@
+import type { Codec, LanguageModelResponse, LanguageModelWarning } from "@kernl-sdk/protocol";
+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 declare const MODEL_RESPONSE: Codec<LanguageModelResponse, AISdkGenerateResult>;
+export declare const WARNING: Codec<LanguageModelWarning, LanguageModelV3CallWarning>;
+//# sourceMappingURL=response.d.ts.map

package/dist/convert/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/convert/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,qBAAqB,EAIrB,oBAAoB,EAErB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;IACvC,YAAY,EAAE,2BAA2B,CAAC;IAC1C,KAAK,EAAE,oBAAoB,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;CAC7C;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,qBAAqB,EAAE,mBAAmB,CAsE1E,CAAC;AAmBJ,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,oBAAoB,EAAE,0BAA0B,CA0BzE,CAAC"}

package/dist/convert/response.js

@@ -0,0 +1,105 @@
+import { randomID } from "@kernl-sdk/shared/lib";
+export const MODEL_RESPONSE = {
+    encode: () => {
+        throw new Error("codec:unimplemented");
+    },
+    decode: (result) => {
+        const content = [];
+        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,
+        };
+    },
+};
+const FINISH_REASON = {
+    encode: () => {
+        throw new Error("codec:unimplemented");
+    },
+    decode: (reason) => reason,
+};
+const USAGE = {
+    encode: () => {
+        throw new Error("codec:unimplemented");
+    },
+    decode: (usage) => usage,
+};
+export const WARNING = {
+    encode: () => {
+        throw new Error("codec:unimplemented");
+    },
+    decode: (warning) => {
+        switch (warning.type) {
+            case "unsupported-setting":
+                return {
+                    type: "unsupported-setting",
+                    setting: warning.setting,
+                    details: warning.details,
+                };
+            case "other":
+                return {
+                    type: "other",
+                    message: warning.message,
+                };
+            default:
+                return {
+                    type: "other",
+                    message: "Unknown warning type",
+                };
+        }
+    },
+};

package/dist/convert/settings.d.ts

@@ -0,0 +1,16 @@
+import type { Codec, LanguageModelRequestSettings } from "@kernl-sdk/protocol";
+import type { LanguageModelV3ToolChoice, SharedV3ProviderOptions } from "@ai-sdk/provider";
+/**
+ * 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 declare const MODEL_SETTINGS: Codec<LanguageModelRequestSettings, AISdkCallOptions>;
+//# sourceMappingURL=settings.d.ts.map

package/dist/convert/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/convert/settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EACV,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAI1B;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,yBAAyB,CAAC;IACvC,eAAe,CAAC,EAAE,uBAAuB,CAAC;CAC3C;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAChC,4BAA4B,EAC5B,gBAAgB,CAsCjB,CAAC"}

package/dist/convert/settings.js

@@ -0,0 +1,36 @@
+import { TOOL_CHOICE } from "./tools";
+export const MODEL_SETTINGS = {
+    encode: (settings) => {
+        const options = {};
+        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;
+        }
+        // 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/dist/convert/stream.d.ts

@@ -0,0 +1,11 @@
+import type { Codec, LanguageModelStreamEvent } from "@kernl-sdk/protocol";
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+/**
+ * Convert AI SDK stream to async iterable of kernl stream events.
+ */
+export declare function convertStream(stream: ReadableStream<LanguageModelV3StreamPart>): AsyncIterable<LanguageModelStreamEvent>;
+/**
+ * Codec for converting individual stream parts.
+ */
+export declare const STREAM_PART: Codec<LanguageModelStreamEvent | null, LanguageModelV3StreamPart>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/convert/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/convert/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAGlE;;GAEG;AACH,wBAAuB,aAAa,CAClC,MAAM,EAAE,cAAc,CAAC,yBAAyB,CAAC,GAChD,aAAa,CAAC,wBAAwB,CAAC,CAgBzC;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAC7B,wBAAwB,GAAG,IAAI,EAC/B,yBAAyB,CAoJ1B,CAAC"}

package/dist/convert/stream.js

@@ -0,0 +1,154 @@
+import { WARNING } from "./response";
+/**
+ * Convert AI SDK stream to async iterable of kernl stream events.
+ */
+export async function* convertStream(stream) {
+    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 = {
+    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, // 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/dist/convert/tools.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, LanguageModelTool, LanguageModelToolChoice } from "@kernl-sdk/protocol";
+import type { LanguageModelV3FunctionTool, LanguageModelV3ProviderDefinedTool, LanguageModelV3ToolChoice } from "@ai-sdk/provider";
+export declare const TOOL: Codec<LanguageModelTool, LanguageModelV3FunctionTool | LanguageModelV3ProviderDefinedTool>;
+export declare const TOOL_CHOICE: Codec<LanguageModelToolChoice, LanguageModelV3ToolChoice>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/convert/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/convert/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,2BAA2B,EAC3B,kCAAkC,EAClC,yBAAyB,EAC1B,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,IAAI,EAAE,KAAK,CACtB,iBAAiB,EACjB,2BAA2B,GAAG,kCAAkC,CAwBjE,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAC7B,uBAAuB,EACvB,yBAAyB,CAiB1B,CAAC"}

package/dist/convert/tools.js

@@ -0,0 +1,42 @@
+export const TOOL = {
+    encode: (tool) => {
+        if (tool.kind === "function") {
+            return {
+                type: "function",
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.parameters,
+                providerOptions: tool.providerOptions,
+            };
+        }
+        else {
+            // provider-defined
+            return {
+                type: "provider-defined",
+                id: tool.id,
+                name: tool.name,
+                args: tool.args,
+            };
+        }
+    },
+    decode: () => {
+        throw new Error("codec:unimplemented");
+    },
+};
+export const TOOL_CHOICE = {
+    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/dist/error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wrap AI SDK errors with additional context.
+ *
+ * @param error - The error from AI SDK
+ * @param context - Additional context about where the error occurred
+ */
+export declare function wrapError(error: unknown, context: string): Error;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAShE"}

package/dist/error.js

@@ -0,0 +1,15 @@
+/**
+ * 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, context) {
+    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/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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";
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGtD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * @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";

package/dist/language-model.d.ts

@@ -0,0 +1,21 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { LanguageModel, LanguageModelRequest, LanguageModelResponse, LanguageModelStreamEvent } from "@kernl-sdk/protocol";
+/**
+ * LanguageModel adapter for the AI SDK LanguageModelV3.
+ */
+export declare class AISDKLanguageModel implements LanguageModel {
+    private model;
+    readonly spec: "1.0";
+    readonly provider: string;
+    readonly modelId: string;
+    constructor(model: LanguageModelV3);
+    /**
+     * Get a response from the model.
+     */
+    generate(request: LanguageModelRequest): Promise<LanguageModelResponse>;
+    /**
+     * Get a streamed response from the model.
+     */
+    stream(request: LanguageModelRequest): AsyncIterable<LanguageModelStreamEvent>;
+}
+//# sourceMappingURL=language-model.d.ts.map

package/dist/language-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-model.d.ts","sourceRoot":"","sources":["../src/language-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EACV,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACzB,MAAM,qBAAqB,CAAC;AAS7B;;GAEG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IAK1C,OAAO,CAAC,KAAK;IAJzB,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEL,KAAK,EAAE,eAAe;IAK1C;;OAEG;IACG,QAAQ,CACZ,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAmBjC;;OAEG;IACI,MAAM,CACX,OAAO,EAAE,oBAAoB,GAC5B,aAAa,CAAC,wBAAwB,CAAC;CAkB3C"}