@databricks/ai-sdk-provider 0.0.1 → 0.1.1

package/dist/index.js

@@ -0,0 +1,2009 @@
+import { combineHeaders, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, parseProviderOptions, postJsonToApi, withoutTrailingSlash } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { randomUUID } from "node:crypto";
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+
+//#region src/chat-agent-language-model/chat-agent-schema.ts
+const chatAgentToolCallSchema = z.object({
+	type: z.literal("function"),
+	function: z.object({
+		name: z.string(),
+		arguments: z.string()
+	}),
+	id: z.string()
+});
+const chatAgentAssistantMessageSchema = z.object({
+	role: z.literal("assistant"),
+	content: z.string(),
+	id: z.string(),
+	name: z.string().optional(),
+	tool_calls: z.array(chatAgentToolCallSchema).optional()
+});
+const chatAgentToolMessageSchema = z.object({
+	role: z.literal("tool"),
+	name: z.string(),
+	content: z.string(),
+	tool_call_id: z.string(),
+	id: z.string(),
+	attachments: z.record(z.string(), z.unknown()).optional()
+});
+const chatAgentUserMessageSchema = z.object({
+	role: z.literal("user"),
+	content: z.string(),
+	id: z.string()
+});
+const chatAgentMessageSchema = z.discriminatedUnion("role", [
+	chatAgentAssistantMessageSchema,
+	chatAgentToolMessageSchema,
+	chatAgentUserMessageSchema
+]);
+const chatAgentChunkSchema = z.object({
+	id: z.string(),
+	delta: chatAgentMessageSchema
+});
+const chatAgentResponseSchema = z.object({
+	id: z.string(),
+	messages: z.array(chatAgentMessageSchema)
+});
+
+//#endregion
+//#region src/tools.ts
+const DATABRICKS_TOOL_CALL_ID = "databricks-tool-call";
+/**
+* The AI-SDK requires that tools used by the model are defined ahead of time.
+*
+* Since tool calls can be orchestrated by Databricks' agents we don't know the name, input, or output schemas
+* of the tools until the model is called.
+*
+* In the DatabricksProvider we transform all tool calls to fit this definition, and keep the
+* original name as part of the metadata. This allows us to parse any tool orchestrated by Databricks' agents,
+* while still being able to render the tool call and result in the UI, and pass it back to the model with the correct name.
+*/
+const DATABRICKS_TOOL_DEFINITION = {
+	name: DATABRICKS_TOOL_CALL_ID,
+	description: "Databricks tool call",
+	inputSchema: z.any(),
+	outputSchema: z.any()
+};
+
+//#endregion
+//#region src/chat-agent-language-model/chat-agent-convert-to-message-parts.ts
+const convertChatAgentChunkToMessagePart = (chunk) => {
+	const parts = [];
+	if (chunk.delta.role === "assistant") {
+		if (chunk.delta.content) parts.push({
+			type: "text-delta",
+			id: chunk.delta.id,
+			delta: chunk.delta.content
+		});
+		chunk.delta.tool_calls?.forEach((toolCall) => {
+			parts.push({
+				type: "tool-call",
+				toolCallId: toolCall.id,
+				input: toolCall.function.arguments,
+				toolName: toolCall.function.name
+			});
+		});
+	} else if (chunk.delta.role === "tool") parts.push({
+		type: "tool-result",
+		toolCallId: chunk.delta.tool_call_id,
+		result: chunk.delta.content,
+		toolName: DATABRICKS_TOOL_CALL_ID
+	});
+	return parts;
+};
+const convertChatAgentResponseToMessagePart = (response) => {
+	const parts = [];
+	for (const message of response.messages) if (message.role === "assistant") {
+		parts.push({
+			type: "text",
+			text: message.content
+		});
+		for (const part of message.tool_calls ?? []) parts.push({
+			type: "tool-call",
+			toolCallId: part.id,
+			input: part.function.arguments,
+			toolName: part.function.name
+		});
+	} else if (message.role === "tool") parts.push({
+		type: "tool-result",
+		toolCallId: message.tool_call_id,
+		result: message.content,
+		toolName: DATABRICKS_TOOL_CALL_ID
+	});
+	return parts;
+};
+
+//#endregion
+//#region src/chat-agent-language-model/chat-agent-convert-to-input.ts
+const convertLanguageModelV2PromptToChatAgentResponse = (prompt) => {
+	const messages = [];
+	let messageIndex = 0;
+	for (const msg of prompt) switch (msg.role) {
+		case "system": break;
+		case "user": {
+			const converted = convertUserMessage(msg, messageIndex);
+			messages.push(converted);
+			messageIndex++;
+			break;
+		}
+		case "assistant": {
+			const converted = convertAssistantMessage(msg, messageIndex);
+			messages.push(...converted);
+			messageIndex += converted.length;
+			break;
+		}
+		case "tool": {
+			const converted = convertToolMessage(msg, messageIndex);
+			messages.push(...converted);
+			messageIndex += converted.length;
+			break;
+		}
+	}
+	return messages;
+};
+const convertUserMessage = (msg, messageIndex) => {
+	const text = (msg.content ?? []).filter((part) => part.type === "text").map((part) => part.text).join("\n");
+	return {
+		role: "user",
+		content: text,
+		id: `user-${messageIndex}`
+	};
+};
+const convertAssistantMessage = (msg, startIndex) => {
+	const messages = [];
+	let messageIndex = startIndex;
+	const textContent = (msg.content ?? []).filter((part) => part.type === "text" || part.type === "reasoning").map((part) => part.type === "text" ? part.text : part.text).join("\n");
+	const toolCalls = (msg.content ?? []).filter((part) => part.type === "tool-call").map((call) => ({
+		type: "function",
+		id: call.toolCallId,
+		function: {
+			name: call.toolName,
+			arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {})
+		}
+	}));
+	messages.push({
+		role: "assistant",
+		content: textContent,
+		id: `assistant-${messageIndex++}`,
+		tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+	});
+	for (const part of msg.content ?? []) if (part.type === "tool-result") messages.push({
+		role: "tool",
+		name: part.toolName,
+		content: convertToolResultOutput(part.output),
+		tool_call_id: part.toolCallId,
+		id: `tool-${messageIndex++}`
+	});
+	return messages;
+};
+const convertToolMessage = (msg, startIndex) => {
+	const messages = [];
+	let messageIndex = startIndex;
+	for (const part of msg.content ?? []) if (part.type === "tool-result") messages.push({
+		role: "tool",
+		name: part.toolName,
+		content: convertToolResultOutput(part.output),
+		tool_call_id: part.toolCallId,
+		id: `tool-${messageIndex++}`
+	});
+	return messages;
+};
+const convertToolResultOutput = (output) => {
+	switch (output.type) {
+		case "text":
+		case "error-text": return output.value;
+		case "json":
+		case "error-json": return JSON.stringify(output.value);
+		case "content": return output.value.map((p) => p.type === "text" ? p.text : "").filter(Boolean).join("\n");
+		default: return "";
+	}
+};
+
+//#endregion
+//#region src/stream-transformers/compose-stream-part-transformers.ts
+/**
+* Compose an arbitrary number of `DatabricksStreamPartTransformer`s.
+*
+* The returned function has the exact same signature as a normal transformer,
+* but its `out`‑element type is inferred from the **last** transformer you pass
+* in.
+*
+* Runtime behaviour:
+*   1️⃣ Call the first transformer with the supplied `parts` and the
+*      caller‑provided `last` (usually `null`).
+*   2️⃣ Take its `out` and `last` and feed them to the next transformer.
+*   3️⃣ …repeat until the last transformer runs.
+*   4️⃣ Return the `out`/`last` of that final transformer.
+*/
+function composeDatabricksStreamPartTransformers(...transformers) {
+	return (initialParts, last = null) => {
+		let currentParts = initialParts;
+		for (const fn of transformers) {
+			const result = fn(currentParts, last);
+			currentParts = result.out;
+		}
+		return { out: currentParts };
+	};
+}
+
+//#endregion
+//#region src/stream-transformers/databricks-delta-boundary.ts
+/**
+* Injects start/end deltas for sequential streams.
+*/
+const applyDeltaBoundaryTransform = (parts, last) => {
+	const out = [];
+	const lastDeltaType = maybeGetDeltaType(last);
+	for (const incoming of parts) {
+		const incomingDeltaType = maybeGetDeltaType(incoming);
+		const incomingId = getPartId$1(incoming);
+		const lastId = getPartId$1(last);
+		const incomingMatchesLast = Boolean(isDeltaPart(last) && isDeltaPart(incoming)) && Boolean(lastDeltaType && incomingDeltaType) && Boolean(lastDeltaType === incomingDeltaType) && Boolean(incomingId && lastId && incomingId === lastId);
+		if (incomingMatchesLast) {
+			out.push(incoming);
+			continue;
+		}
+		if (isDeltaPart(last)) out.push({
+			type: `${getDeltaType(last)}-end`,
+			id: last.id
+		});
+		if (isDeltaPart(incoming)) {
+			out.push({
+				type: `${getDeltaType(incoming)}-start`,
+				id: incoming.id
+			}, incoming);
+			continue;
+		}
+		out.push(incoming);
+		continue;
+	}
+	return { out };
+};
+const isDeltaIsh = (part) => part?.type.startsWith("text-") || part?.type.startsWith("reasoning-") || false;
+const maybeGetDeltaType = (part) => {
+	if (!isDeltaIsh(part)) return null;
+	if (part.type.startsWith("text-")) return "text";
+	if (part.type.startsWith("reasoning-")) return "reasoning";
+	return null;
+};
+const getDeltaType = (part) => {
+	if (part.type.startsWith("text-")) return "text";
+	if (part.type.startsWith("reasoning-")) return "reasoning";
+	throw new Error(`Unknown delta type: ${part.type}`);
+};
+const isDeltaPart = (part) => part?.type === "text-delta" || part?.type === "reasoning-delta";
+const getPartId$1 = (part) => {
+	if (part && "id" in part) return part.id;
+	return void 0;
+};
+
+//#endregion
+//#region src/stream-transformers/databricks-stream-transformer.ts
+/**
+* Allows stream transformations to be composed together.
+*
+* Currently only used to automatically inject start/end
+* deltas since the APIs does not supply the necessary events.
+*/
+const getDatabricksLanguageModelTransformStream = () => {
+	let lastChunk = null;
+	const deltaEndByTypeAndId = new Set();
+	const transformerStreamParts = composeDatabricksStreamPartTransformers(applyDeltaBoundaryTransform);
+	return new TransformStream({
+		transform(chunk, controller) {
+			const { out } = transformerStreamParts([chunk], lastChunk);
+			out.forEach((transformedChunk) => {
+				const group = getDeltaGroup(transformedChunk.type);
+				const endKey = makeEndKey(getPartId(transformedChunk), group);
+				if (endKey && deltaEndByTypeAndId.has(endKey)) return;
+				if (transformedChunk.type === "text-end" || transformedChunk.type === "reasoning-end") {
+					/**
+					* We register when a delta ends.
+					* We rely on response.output_item.done chunks to display non streamed data
+					* so we need to deduplicate them with their corresponding delta chunks.
+					*/
+					const endGroup = getDeltaGroup(transformedChunk.type);
+					const key = makeEndKey(getPartId(transformedChunk), endGroup);
+					if (key) deltaEndByTypeAndId.add(key);
+				}
+				controller.enqueue(transformedChunk);
+			});
+			lastChunk = out[out.length - 1] ?? lastChunk;
+		},
+		flush(controller) {
+			if (lastChunk?.type === "text-delta") controller.enqueue({
+				type: "text-end",
+				id: lastChunk.id
+			});
+			if (lastChunk?.type === "reasoning-delta") controller.enqueue({
+				type: "reasoning-end",
+				id: lastChunk.id
+			});
+		}
+	});
+};
+const getDeltaGroup = (type) => {
+	if (type.startsWith("text-")) return "text";
+	if (type.startsWith("reasoning-")) return "reasoning";
+	return null;
+};
+const getPartId = (part) => {
+	if ("id" in part) return part.id;
+	return void 0;
+};
+const makeEndKey = (id, group) => id && group ? `${group}:${id}` : null;
+
+//#endregion
+//#region src/chat-agent-language-model/chat-agent-language-model.ts
+var DatabricksChatAgentLanguageModel = class {
+	specificationVersion = "v2";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	supportedUrls = {};
+	async doGenerate(options) {
+		const networkArgs = this.getArgs({
+			config: this.config,
+			options,
+			stream: false,
+			modelId: this.modelId
+		});
+		const { value: response } = await postJsonToApi({
+			...networkArgs,
+			successfulResponseHandler: createJsonResponseHandler(chatAgentResponseSchema),
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: z.any(),
+				errorToMessage: (error) => JSON.stringify(error),
+				isRetryable: () => false
+			})
+		});
+		return {
+			content: convertChatAgentResponseToMessagePart(response),
+			finishReason: "stop",
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				totalTokens: 0
+			},
+			warnings: []
+		};
+	}
+	async doStream(options) {
+		const networkArgs = this.getArgs({
+			config: this.config,
+			options,
+			stream: true,
+			modelId: this.modelId
+		});
+		const { responseHeaders, value: response } = await postJsonToApi({
+			...networkArgs,
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: z.any(),
+				errorToMessage: (error) => JSON.stringify(error),
+				isRetryable: () => false
+			}),
+			successfulResponseHandler: createEventSourceResponseHandler(chatAgentChunkSchema)
+		});
+		let finishReason = "unknown";
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings: []
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = "error";
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const parts = convertChatAgentChunkToMessagePart(chunk.value);
+					for (const part of parts) controller.enqueue(part);
+				},
+				flush(controller) {
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: {
+							inputTokens: 0,
+							outputTokens: 0,
+							totalTokens: 0
+						}
+					});
+				}
+			})).pipeThrough(getDatabricksLanguageModelTransformStream()),
+			request: { body: networkArgs.body },
+			response: { headers: responseHeaders }
+		};
+	}
+	getArgs({ config, options, stream, modelId }) {
+		return {
+			body: {
+				model: modelId,
+				stream,
+				messages: convertLanguageModelV2PromptToChatAgentResponse(options.prompt)
+			},
+			url: config.url({ path: "/completions" }),
+			headers: combineHeaders(config.headers(), options.headers),
+			fetch: config.fetch,
+			abortSignal: options.abortSignal
+		};
+	}
+};
+
+//#endregion
+//#region src/responses-agent-language-model/responses-agent-schema.ts
+/**
+* Response schema
+*/
+const responsesAgentMessageSchema = z.object({
+	type: z.literal("message"),
+	role: z.literal("assistant"),
+	id: z.string(),
+	content: z.array(z.object({
+		type: z.literal("output_text"),
+		text: z.string(),
+		logprobs: z.unknown().nullish(),
+		annotations: z.array(z.discriminatedUnion("type", [z.object({
+			type: z.literal("url_citation"),
+			start_index: z.number(),
+			end_index: z.number(),
+			url: z.string(),
+			title: z.string()
+		})]))
+	}))
+});
+const responsesAgentFunctionCallSchema = z.object({
+	type: z.literal("function_call"),
+	call_id: z.string(),
+	name: z.string(),
+	arguments: z.string(),
+	id: z.string()
+});
+const responsesAgentReasoningSchema = z.object({
+	type: z.literal("reasoning"),
+	id: z.string(),
+	encrypted_content: z.string().nullish(),
+	summary: z.array(z.object({
+		type: z.literal("summary_text"),
+		text: z.string()
+	}))
+});
+const responsesAgentFunctionCallOutputSchema = z.object({
+	type: z.literal("function_call_output"),
+	call_id: z.string(),
+	output: z.any()
+});
+const responsesAgentMcpApprovalRequestSchema = z.object({
+	type: z.literal("mcp_approval_request"),
+	id: z.string(),
+	name: z.string(),
+	arguments: z.string(),
+	server_label: z.string()
+});
+const responsesAgentMcpApprovalResponseSchema = z.object({
+	type: z.literal("mcp_approval_response"),
+	id: z.string().optional(),
+	approval_request_id: z.string(),
+	approve: z.boolean(),
+	reason: z.string().nullish()
+});
+const responsesAgentOutputItem = z.discriminatedUnion("type", [
+	responsesAgentMessageSchema,
+	responsesAgentFunctionCallSchema,
+	responsesAgentReasoningSchema,
+	responsesAgentFunctionCallOutputSchema,
+	responsesAgentMcpApprovalRequestSchema,
+	responsesAgentMcpApprovalResponseSchema
+]);
+const responsesAgentResponseSchema = z.object({
+	id: z.string().optional(),
+	created_at: z.number().optional(),
+	error: z.object({
+		code: z.string(),
+		message: z.string()
+	}).nullish(),
+	model: z.string().optional(),
+	output: z.array(responsesAgentOutputItem),
+	incomplete_details: z.object({ reason: z.enum(["max_output_tokens", "content_filter"]).optional() }).nullish(),
+	usage: z.object({
+		input_tokens: z.number(),
+		output_tokens: z.number(),
+		total_tokens: z.number()
+	}).optional()
+});
+/**
+* Chunk schema
+*/
+const textDeltaChunkSchema = z.object({
+	type: z.literal("response.output_text.delta"),
+	item_id: z.string(),
+	delta: z.string(),
+	logprobs: z.unknown().nullish()
+});
+const errorChunkSchema = z.object({
+	type: z.literal("error"),
+	code: z.string(),
+	message: z.string(),
+	param: z.string().nullish(),
+	sequence_number: z.number()
+});
+const simpleErrorChunkSchema = z.object({
+	type: z.undefined().optional(),
+	error: z.string()
+});
+const responseOutputItemDoneSchema = z.object({
+	type: z.literal("response.output_item.done"),
+	output_index: z.number(),
+	item: responsesAgentOutputItem
+});
+const responseAnnotationAddedSchema = z.object({
+	type: z.literal("response.output_text.annotation.added"),
+	annotation: z.discriminatedUnion("type", [z.object({
+		type: z.literal("url_citation"),
+		url: z.string(),
+		title: z.string()
+	})])
+});
+const responseReasoningSummaryTextDeltaSchema = z.object({
+	type: z.literal("response.reasoning_summary_text.delta"),
+	item_id: z.string(),
+	summary_index: z.number(),
+	delta: z.string()
+});
+const responseFunctionCallArgumentsDeltaSchema = z.object({
+	type: z.literal("response.function_call_arguments.delta"),
+	item_id: z.string(),
+	delta: z.string(),
+	output_index: z.number(),
+	sequence_number: z.number()
+});
+const functionCallOutputChunkSchema = z.object({
+	type: z.literal("function_call_output"),
+	call_id: z.string(),
+	output: z.any()
+});
+const responsesCompletedSchema = z.object({
+	type: z.literal("responses.completed"),
+	response: z.object({
+		id: z.string(),
+		status: z.enum([
+			"completed",
+			"failed",
+			"in_progress",
+			"cancelled",
+			"queued",
+			"incomplete"
+		]).optional(),
+		incomplete_details: z.object({ reason: z.enum(["max_output_tokens", "content_filter"]).optional() }).nullish(),
+		usage: z.object({
+			input_tokens: z.number(),
+			output_tokens: z.number(),
+			total_tokens: z.number()
+		})
+	})
+});
+const responsesAgentChunkSchema = z.union([
+	textDeltaChunkSchema,
+	responseOutputItemDoneSchema,
+	responseAnnotationAddedSchema,
+	responseReasoningSummaryTextDeltaSchema,
+	responseFunctionCallArgumentsDeltaSchema,
+	functionCallOutputChunkSchema,
+	errorChunkSchema,
+	responsesCompletedSchema,
+	simpleErrorChunkSchema
+]);
+/**
+* We use a loose schema for response validation to handle unknown chunks.
+*/
+const looseResponseAgentChunkSchema = z.union([responsesAgentChunkSchema, z.object({ type: z.string() }).loose()]);
+
+//#endregion
+//#region src/mcp.ts
+/**
+* MCP Approval Utility Functions
+*
+* Shared utilities for handling MCP (Model Context Protocol) approval requests
+* and responses across client and server code.
+*/
+/** Key used in tool output to indicate approval status */
+const MCP_APPROVAL_STATUS_KEY = "__approvalStatus__";
+/** Type string for MCP approval requests in provider metadata */
+const MCP_APPROVAL_REQUEST_TYPE = "mcp_approval_request";
+/** Type string for MCP approval responses in provider metadata */
+const MCP_APPROVAL_RESPONSE_TYPE = "mcp_approval_response";
+/**
+* Check if output contains an approval status marker.
+*
+* @example
+* if (isApprovalStatusOutput(output)) {
+*   console.log(output.__approvalStatus__); // TypeScript knows this is boolean
+* }
+*/
+function isApprovalStatusOutput(output) {
+	return typeof output === "object" && output !== null && MCP_APPROVAL_STATUS_KEY in output && typeof output[MCP_APPROVAL_STATUS_KEY] === "boolean";
+}
+/**
+* Check if provider metadata indicates an MCP approval request.
+*
+* @example
+* const metadata = extractDatabricksMetadata(part);
+* if (isMcpApprovalRequest(metadata)) {
+*   // Handle MCP approval request
+* }
+*/
+function isMcpApprovalRequest(metadata) {
+	return metadata?.type?.toString() === MCP_APPROVAL_REQUEST_TYPE;
+}
+/**
+* Check if provider metadata indicates an MCP approval response.
+*/
+function isMcpApprovalResponse(metadata) {
+	return metadata?.type?.toString() === MCP_APPROVAL_RESPONSE_TYPE;
+}
+/**
+* Extract Databricks metadata from a tool call part's callProviderMetadata.
+*
+* @example
+* const metadata = extractDatabricksMetadata(part);
+* const toolName = metadata?.toolName;
+* const isMcp = isMcpApprovalRequest(metadata);
+*/
+function extractDatabricksMetadata(part) {
+	if ("callProviderMetadata" in part && part.callProviderMetadata?.databricks) return part.callProviderMetadata.databricks;
+	return void 0;
+}
+/**
+* Extract the approval status boolean from an output object.
+*
+* @returns `true` if approved, `false` if denied, `undefined` if not an approval output
+*
+* @example
+* const status = extractApprovalStatus(output);
+* if (status !== undefined) {
+*   console.log(status ? 'Approved' : 'Denied');
+* }
+*/
+function extractApprovalStatus(output) {
+	if (isApprovalStatusOutput(output)) return output[MCP_APPROVAL_STATUS_KEY];
+	return void 0;
+}
+/**
+* Extract approval status from a tool result's output value.
+* Handles the nested structure where output.type === 'json' and value contains the status.
+*
+* @example
+* const status = extractApprovalStatusFromToolResult(toolResult.output);
+*/
+function extractApprovalStatusFromToolResult(output) {
+	if (output.type === "json" && output.value && typeof output.value === "object" && MCP_APPROVAL_STATUS_KEY in output.value) {
+		const value = output.value[MCP_APPROVAL_STATUS_KEY];
+		if (typeof value === "boolean") return value;
+	}
+	return void 0;
+}
+/**
+* Create an approval status output object.
+*
+* @example
+* await addToolResult({
+*   toolCallId,
+*   output: createApprovalStatusOutput(true), // Approve
+* });
+*/
+function createApprovalStatusOutput(approve) {
+	return { [MCP_APPROVAL_STATUS_KEY]: approve };
+}
+/**
+* Determine the MCP approval state from a tool output.
+*
+* Logic:
+* - No output → 'awaiting-approval' (user hasn't responded yet)
+* - Output with __approvalStatus__: true → 'approved'
+* - Output with __approvalStatus__: false → 'denied'
+* - Output without __approvalStatus__ → 'approved' (tool executed, so it was approved)
+*
+* @example
+* const approvalState = getMcpApprovalState(part.output);
+* // 'awaiting-approval' | 'approved' | 'denied'
+*/
+function getMcpApprovalState(output) {
+	if (!output) return "awaiting-approval";
+	const status = extractApprovalStatus(output);
+	if (status === void 0) return "approved";
+	return status ? "approved" : "denied";
+}
+
+//#endregion
+//#region src/responses-agent-language-model/responses-convert-to-message-parts.ts
+const convertResponsesAgentChunkToMessagePart = (chunk) => {
+	const parts = [];
+	if ("error" in chunk) {
+		parts.push({
+			type: "error",
+			error: chunk.error
+		});
+		return parts;
+	}
+	switch (chunk.type) {
+		case "response.output_text.delta":
+			parts.push({
+				type: "text-delta",
+				id: chunk.item_id,
+				delta: chunk.delta,
+				providerMetadata: { databricks: { itemId: chunk.item_id } }
+			});
+			break;
+		case "response.reasoning_summary_text.delta":
+			parts.push({
+				type: "reasoning-delta",
+				id: chunk.item_id,
+				delta: chunk.delta,
+				providerMetadata: { databricks: { itemId: chunk.item_id } }
+			});
+			break;
+		case "function_call_output":
+			parts.push({
+				type: "tool-result",
+				toolCallId: chunk.call_id,
+				result: chunk.output,
+				toolName: DATABRICKS_TOOL_CALL_ID
+			});
+			break;
+		case "response.output_item.done":
+			parts.push(...convertOutputItemDone(chunk.item));
+			break;
+		case "response.output_text.annotation.added":
+			parts.push({
+				type: "source",
+				url: chunk.annotation.url,
+				title: chunk.annotation.title,
+				id: randomUUID(),
+				sourceType: "url"
+			});
+			break;
+		case "error":
+			parts.push({
+				type: "error",
+				error: chunk
+			});
+			break;
+		default: break;
+	}
+	return parts;
+};
+const convertOutputItemDone = (item) => {
+	switch (item.type) {
+		case "message": {
+			const firstContent = item.content[0];
+			if (!firstContent) return [];
+			return [{
+				type: "text-delta",
+				id: item.id,
+				delta: firstContent.text,
+				providerMetadata: { databricks: {
+					itemId: item.id,
+					itemType: "response.output_item.done"
+				} }
+			}];
+		}
+		case "function_call": return [{
+			type: "tool-call",
+			toolCallId: item.call_id,
+			toolName: DATABRICKS_TOOL_CALL_ID,
+			input: item.arguments,
+			providerMetadata: { databricks: {
+				toolName: item.name,
+				itemId: item.id
+			} }
+		}];
+		case "function_call_output": return [{
+			type: "tool-result",
+			toolCallId: item.call_id,
+			result: item.output,
+			toolName: DATABRICKS_TOOL_CALL_ID
+		}];
+		case "reasoning": {
+			const firstSummary = item.summary[0];
+			if (!firstSummary) return [];
+			return [
+				{
+					type: "reasoning-start",
+					id: item.id
+				},
+				{
+					type: "reasoning-delta",
+					id: item.id,
+					delta: firstSummary.text,
+					providerMetadata: { databricks: { itemId: item.id } }
+				},
+				{
+					type: "reasoning-end",
+					id: item.id
+				}
+			];
+		}
+		case "mcp_approval_request": return [{
+			type: "tool-call",
+			toolCallId: item.id,
+			toolName: DATABRICKS_TOOL_CALL_ID,
+			input: item.arguments,
+			providerMetadata: { databricks: {
+				type: MCP_APPROVAL_REQUEST_TYPE,
+				toolName: item.name,
+				itemId: item.id,
+				serverLabel: item.server_label
+			} }
+		}];
+		case "mcp_approval_response": return [{
+			type: "tool-result",
+			toolCallId: item.approval_request_id,
+			toolName: DATABRICKS_TOOL_CALL_ID,
+			result: createApprovalStatusOutput(item.approve),
+			providerMetadata: { databricks: {
+				type: MCP_APPROVAL_RESPONSE_TYPE,
+				...item.id != null && { itemId: item.id }
+			} }
+		}];
+		default: return [];
+	}
+};
+const convertResponsesAgentResponseToMessagePart = (response) => {
+	const parts = [];
+	for (const output of response.output) switch (output.type) {
+		case "message": {
+			for (const content of output.content) if (content.type === "output_text") parts.push({
+				type: "text",
+				text: content.text,
+				providerMetadata: { databricks: { itemId: output.id } }
+			});
+			break;
+		}
+		case "function_call":
+			parts.push({
+				type: "tool-call",
+				toolCallId: output.call_id,
+				toolName: output.name,
+				input: output.arguments,
+				providerMetadata: { databricks: { itemId: output.id } }
+			});
+			break;
+		case "reasoning":
+			for (const summary of output.summary) if (summary.type === "summary_text") parts.push({
+				type: "reasoning",
+				text: summary.text,
+				providerMetadata: { databricks: { itemId: output.id } }
+			});
+			break;
+		case "function_call_output":
+			parts.push({
+				type: "tool-result",
+				result: output.output,
+				toolCallId: output.call_id,
+				toolName: DATABRICKS_TOOL_CALL_ID
+			});
+			break;
+		case "mcp_approval_request":
+			parts.push({
+				type: "tool-call",
+				toolCallId: output.id,
+				toolName: DATABRICKS_TOOL_CALL_ID,
+				input: output.arguments,
+				providerMetadata: { databricks: {
+					type: MCP_APPROVAL_REQUEST_TYPE,
+					toolName: output.name,
+					itemId: output.id,
+					serverLabel: output.server_label
+				} }
+			});
+			break;
+		case "mcp_approval_response":
+			parts.push({
+				type: "tool-result",
+				toolCallId: output.approval_request_id,
+				toolName: DATABRICKS_TOOL_CALL_ID,
+				result: createApprovalStatusOutput(output.approve),
+				providerMetadata: { databricks: {
+					type: MCP_APPROVAL_RESPONSE_TYPE,
+					...output.id != null && { itemId: output.id }
+				} }
+			});
+			break;
+		default: break;
+	}
+	return parts;
+};
+
+//#endregion
+//#region src/responses-agent-language-model/responses-convert-to-input.ts
+async function convertToResponsesInput({ prompt, systemMessageMode }) {
+	const input = [];
+	const warnings = [];
+	const toolCallResultsByToolCallId = prompt.filter((p) => p.role === "tool").flatMap((p) => p.content).reduce((reduction, toolCallResult) => {
+		if (toolCallResult.type === "tool-result") reduction[toolCallResult.toolCallId] = toolCallResult;
+		return reduction;
+	}, {});
+	for (const { role, content } of prompt) switch (role) {
+		case "system": {
+			switch (systemMessageMode) {
+				case "system":
+					input.push({
+						role: "system",
+						content
+					});
+					break;
+				case "developer":
+					input.push({
+						role: "developer",
+						content
+					});
+					break;
+				case "remove":
+					warnings.push({
+						type: "other",
+						message: "system messages are removed for this model"
+					});
+					break;
+				default: {
+					const _exhaustiveCheck = systemMessageMode;
+					throw new Error(`Unsupported system message mode: ${String(_exhaustiveCheck)}`);
+				}
+			}
+			break;
+		}
+		case "user":
+			input.push({
+				role: "user",
+				content: content.map((part) => {
+					switch (part.type) {
+						case "text": return {
+							type: "input_text",
+							text: part.text
+						};
+						default: throw new UnsupportedFunctionalityError({ functionality: `part ${JSON.stringify(part)}` });
+					}
+				})
+			});
+			break;
+		case "assistant":
+			for (const part of content) {
+				const providerOptions = await parseProviderOptions({
+					provider: "databricks",
+					providerOptions: part.providerOptions,
+					schema: ProviderOptionsSchema
+				});
+				const itemId = providerOptions?.itemId ?? void 0;
+				switch (part.type) {
+					case "text": {
+						input.push({
+							role: "assistant",
+							content: [{
+								type: "output_text",
+								text: part.text
+							}],
+							id: itemId
+						});
+						break;
+					}
+					case "tool-call": {
+						const toolName = providerOptions?.toolName ?? part.toolName;
+						if (providerOptions?.type === MCP_APPROVAL_REQUEST_TYPE) {
+							const serverLabel = providerOptions?.serverLabel ?? "";
+							const argumentsString = JSON.stringify(part.input);
+							const id = part.toolCallId;
+							input.push({
+								type: MCP_APPROVAL_REQUEST_TYPE,
+								id,
+								name: toolName,
+								arguments: argumentsString,
+								server_label: serverLabel
+							});
+							const toolResult = toolCallResultsByToolCallId[part.toolCallId];
+							if (toolResult) {
+								/**
+								* The tool call result is either the approval status or the actual output from the tool call.
+								* If it's the approval status, we need to add an approval response part.
+								* If it's the tool call output, we don't include the approval response part but we do include the tool call output part.
+								*/
+								const approvalStatus = extractApprovalStatusFromToolResult(toolResult.output);
+								if (approvalStatus !== void 0) input.push({
+									type: MCP_APPROVAL_RESPONSE_TYPE,
+									id: toolResult.toolCallId,
+									approval_request_id: toolResult.toolCallId,
+									approve: approvalStatus
+								});
+								else input.push({
+									type: "function_call_output",
+									call_id: toolResult.toolCallId,
+									output: convertToolResultOutputToString(toolResult.output)
+								});
+							}
+							break;
+						}
+						input.push({
+							type: "function_call",
+							call_id: part.toolCallId,
+							name: toolName,
+							arguments: JSON.stringify(part.input),
+							id: itemId
+						});
+						const toolCallResult = toolCallResultsByToolCallId[part.toolCallId];
+						if (toolCallResult) input.push({
+							type: "function_call_output",
+							call_id: part.toolCallId,
+							output: convertToolResultOutputToString(toolCallResult.output)
+						});
+						break;
+					}
+					case "tool-result": {
+						if (providerOptions?.type === MCP_APPROVAL_RESPONSE_TYPE) {
+							const approvalRequestId = providerOptions?.approvalRequestId ?? part.toolCallId;
+							const approve = providerOptions?.approve ?? false;
+							const reason = providerOptions?.reason ?? "";
+							input.push({
+								type: MCP_APPROVAL_RESPONSE_TYPE,
+								id: approvalRequestId,
+								approval_request_id: approvalRequestId,
+								approve,
+								reason
+							});
+							break;
+						}
+						input.push({
+							type: "function_call_output",
+							call_id: part.toolCallId,
+							output: convertToolResultOutputToString(part.output)
+						});
+						break;
+					}
+					case "reasoning": {
+						if (!itemId) break;
+						input.push({
+							type: "reasoning",
+							summary: [{
+								type: "summary_text",
+								text: part.text
+							}],
+							id: itemId
+						});
+						break;
+					}
+				}
+			}
+			break;
+		case "tool": break;
+		default: {
+			const _exhaustiveCheck = role;
+			throw new Error(`Unsupported role: ${String(_exhaustiveCheck)}`);
+		}
+	}
+	return {
+		input,
+		warnings
+	};
+}
+const ProviderOptionsSchema = z.object({
+	itemId: z.string().nullish(),
+	toolName: z.string().nullish(),
+	type: z.enum(["mcp_approval_request", "mcp_approval_response"]).nullish(),
+	serverLabel: z.string().nullish(),
+	approvalRequestId: z.string().nullish(),
+	approve: z.boolean().nullish(),
+	reason: z.string().nullish()
+});
+const convertToolResultOutputToString = (output) => {
+	switch (output.type) {
+		case "text":
+		case "error-text": return output.value;
+		default: return JSON.stringify(output.value);
+	}
+};
+
+//#endregion
+//#region src/responses-agent-language-model/responses-agent-language-model.ts
+function mapResponsesFinishReason({ finishReason, hasToolCalls }) {
+	switch (finishReason) {
+		case void 0:
+		case null: return hasToolCalls ? "tool-calls" : "stop";
+		case "max_output_tokens": return "length";
+		case "content_filter": return "content-filter";
+		default: return hasToolCalls ? "tool-calls" : "other";
+	}
+}
+var DatabricksResponsesAgentLanguageModel = class {
+	specificationVersion = "v2";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	supportedUrls = {};
+	async doGenerate(options) {
+		const networkArgs = await this.getArgs({
+			config: this.config,
+			options,
+			stream: false,
+			modelId: this.modelId
+		});
+		const { value: response } = await postJsonToApi({
+			...networkArgs,
+			successfulResponseHandler: createJsonResponseHandler(responsesAgentResponseSchema),
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: z.any(),
+				errorToMessage: (error) => JSON.stringify(error),
+				isRetryable: () => false
+			})
+		});
+		const content = convertResponsesAgentResponseToMessagePart(response);
+		const hasToolCalls = content.some((p) => p.type === "tool-call");
+		return {
+			content,
+			finishReason: mapResponsesFinishReason({
+				finishReason: response.incomplete_details?.reason,
+				hasToolCalls
+			}),
+			usage: {
+				inputTokens: response.usage?.input_tokens ?? 0,
+				outputTokens: response.usage?.output_tokens ?? 0,
+				totalTokens: response.usage?.total_tokens ?? 0
+			},
+			warnings: []
+		};
+	}
+	async doStream(options) {
+		const networkArgs = await this.getArgs({
+			config: this.config,
+			options,
+			stream: true,
+			modelId: this.modelId
+		});
+		const { responseHeaders, value: response } = await postJsonToApi({
+			...networkArgs,
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: z.any(),
+				errorToMessage: (error) => JSON.stringify(error),
+				isRetryable: () => false
+			}),
+			successfulResponseHandler: createEventSourceResponseHandler(looseResponseAgentChunkSchema),
+			abortSignal: options.abortSignal
+		});
+		let finishReason = "unknown";
+		const usage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0
+		};
+		const allParts = [];
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings: []
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = "error";
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					if (chunk.value.type === "responses.completed") {
+						const hasToolCalls = allParts.some((p) => p.type === "tool-call");
+						finishReason = mapResponsesFinishReason({
+							finishReason: chunk.value.response.incomplete_details?.reason,
+							hasToolCalls
+						});
+						usage.inputTokens = chunk.value.response.usage.input_tokens;
+						usage.outputTokens = chunk.value.response.usage.output_tokens;
+						usage.totalTokens = chunk.value.response.usage.total_tokens;
+						return;
+					}
+					const parts = convertResponsesAgentChunkToMessagePart(chunk.value);
+					allParts.push(...parts);
+					/**
+					* Check if the last chunk was a tool result without a tool call
+					* This is a special case for MCP approval requests where the tool result
+					* is sent in a separate call after the tool call was approved/denied.
+					*/
+					if (parts.length === 0) return;
+					const part = parts[0];
+					if (part.type === "tool-result") {
+						const matchingToolCallInParts = parts.find((c) => c.type === "tool-call" && c.toolCallId === part.toolCallId);
+						const matchingToolCallInStream = allParts.find((c) => c.type === "tool-call" && c.toolCallId === part.toolCallId);
+						if (!matchingToolCallInParts && !matchingToolCallInStream) {
+							const toolCallFromPreviousMessages = options.prompt.flatMap((message) => {
+								if (typeof message.content === "string") return [];
+								return message.content;
+							}).find((p) => p.type === "tool-call" && p.toolCallId === part.toolCallId);
+							if (!toolCallFromPreviousMessages) throw new Error("No matching tool call found in previous message");
+							if (toolCallFromPreviousMessages.type === "tool-call") controller.enqueue({
+								...toolCallFromPreviousMessages,
+								input: JSON.stringify(toolCallFromPreviousMessages.input)
+							});
+						}
+					}
+					if (shouldDedupeOutputItemDone(parts, allParts.slice(0, -parts.length))) return;
+					for (const part$1 of parts) controller.enqueue(part$1);
+				},
+				flush(controller) {
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage
+					});
+				}
+			})).pipeThrough(getDatabricksLanguageModelTransformStream()),
+			request: { body: networkArgs.body },
+			response: { headers: responseHeaders }
+		};
+	}
+	async getArgs({ config, options, stream, modelId }) {
+		const { input } = await convertToResponsesInput({
+			prompt: options.prompt,
+			systemMessageMode: "system"
+		});
+		return {
+			url: config.url({ path: "/responses" }),
+			headers: combineHeaders(config.headers(), options.headers),
+			body: {
+				model: modelId,
+				input,
+				stream
+			},
+			fetch: config.fetch
+		};
+	}
+};
+function shouldDedupeOutputItemDone(incomingParts, previousParts) {
+	const doneTextDelta = incomingParts.find((p) => p.type === "text-delta" && p.providerMetadata?.databricks?.itemType === "response.output_item.done");
+	if (!doneTextDelta || doneTextDelta.type !== "text-delta" || !doneTextDelta.id) return false;
+	/**
+	* To determine if the text in response.output_item.done is a duplicate, we need to reconstruct the text from the
+	* previous consecutive text-deltas and check if the .done text is already present in what we've streamed.
+	*
+	* The caveat is that the response.output_item.done text uses GFM footnote syntax, where as the streamed content
+	* uses response.output_text.delta and response.output_text.annotation.added events. So we reconstruct all the
+	* delta text and check if the .done text is contained in it (meaning we've already streamed it).
+	*
+	* We only consider text-deltas that came AFTER the last response.output_item.done event, since each .done
+	* corresponds to a specific message and we should only compare against text streamed for that message.
+	*/
+	const lastDoneIndex = previousParts.findLastIndex((part) => part.type === "text-delta" && part.providerMetadata?.databricks?.itemType === "response.output_item.done");
+	const partsAfterLastDone = previousParts.slice(lastDoneIndex + 1);
+	const { texts: reconstructuredTexts, current } = partsAfterLastDone.reduce((acc, part) => {
+		if (part.type === "text-delta") return {
+			...acc,
+			current: acc.current + part.delta
+		};
+		else if (acc.current.trim().length > 0) return {
+			texts: [...acc.texts, acc.current.trim()],
+			current: ""
+		};
+		return acc;
+	}, {
+		texts: [],
+		current: ""
+	});
+	reconstructuredTexts.push(current);
+	if (reconstructuredTexts.length === 0) return false;
+	const allTextsFoundInOrder = reconstructuredTexts.reduce((acc, text) => {
+		if (!acc.found) return acc;
+		const index = doneTextDelta.delta.indexOf(text, acc.lastIndex);
+		if (index === -1) return {
+			found: false,
+			lastIndex: acc.lastIndex
+		};
+		return {
+			found: true,
+			lastIndex: index + text.length
+		};
+	}, {
+		found: true,
+		lastIndex: 0
+	});
+	return allTextsFoundInOrder.found;
+}
+
+//#endregion
+//#region src/fmapi-language-model/fmapi-schema.ts
+const toolCallSchema = z.object({
+	id: z.string(),
+	type: z.literal("function"),
+	function: z.object({
+		name: z.string(),
+		arguments: z.string()
+	})
+});
+const reasoningSummarySchema = z.discriminatedUnion("type", [z.object({
+	type: z.literal("summary_text"),
+	text: z.string(),
+	signature: z.string().optional()
+}), z.object({
+	type: z.literal("summary_encrypted_text"),
+	data: z.string()
+})]);
+const contentItemSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("text"),
+		text: z.string(),
+		citation: z.unknown().optional()
+	}),
+	z.object({
+		type: z.literal("image"),
+		image_url: z.string()
+	}),
+	z.object({
+		type: z.literal("reasoning"),
+		summary: z.array(reasoningSummarySchema)
+	})
+]);
+const toolCallDeltaSchema = z.object({
+	index: z.number(),
+	id: z.string().optional(),
+	type: z.literal("function").optional(),
+	function: z.object({
+		name: z.string().optional(),
+		arguments: z.string().optional()
+	}).optional()
+});
+const fmapiChunkSchema = z.object({
+	id: z.string(),
+	created: z.number(),
+	model: z.string(),
+	usage: z.object({
+		prompt_tokens: z.number(),
+		completion_tokens: z.number(),
+		total_tokens: z.number()
+	}).nullable().optional(),
+	object: z.literal("chat.completion.chunk"),
+	choices: z.array(z.object({
+		index: z.number(),
+		delta: z.object({
+			role: z.union([
+				z.literal("assistant"),
+				z.null(),
+				z.undefined()
+			]).optional(),
+			content: z.union([
+				z.string(),
+				z.array(contentItemSchema),
+				z.null()
+			]).optional(),
+			tool_calls: z.array(toolCallDeltaSchema).optional()
+		}),
+		finish_reason: z.union([
+			z.literal("stop"),
+			z.literal("tool_calls"),
+			z.null()
+		]).optional()
+	}))
+});
+const fmapiResponseSchema = z.object({
+	id: z.string(),
+	created: z.number(),
+	model: z.string(),
+	usage: z.object({
+		prompt_tokens: z.number(),
+		completion_tokens: z.number(),
+		total_tokens: z.number()
+	}).nullable().optional(),
+	choices: z.array(z.object({
+		message: z.object({
+			role: z.union([
+				z.literal("assistant"),
+				z.literal("user"),
+				z.literal("tool")
+			]),
+			content: z.union([
+				z.string(),
+				z.array(contentItemSchema),
+				z.null()
+			]).optional(),
+			tool_calls: z.array(toolCallSchema).optional()
+		}),
+		finish_reason: z.union([
+			z.literal("stop"),
+			z.literal("tool_calls"),
+			z.null()
+		]).optional()
+	}))
+});
+
+//#endregion
+//#region src/fmapi-language-model/fmapi-tags.ts
+const TAGS = {
+	LEGACY_CALL_OPEN: "<uc_function_call>",
+	LEGACY_CALL_CLOSE: "</uc_function_call>",
+	LEGACY_RESULT_OPEN: "<uc_function_result>",
+	LEGACY_RESULT_CLOSE: "</uc_function_result>",
+	CALL_OPEN: "<tool_call>",
+	CALL_CLOSE: "</tool_call>",
+	RESULT_OPEN: "<tool_call_result>",
+	RESULT_CLOSE: "</tool_call_result>"
+};
+const tagSplitRegex = new RegExp(`(${escapeRegex(TAGS.LEGACY_CALL_OPEN)}.*?${escapeRegex(TAGS.LEGACY_CALL_CLOSE)}|${escapeRegex(TAGS.LEGACY_RESULT_OPEN)}.*?${escapeRegex(TAGS.LEGACY_RESULT_CLOSE)}|${escapeRegex(TAGS.CALL_OPEN)}.*?${escapeRegex(TAGS.CALL_CLOSE)}|${escapeRegex(TAGS.RESULT_OPEN)}.*?${escapeRegex(TAGS.RESULT_CLOSE)})`, "g");
+function parseTaggedToolCall(text) {
+	const inner = stripEnclosingTag(text, TAGS.LEGACY_CALL_OPEN, TAGS.LEGACY_CALL_CLOSE) ?? stripEnclosingTag(text, TAGS.CALL_OPEN, TAGS.CALL_CLOSE);
+	if (inner == null) return null;
+	try {
+		const parsed = JSON.parse(inner);
+		if (parsed && typeof parsed === "object" && "id" in parsed && "name" in parsed) return {
+			id: String(parsed.id),
+			name: String(parsed.name),
+			arguments: parsed.arguments
+		};
+	} catch {}
+	return null;
+}
+function parseTaggedToolResult(text) {
+	const inner = stripEnclosingTag(text, TAGS.LEGACY_RESULT_OPEN, TAGS.LEGACY_RESULT_CLOSE) ?? stripEnclosingTag(text, TAGS.RESULT_OPEN, TAGS.RESULT_CLOSE);
+	if (inner == null) return null;
+	try {
+		const parsed = JSON.parse(inner);
+		if (parsed && typeof parsed === "object" && "id" in parsed) return {
+			id: String(parsed.id),
+			content: parsed.content
+		};
+	} catch {}
+	return null;
+}
+function serializeToolCall(value) {
+	const payload = JSON.stringify({
+		id: value.id,
+		name: value.name,
+		arguments: value.arguments
+	});
+	return `${TAGS.CALL_OPEN}${payload}${TAGS.CALL_CLOSE}`;
+}
+function serializeToolResult(value) {
+	const payload = JSON.stringify({
+		id: value.id,
+		content: value.content
+	});
+	return `${TAGS.RESULT_OPEN}${payload}${TAGS.RESULT_CLOSE}`;
+}
+function stripEnclosingTag(text, open, close) {
+	const trimmed = text.trim();
+	if (trimmed.startsWith(open) && trimmed.endsWith(close)) return trimmed.slice(open.length, trimmed.length - close.length);
+	return null;
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+//#region src/fmapi-language-model/fmapi-convert-to-message-parts.ts
+const convertFmapiChunkToMessagePart = (chunk, toolCallIdsByIndex) => {
+	const parts = [];
+	if (chunk.choices.length === 0) return parts;
+	const choice = chunk.choices[0];
+	if (choice.delta.tool_calls && choice.delta.tool_calls.length > 0) for (const toolCallDelta of choice.delta.tool_calls) {
+		const index = toolCallDelta.index;
+		if (toolCallDelta.id && toolCallDelta.function?.name) {
+			toolCallIdsByIndex?.set(index, toolCallDelta.id);
+			parts.push({
+				type: "tool-input-start",
+				id: toolCallDelta.id,
+				toolName: toolCallDelta.function.name
+			});
+		}
+		if (toolCallDelta.function?.arguments) {
+			const id = toolCallDelta.id ?? toolCallIdsByIndex?.get(index) ?? `tool-call-${index}`;
+			parts.push({
+				type: "tool-input-delta",
+				id,
+				delta: toolCallDelta.function.arguments
+			});
+		}
+	}
+	if (typeof choice.delta.content === "string") {
+		const extracted = extractPartsFromTextCompletion(choice.delta.content);
+		for (const part of extracted) if (part.type === "text") parts.push({
+			type: "text-delta",
+			id: chunk.id,
+			delta: part.text
+		});
+		else parts.push(part);
+	} else if (Array.isArray(choice.delta.content)) parts.push(...mapContentItemsToStreamParts(choice.delta.content, chunk.id));
+	return parts;
+};
+const convertFmapiResponseToMessagePart = (response) => {
+	const parts = [];
+	if (response.choices.length === 0) return parts;
+	const choice = response.choices[0];
+	if (choice.message.tool_calls && choice.message.tool_calls.length > 0) {
+		for (const toolCall of choice.message.tool_calls) parts.push(convertToolCallToContent(toolCall));
+		if (typeof choice.message.content === "string" && choice.message.content) parts.push({
+			type: "text",
+			text: choice.message.content
+		});
+		return parts;
+	}
+	if (typeof choice.message.content === "string") {
+		const extracted = extractToolPartsFromText(choice.message.content);
+		if (extracted) for (const part of extracted) parts.push(part);
+		else parts.push({
+			type: "text",
+			text: choice.message.content
+		});
+	} else parts.push(...mapContentItemsToProviderContent(choice.message.content ?? []));
+	return parts;
+};
+const convertToolCallToContent = (toolCall) => {
+	return {
+		type: "tool-call",
+		toolCallId: toolCall.id,
+		toolName: toolCall.function.name,
+		input: toolCall.function.arguments
+	};
+};
+const extractPartsFromTextCompletion = (text) => {
+	const parts = text.split(tagSplitRegex);
+	const accumulated = [];
+	for (const segment of parts.filter((p) => p !== "")) {
+		const toolParts = extractToolPartsFromText(segment);
+		if (toolParts) accumulated.push(...toolParts);
+		else accumulated.push({
+			type: "text",
+			text: segment
+		});
+	}
+	return accumulated;
+};
+const extractToolPartsFromText = (text) => {
+	const trimmed = text.trim();
+	const call = parseTaggedToolCall(trimmed);
+	if (call) return [{
+		type: "tool-call",
+		input: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments),
+		toolName: call.name,
+		toolCallId: call.id,
+		providerExecuted: true
+	}];
+	const result = parseTaggedToolResult(trimmed);
+	if (result) return [{
+		type: "tool-result",
+		result: result.content,
+		toolCallId: result.id,
+		toolName: DATABRICKS_TOOL_CALL_ID
+	}];
+	return null;
+};
+const mapContentItemsToStreamParts = (items, id) => {
+	const parts = [];
+	for (const item of items) switch (item.type) {
+		case "text":
+			parts.push({
+				type: "text-delta",
+				id,
+				delta: item.text
+			});
+			break;
+		case "image": break;
+		case "reasoning": {
+			for (const summary of item.summary.filter((s) => s.type === "summary_text")) parts.push({
+				type: "reasoning-delta",
+				id,
+				delta: summary.text
+			});
+			break;
+		}
+	}
+	return parts;
+};
+const mapContentItemsToProviderContent = (items) => {
+	const parts = [];
+	for (const item of items) switch (item.type) {
+		case "text":
+			parts.push({
+				type: "text",
+				text: item.text
+			});
+			break;
+		case "image": break;
+		case "reasoning": {
+			for (const summary of item.summary.filter((s) => s.type === "summary_text")) parts.push({
+				type: "reasoning",
+				text: summary.text
+			});
+			break;
+		}
+	}
+	return parts;
+};
+
+//#endregion
+//#region src/fmapi-language-model/fmapi-convert-to-input.ts
+const convertPromptToFmapiMessages = (prompt) => {
+	const messages = prompt.map((message) => {
+		const role = message.role === "system" ? "user" : message.role;
+		let contentItems = [];
+		switch (message.role) {
+			case "system":
+				contentItems = convertSystemContent(message);
+				break;
+			case "user":
+				contentItems = convertUserContent(message);
+				break;
+			case "assistant":
+				contentItems = convertAssistantContent(message);
+				break;
+			case "tool":
+				contentItems = convertToolContent(message);
+				break;
+		}
+		const content = contentItems.length === 0 ? "" : contentItems;
+		return {
+			role,
+			content
+		};
+	});
+	return { messages };
+};
+const convertSystemContent = (message) => {
+	return [{
+		type: "text",
+		text: message.content
+	}];
+};
+const convertUserContent = (message) => {
+	const items = [];
+	for (const part of message.content) switch (part.type) {
+		case "text":
+			items.push({
+				type: "text",
+				text: part.text
+			});
+			break;
+		case "file":
+			if (part.mediaType.startsWith("image/")) {
+				const url = toHttpUrlString(part.data);
+				if (url) items.push({
+					type: "image",
+					image_url: url
+				});
+			}
+			break;
+	}
+	return items;
+};
+const convertAssistantContent = (message) => {
+	const items = [];
+	for (const part of message.content) switch (part.type) {
+		case "text":
+			items.push({
+				type: "text",
+				text: part.text
+			});
+			break;
+		case "file":
+			if (part.mediaType.startsWith("image/")) {
+				const url = toHttpUrlString(part.data);
+				if (url) items.push({
+					type: "image",
+					image_url: url
+				});
+			}
+			break;
+		case "reasoning":
+			items.push({
+				type: "reasoning",
+				summary: [{
+					type: "summary_text",
+					text: part.text
+				}]
+			});
+			break;
+		case "tool-call":
+			items.push({
+				type: "text",
+				text: serializeToolCall({
+					id: part.toolCallId,
+					name: part.toolName,
+					arguments: part.input
+				})
+			});
+			break;
+		case "tool-result":
+			items.push({
+				type: "text",
+				text: serializeToolResult({
+					id: part.toolCallId,
+					content: convertToolResultOutputToContentValue(part.output)
+				})
+			});
+			break;
+	}
+	return items;
+};
+const convertToolContent = (message) => {
+	const items = [];
+	for (const part of message.content) if (part.type === "tool-result") items.push({
+		type: "text",
+		text: serializeToolResult({
+			id: part.toolCallId,
+			content: convertToolResultOutputToContentValue(part.output)
+		})
+	});
+	return items;
+};
+const toHttpUrlString = (data) => {
+	if (data instanceof URL) return data.toString();
+	if (typeof data === "string") {
+		if (data.startsWith("http://") || data.startsWith("https://")) return data;
+	}
+	return null;
+};
+const convertToolResultOutputToContentValue = (output) => {
+	switch (output.type) {
+		case "text":
+		case "error-text": return output.value;
+		case "json":
+		case "error-json": return output.value;
+		case "content": return output.value;
+		default: return null;
+	}
+};
+
+//#endregion
+//#region src/fmapi-language-model/fmapi-language-model.ts
+var DatabricksFmapiLanguageModel = class {
+	specificationVersion = "v2";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	supportedUrls = {};
+	async doGenerate(options) {
+		const networkArgs = this.getArgs({
+			config: this.config,
+			options,
+			stream: false,
+			modelId: this.modelId
+		});
+		const { value: response } = await postJsonToApi({
+			...networkArgs,
+			successfulResponseHandler: createJsonResponseHandler(fmapiResponseSchema),
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: z.any(),
+				errorToMessage: (error) => JSON.stringify(error),
+				isRetryable: () => false
+			})
+		});
+		const choice = response.choices[0];
+		let finishReason = "stop";
+		if (choice?.finish_reason === "tool_calls") finishReason = "tool-calls";
+		return {
+			content: convertFmapiResponseToMessagePart(response),
+			finishReason,
+			usage: {
+				inputTokens: response.usage?.prompt_tokens ?? 0,
+				outputTokens: response.usage?.completion_tokens ?? 0,
+				totalTokens: response.usage?.total_tokens ?? 0
+			},
+			warnings: []
+		};
+	}
+	async doStream(options) {
+		const networkArgs = this.getArgs({
+			config: this.config,
+			options,
+			stream: true,
+			modelId: this.modelId
+		});
+		const { responseHeaders, value: response } = await postJsonToApi({
+			...networkArgs,
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: z.any(),
+				errorToMessage: (error) => JSON.stringify(error),
+				isRetryable: () => false
+			}),
+			successfulResponseHandler: createEventSourceResponseHandler(fmapiChunkSchema),
+			abortSignal: options.abortSignal
+		});
+		let finishReason = "unknown";
+		let usage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0
+		};
+		const toolCallIdsByIndex = new Map();
+		const toolCallNamesById = new Map();
+		const toolCallInputsById = new Map();
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings: []
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = "error";
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const choice = chunk.value.choices[0];
+					if (choice?.finish_reason === "stop") finishReason = "stop";
+					else if (choice?.finish_reason === "tool_calls") finishReason = "tool-calls";
+					if (chunk.value.usage) usage = {
+						inputTokens: chunk.value.usage.prompt_tokens,
+						outputTokens: chunk.value.usage.completion_tokens,
+						totalTokens: chunk.value.usage.total_tokens
+					};
+					const parts = convertFmapiChunkToMessagePart(chunk.value, toolCallIdsByIndex);
+					for (const part of parts) {
+						if (part.type === "tool-input-start") {
+							toolCallNamesById.set(part.id, part.toolName);
+							toolCallInputsById.set(part.id, "");
+						} else if (part.type === "tool-input-delta") {
+							const current = toolCallInputsById.get(part.id) ?? "";
+							toolCallInputsById.set(part.id, current + part.delta);
+						}
+						controller.enqueue(part);
+					}
+				},
+				flush(controller) {
+					for (const [toolCallId, inputText] of toolCallInputsById) {
+						const toolName = toolCallNamesById.get(toolCallId);
+						if (toolName) {
+							controller.enqueue({
+								type: "tool-input-end",
+								id: toolCallId
+							});
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId,
+								toolName,
+								input: inputText
+							});
+						}
+					}
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage
+					});
+				}
+			})).pipeThrough(getDatabricksLanguageModelTransformStream()),
+			request: { body: networkArgs.body },
+			response: { headers: responseHeaders }
+		};
+	}
+	getArgs({ config, options, stream, modelId }) {
+		const tools = options.tools?.map((tool) => convertToolToOpenAIFormat(tool)).filter((tool) => tool !== void 0);
+		const toolChoice = options.toolChoice ? convertToolChoiceToOpenAIFormat(options.toolChoice) : void 0;
+		return {
+			url: config.url({ path: "/chat/completions" }),
+			headers: combineHeaders(config.headers(), options.headers),
+			body: {
+				messages: convertPromptToFmapiMessages(options.prompt).messages,
+				stream,
+				model: modelId,
+				...tools && tools.length > 0 ? { tools } : {},
+				...toolChoice && tools && tools.length > 0 ? { tool_choice: toolChoice } : {},
+				...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+				...options.maxOutputTokens !== void 0 ? { max_tokens: options.maxOutputTokens } : {},
+				...options.stopSequences && options.stopSequences.length > 0 ? { stop: options.stopSequences } : {}
+			},
+			fetch: config.fetch
+		};
+	}
+};
+/**
+* Convert AI SDK tool to OpenAI format
+*/
+function convertToolToOpenAIFormat(tool) {
+	if (tool.type === "provider-defined" || tool.name === DATABRICKS_TOOL_CALL_ID) return void 0;
+	return {
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema
+		}
+	};
+}
+/**
+* Convert AI SDK tool choice to OpenAI format
+*/
+function convertToolChoiceToOpenAIFormat(toolChoice) {
+	if (toolChoice.type === "auto") return "auto";
+	if (toolChoice.type === "none") return "none";
+	if (toolChoice.type === "required") return "required";
+	if (toolChoice.type === "tool") return {
+		type: "function",
+		function: { name: toolChoice.toolName }
+	};
+	return "auto";
+}
+
+//#endregion
+//#region src/databricks-provider.ts
+const createDatabricksProvider = (settings) => {
+	const baseUrl = withoutTrailingSlash(settings.baseURL);
+	const getHeaders = () => combineHeaders(settings.headers);
+	const fetch = settings.fetch;
+	const provider = settings.provider ?? "databricks";
+	const formatUrl = ({ path }) => settings.formatUrl?.({
+		baseUrl,
+		path
+	}) ?? `${baseUrl}${path}`;
+	const createChatAgent = (modelId) => new DatabricksChatAgentLanguageModel(modelId, {
+		url: formatUrl,
+		headers: getHeaders,
+		fetch,
+		provider
+	});
+	const createResponsesAgent = (modelId) => new DatabricksResponsesAgentLanguageModel(modelId, {
+		url: formatUrl,
+		headers: getHeaders,
+		fetch,
+		provider
+	});
+	const createFmapi = (modelId) => new DatabricksFmapiLanguageModel(modelId, {
+		url: formatUrl,
+		headers: getHeaders,
+		fetch,
+		provider
+	});
+	const notImplemented = (name) => {
+		return () => {
+			throw new Error(`${name} is not supported yet`);
+		};
+	};
+	return {
+		chatAgent: createChatAgent,
+		responsesAgent: createResponsesAgent,
+		fmapi: createFmapi,
+		imageModel: notImplemented("ImageModel"),
+		textEmbeddingModel: notImplemented("TextEmbeddingModel"),
+		languageModel: notImplemented("LanguageModel")
+	};
+};
+
+//#endregion
+export { DATABRICKS_TOOL_CALL_ID, DATABRICKS_TOOL_DEFINITION, MCP_APPROVAL_REQUEST_TYPE, MCP_APPROVAL_RESPONSE_TYPE, MCP_APPROVAL_STATUS_KEY, createApprovalStatusOutput, createDatabricksProvider, extractApprovalStatus, extractApprovalStatusFromToolResult, extractDatabricksMetadata, getMcpApprovalState, isApprovalStatusOutput, isMcpApprovalRequest, isMcpApprovalResponse };
+//# sourceMappingURL=index.js.map