@inkeep/ai-sdk-provider 0.0.0-dev-20251222193816 → 0.0.0-dev-20251222214618

package/dist/inkeep-chat-language-model.cjs

@@ -0,0 +1,270 @@
+const require_convert_to_inkeep_messages = require('./convert-to-inkeep-messages.cjs');
+const require_get_response_metadata = require('./get-response-metadata.cjs');
+const require_inkeep_error = require('./inkeep-error.cjs');
+const require_map_inkeep_finish_reason = require('./map-inkeep-finish-reason.cjs');
+let __ai_sdk_provider_utils = require("@ai-sdk/provider-utils");
+let __inkeep_agents_core = require("@inkeep/agents-core");
+let zod = require("zod");
+
+//#region src/inkeep-chat-language-model.ts
+/**
+* Converts data-operation events to AI SDK tool events (tool-call or tool-result).
+*
+* Handles:
+* - tool_call: Direct tool invocation (tool-call)
+* - tool_result: Direct tool result (tool-result)
+* - transfer: Agent transfers control to another agent (tool-call)
+* - delegation_sent: Agent delegates a task to another agent (tool-call)
+* - delegation_returned: Delegated task completes and returns (tool-result)
+*/
+function convertDataOperationToToolEvent(opData) {
+	if (!opData || typeof opData !== "object" || !("type" in opData)) return null;
+	const eventType = opData.type;
+	const data = opData.details?.data;
+	if (!data) return null;
+	switch (eventType) {
+		case "tool_call": return {
+			type: "tool-call",
+			toolCallId: data.toolCallId,
+			toolName: data.toolName,
+			input: JSON.stringify(data.input)
+		};
+		case "tool_result": return {
+			type: "tool-result",
+			toolCallId: data.toolCallId,
+			toolName: data.toolName,
+			result: data.output?.result ?? data.output
+		};
+		case "transfer": {
+			const transferData = data;
+			return {
+				type: "tool-call",
+				toolCallId: `transfer_${Date.now()}`,
+				toolName: transferData.targetSubAgent,
+				input: JSON.stringify({
+					fromSubAgent: transferData.fromSubAgent,
+					reason: transferData.reason,
+					context: transferData.context
+				})
+			};
+		}
+		case "delegation_sent": {
+			const delegationData = data;
+			return {
+				type: "tool-call",
+				toolCallId: delegationData.delegationId,
+				toolName: delegationData.targetSubAgent,
+				input: JSON.stringify({
+					fromSubAgent: delegationData.fromSubAgent,
+					taskDescription: delegationData.taskDescription,
+					context: delegationData.context
+				})
+			};
+		}
+		case "delegation_returned": {
+			const returnedData = data;
+			return {
+				type: "tool-result",
+				toolCallId: returnedData.delegationId,
+				toolName: returnedData.targetSubAgent,
+				result: returnedData.result
+			};
+		}
+		default: return null;
+	}
+}
+var InkeepChatLanguageModel = class {
+	specificationVersion = "v2";
+	defaultObjectGenerationMode = void 0;
+	supportsImageUrls = false;
+	supportedUrls = {};
+	modelId;
+	options;
+	config;
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(options, config) {
+		this.modelId = "inkeep-agent";
+		this.options = options;
+		this.config = config;
+	}
+	getArgs(options) {
+		return {
+			args: {
+				messages: require_convert_to_inkeep_messages.convertToInkeepChatMessages(options.prompt),
+				conversationId: this.options.conversationId,
+				headers: this.options.headers,
+				runConfig: this.options.runConfig
+			},
+			warnings: []
+		};
+	}
+	async doGenerate(options) {
+		const { args, warnings } = this.getArgs(options);
+		const response = await (0, __ai_sdk_provider_utils.postJsonToApi)({
+			url: `${this.config.baseURL}/api/chat`,
+			headers: this.config.headers(),
+			body: {
+				...args,
+				stream: false
+			},
+			failedResponseHandler: require_inkeep_error.inkeepFailedResponseHandler,
+			successfulResponseHandler: (0, __ai_sdk_provider_utils.createJsonResponseHandler)(inkeepChatCompletionSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const { value: completion } = response;
+		const choice = completion.choices[0];
+		const content = [];
+		if (choice.message.content) content.push({
+			type: "text",
+			text: choice.message.content
+		});
+		return {
+			content,
+			finishReason: require_map_inkeep_finish_reason.mapInkeepFinishReason(choice.finish_reason),
+			usage: {
+				promptTokens: completion.usage?.prompt_tokens ?? 0,
+				completionTokens: completion.usage?.completion_tokens ?? 0,
+				inputTokens: completion.usage?.prompt_tokens ?? 0,
+				outputTokens: completion.usage?.completion_tokens ?? 0,
+				totalTokens: completion.usage?.total_tokens ?? 0
+			},
+			rawCall: {
+				rawPrompt: args.messages,
+				rawSettings: args
+			},
+			rawResponse: { headers: response.responseHeaders },
+			response: require_get_response_metadata.getResponseMetadata(completion),
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = this.getArgs(options);
+		const response = await (0, __ai_sdk_provider_utils.postJsonToApi)({
+			url: `${this.config.baseURL}/api/chat`,
+			headers: this.config.headers(),
+			body: {
+				...args,
+				stream: true
+			},
+			failedResponseHandler: require_inkeep_error.inkeepFailedResponseHandler,
+			successfulResponseHandler: (0, __ai_sdk_provider_utils.createEventSourceResponseHandler)(__inkeep_agents_core.StreamEventSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const { value: stream } = response;
+		let finishReason = "unknown";
+		let usage = {
+			promptTokens: 0,
+			completionTokens: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0
+		};
+		return {
+			stream: stream.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (!chunk.success) {
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const event = chunk.value;
+					switch (event.type) {
+						case "text-start":
+							controller.enqueue({
+								type: "text-start",
+								id: event.id
+							});
+							break;
+						case "text-delta":
+							controller.enqueue({
+								type: "text-delta",
+								id: event.id,
+								delta: event.delta
+							});
+							break;
+						case "text-end":
+							controller.enqueue({
+								type: "text-end",
+								id: event.id
+							});
+							break;
+						case "data-component":
+						case "data-summary": break;
+						case "data-operation": {
+							const toolEvent = convertDataOperationToToolEvent(event.data);
+							if (toolEvent) controller.enqueue(toolEvent);
+							break;
+						}
+						case "error":
+							controller.enqueue({
+								type: "error",
+								error: new Error(event.error)
+							});
+							break;
+						case "finish":
+							if (event.finishReason) finishReason = require_map_inkeep_finish_reason.mapInkeepFinishReason(event.finishReason);
+							if (event.usage) usage = {
+								promptTokens: event.usage.promptTokens ?? 0,
+								completionTokens: event.usage.completionTokens ?? 0,
+								inputTokens: event.usage.promptTokens ?? 0,
+								outputTokens: event.usage.completionTokens ?? 0,
+								totalTokens: event.usage.totalTokens ?? 0
+							};
+							break;
+						default:
+							console.warn("Unhandled stream event type");
+							break;
+					}
+				},
+				flush(controller) {
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage
+					});
+				}
+			})),
+			rawCall: {
+				rawPrompt: args.messages,
+				rawSettings: args
+			},
+			rawResponse: { headers: response.responseHeaders },
+			warnings
+		};
+	}
+};
+const inkeepChatCompletionSchema = zod.z.object({
+	id: zod.z.string(),
+	object: zod.z.literal("chat.completion"),
+	created: zod.z.number(),
+	model: zod.z.string().optional(),
+	choices: zod.z.array(zod.z.object({
+		index: zod.z.number(),
+		message: zod.z.object({
+			role: zod.z.literal("assistant"),
+			content: zod.z.string()
+		}),
+		finish_reason: zod.z.string()
+	})),
+	usage: zod.z.object({
+		prompt_tokens: zod.z.number().optional(),
+		completion_tokens: zod.z.number().optional(),
+		total_tokens: zod.z.number().optional()
+	}).optional()
+});
+
+//#endregion
+exports.InkeepChatLanguageModel = InkeepChatLanguageModel;
+exports.convertDataOperationToToolEvent = convertDataOperationToToolEvent;

package/dist/inkeep-chat-language-model.d.cts

@@ -0,0 +1,81 @@
+import { InkeepChatMessage } from "./inkeep-chat-prompt.cjs";
+import { InkeepChatOptions } from "./inkeep-chat-options.cjs";
+import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2CallWarning, LanguageModelV2Content, LanguageModelV2FinishReason, LanguageModelV2StreamPart } from "@ai-sdk/provider";
+
+//#region src/inkeep-chat-language-model.d.ts
+interface InkeepChatConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: typeof fetch;
+}
+/**
+ * Converts data-operation events to AI SDK tool events (tool-call or tool-result).
+ *
+ * Handles:
+ * - tool_call: Direct tool invocation (tool-call)
+ * - tool_result: Direct tool result (tool-result)
+ * - transfer: Agent transfers control to another agent (tool-call)
+ * - delegation_sent: Agent delegates a task to another agent (tool-call)
+ * - delegation_returned: Delegated task completes and returns (tool-result)
+ */
+declare function convertDataOperationToToolEvent(opData: any): LanguageModelV2StreamPart | null;
+declare class InkeepChatLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion: "v2";
+  readonly defaultObjectGenerationMode: undefined;
+  readonly supportsImageUrls = false;
+  readonly supportedUrls: {};
+  readonly modelId: string;
+  readonly options: InkeepChatOptions;
+  readonly config: InkeepChatConfig;
+  get provider(): string;
+  constructor(options: InkeepChatOptions, config: InkeepChatConfig);
+  private getArgs;
+  doGenerate(options: LanguageModelV2CallOptions): Promise<{
+    content: LanguageModelV2Content[];
+    finishReason: LanguageModelV2FinishReason;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      inputTokens: number;
+      outputTokens: number;
+      totalTokens: number;
+    };
+    rawCall: {
+      rawPrompt: InkeepChatMessage[];
+      rawSettings: {
+        messages: InkeepChatMessage[];
+        conversationId: string | undefined;
+        headers: Record<string, unknown> | undefined;
+        runConfig: Record<string, unknown> | undefined;
+      };
+    };
+    rawResponse: {
+      headers: Record<string, string> | undefined;
+    };
+    response: {
+      id: string;
+      modelId: string | undefined;
+      timestamp: Date;
+    };
+    warnings: LanguageModelV2CallWarning[];
+  }>;
+  doStream(options: LanguageModelV2CallOptions): Promise<{
+    stream: ReadableStream<LanguageModelV2StreamPart>;
+    rawCall: {
+      rawPrompt: InkeepChatMessage[];
+      rawSettings: {
+        messages: InkeepChatMessage[];
+        conversationId: string | undefined;
+        headers: Record<string, unknown> | undefined;
+        runConfig: Record<string, unknown> | undefined;
+      };
+    };
+    rawResponse: {
+      headers: Record<string, string> | undefined;
+    };
+    warnings: LanguageModelV2CallWarning[];
+  }>;
+}
+//#endregion
+export { InkeepChatLanguageModel, convertDataOperationToToolEvent };

package/dist/inkeep-chat-language-model.d.ts

@@ -0,0 +1,81 @@
+import { InkeepChatMessage } from "./inkeep-chat-prompt.js";
+import { InkeepChatOptions } from "./inkeep-chat-options.js";
+import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2CallWarning, LanguageModelV2Content, LanguageModelV2FinishReason, LanguageModelV2StreamPart } from "@ai-sdk/provider";
+
+//#region src/inkeep-chat-language-model.d.ts
+interface InkeepChatConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: typeof fetch;
+}
+/**
+ * Converts data-operation events to AI SDK tool events (tool-call or tool-result).
+ *
+ * Handles:
+ * - tool_call: Direct tool invocation (tool-call)
+ * - tool_result: Direct tool result (tool-result)
+ * - transfer: Agent transfers control to another agent (tool-call)
+ * - delegation_sent: Agent delegates a task to another agent (tool-call)
+ * - delegation_returned: Delegated task completes and returns (tool-result)
+ */
+declare function convertDataOperationToToolEvent(opData: any): LanguageModelV2StreamPart | null;
+declare class InkeepChatLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion: "v2";
+  readonly defaultObjectGenerationMode: undefined;
+  readonly supportsImageUrls = false;
+  readonly supportedUrls: {};
+  readonly modelId: string;
+  readonly options: InkeepChatOptions;
+  readonly config: InkeepChatConfig;
+  get provider(): string;
+  constructor(options: InkeepChatOptions, config: InkeepChatConfig);
+  private getArgs;
+  doGenerate(options: LanguageModelV2CallOptions): Promise<{
+    content: LanguageModelV2Content[];
+    finishReason: LanguageModelV2FinishReason;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      inputTokens: number;
+      outputTokens: number;
+      totalTokens: number;
+    };
+    rawCall: {
+      rawPrompt: InkeepChatMessage[];
+      rawSettings: {
+        messages: InkeepChatMessage[];
+        conversationId: string | undefined;
+        headers: Record<string, unknown> | undefined;
+        runConfig: Record<string, unknown> | undefined;
+      };
+    };
+    rawResponse: {
+      headers: Record<string, string> | undefined;
+    };
+    response: {
+      id: string;
+      modelId: string | undefined;
+      timestamp: Date;
+    };
+    warnings: LanguageModelV2CallWarning[];
+  }>;
+  doStream(options: LanguageModelV2CallOptions): Promise<{
+    stream: ReadableStream<LanguageModelV2StreamPart>;
+    rawCall: {
+      rawPrompt: InkeepChatMessage[];
+      rawSettings: {
+        messages: InkeepChatMessage[];
+        conversationId: string | undefined;
+        headers: Record<string, unknown> | undefined;
+        runConfig: Record<string, unknown> | undefined;
+      };
+    };
+    rawResponse: {
+      headers: Record<string, string> | undefined;
+    };
+    warnings: LanguageModelV2CallWarning[];
+  }>;
+}
+//#endregion
+export { InkeepChatLanguageModel, convertDataOperationToToolEvent };

package/dist/inkeep-chat-language-model.js

@@ -0,0 +1,269 @@
+import { convertToInkeepChatMessages } from "./convert-to-inkeep-messages.js";
+import { getResponseMetadata } from "./get-response-metadata.js";
+import { inkeepFailedResponseHandler } from "./inkeep-error.js";
+import { mapInkeepFinishReason } from "./map-inkeep-finish-reason.js";
+import { createEventSourceResponseHandler, createJsonResponseHandler, postJsonToApi } from "@ai-sdk/provider-utils";
+import { StreamEventSchema } from "@inkeep/agents-core";
+import { z } from "zod";
+
+//#region src/inkeep-chat-language-model.ts
+/**
+* Converts data-operation events to AI SDK tool events (tool-call or tool-result).
+*
+* Handles:
+* - tool_call: Direct tool invocation (tool-call)
+* - tool_result: Direct tool result (tool-result)
+* - transfer: Agent transfers control to another agent (tool-call)
+* - delegation_sent: Agent delegates a task to another agent (tool-call)
+* - delegation_returned: Delegated task completes and returns (tool-result)
+*/
+function convertDataOperationToToolEvent(opData) {
+	if (!opData || typeof opData !== "object" || !("type" in opData)) return null;
+	const eventType = opData.type;
+	const data = opData.details?.data;
+	if (!data) return null;
+	switch (eventType) {
+		case "tool_call": return {
+			type: "tool-call",
+			toolCallId: data.toolCallId,
+			toolName: data.toolName,
+			input: JSON.stringify(data.input)
+		};
+		case "tool_result": return {
+			type: "tool-result",
+			toolCallId: data.toolCallId,
+			toolName: data.toolName,
+			result: data.output?.result ?? data.output
+		};
+		case "transfer": {
+			const transferData = data;
+			return {
+				type: "tool-call",
+				toolCallId: `transfer_${Date.now()}`,
+				toolName: transferData.targetSubAgent,
+				input: JSON.stringify({
+					fromSubAgent: transferData.fromSubAgent,
+					reason: transferData.reason,
+					context: transferData.context
+				})
+			};
+		}
+		case "delegation_sent": {
+			const delegationData = data;
+			return {
+				type: "tool-call",
+				toolCallId: delegationData.delegationId,
+				toolName: delegationData.targetSubAgent,
+				input: JSON.stringify({
+					fromSubAgent: delegationData.fromSubAgent,
+					taskDescription: delegationData.taskDescription,
+					context: delegationData.context
+				})
+			};
+		}
+		case "delegation_returned": {
+			const returnedData = data;
+			return {
+				type: "tool-result",
+				toolCallId: returnedData.delegationId,
+				toolName: returnedData.targetSubAgent,
+				result: returnedData.result
+			};
+		}
+		default: return null;
+	}
+}
+var InkeepChatLanguageModel = class {
+	specificationVersion = "v2";
+	defaultObjectGenerationMode = void 0;
+	supportsImageUrls = false;
+	supportedUrls = {};
+	modelId;
+	options;
+	config;
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(options, config) {
+		this.modelId = "inkeep-agent";
+		this.options = options;
+		this.config = config;
+	}
+	getArgs(options) {
+		return {
+			args: {
+				messages: convertToInkeepChatMessages(options.prompt),
+				conversationId: this.options.conversationId,
+				headers: this.options.headers,
+				runConfig: this.options.runConfig
+			},
+			warnings: []
+		};
+	}
+	async doGenerate(options) {
+		const { args, warnings } = this.getArgs(options);
+		const response = await postJsonToApi({
+			url: `${this.config.baseURL}/api/chat`,
+			headers: this.config.headers(),
+			body: {
+				...args,
+				stream: false
+			},
+			failedResponseHandler: inkeepFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(inkeepChatCompletionSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const { value: completion } = response;
+		const choice = completion.choices[0];
+		const content = [];
+		if (choice.message.content) content.push({
+			type: "text",
+			text: choice.message.content
+		});
+		return {
+			content,
+			finishReason: mapInkeepFinishReason(choice.finish_reason),
+			usage: {
+				promptTokens: completion.usage?.prompt_tokens ?? 0,
+				completionTokens: completion.usage?.completion_tokens ?? 0,
+				inputTokens: completion.usage?.prompt_tokens ?? 0,
+				outputTokens: completion.usage?.completion_tokens ?? 0,
+				totalTokens: completion.usage?.total_tokens ?? 0
+			},
+			rawCall: {
+				rawPrompt: args.messages,
+				rawSettings: args
+			},
+			rawResponse: { headers: response.responseHeaders },
+			response: getResponseMetadata(completion),
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = this.getArgs(options);
+		const response = await postJsonToApi({
+			url: `${this.config.baseURL}/api/chat`,
+			headers: this.config.headers(),
+			body: {
+				...args,
+				stream: true
+			},
+			failedResponseHandler: inkeepFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(StreamEventSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const { value: stream } = response;
+		let finishReason = "unknown";
+		let usage = {
+			promptTokens: 0,
+			completionTokens: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0
+		};
+		return {
+			stream: stream.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (!chunk.success) {
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const event = chunk.value;
+					switch (event.type) {
+						case "text-start":
+							controller.enqueue({
+								type: "text-start",
+								id: event.id
+							});
+							break;
+						case "text-delta":
+							controller.enqueue({
+								type: "text-delta",
+								id: event.id,
+								delta: event.delta
+							});
+							break;
+						case "text-end":
+							controller.enqueue({
+								type: "text-end",
+								id: event.id
+							});
+							break;
+						case "data-component":
+						case "data-summary": break;
+						case "data-operation": {
+							const toolEvent = convertDataOperationToToolEvent(event.data);
+							if (toolEvent) controller.enqueue(toolEvent);
+							break;
+						}
+						case "error":
+							controller.enqueue({
+								type: "error",
+								error: new Error(event.error)
+							});
+							break;
+						case "finish":
+							if (event.finishReason) finishReason = mapInkeepFinishReason(event.finishReason);
+							if (event.usage) usage = {
+								promptTokens: event.usage.promptTokens ?? 0,
+								completionTokens: event.usage.completionTokens ?? 0,
+								inputTokens: event.usage.promptTokens ?? 0,
+								outputTokens: event.usage.completionTokens ?? 0,
+								totalTokens: event.usage.totalTokens ?? 0
+							};
+							break;
+						default:
+							console.warn("Unhandled stream event type");
+							break;
+					}
+				},
+				flush(controller) {
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage
+					});
+				}
+			})),
+			rawCall: {
+				rawPrompt: args.messages,
+				rawSettings: args
+			},
+			rawResponse: { headers: response.responseHeaders },
+			warnings
+		};
+	}
+};
+const inkeepChatCompletionSchema = z.object({
+	id: z.string(),
+	object: z.literal("chat.completion"),
+	created: z.number(),
+	model: z.string().optional(),
+	choices: z.array(z.object({
+		index: z.number(),
+		message: z.object({
+			role: z.literal("assistant"),
+			content: z.string()
+		}),
+		finish_reason: z.string()
+	})),
+	usage: z.object({
+		prompt_tokens: z.number().optional(),
+		completion_tokens: z.number().optional(),
+		total_tokens: z.number().optional()
+	}).optional()
+});
+
+//#endregion
+export { InkeepChatLanguageModel, convertDataOperationToToolEvent };

package/dist/inkeep-chat-options.d.cts

@@ -0,0 +1,8 @@
+//#region src/inkeep-chat-options.d.ts
+interface InkeepChatOptions {
+  conversationId?: string;
+  runConfig?: Record<string, unknown>;
+  headers?: Record<string, unknown>;
+}
+//#endregion
+export { InkeepChatOptions };