@terminaluse/vercel-ai-sdk-provider 0.3.0 → 0.4.1

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { TerminalUse } from "@terminaluse/sdk";
 import { LanguageModel } from "ai";
+import { TerminalUse } from "@terminaluse/sdk";
 
 //#region src/provider.d.ts
 interface TerminalUseProviderConfig {
@@ -19,6 +19,12 @@ interface TerminalUseProvider {
 interface TerminalUseProviderOptions {
   /** Task ID to send messages to (required) */
   taskId: string;
+  /** Skip task event dispatch and only stream task output */
+  skipSend?: boolean;
+  /** Optional absolute URL override for stream endpoint */
+  streamUrl?: string;
+  /** Optional headers for stream requests (e.g. bridge auth) */
+  streamHeaders?: Record<string, string>;
   /**
    * Optional override for the outbound task event. If omitted, provider sends
    * a text event derived from the latest prompt message (default behavior).

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { TerminalUseClient } from "@terminaluse/sdk";
 import { UnsupportedFunctionalityError } from "ai";
 import { createEventSourceResponseHandler, getFromApi } from "@ai-sdk/provider-utils";
 import { z } from "zod";
+import { TerminalUseClient } from "@terminaluse/sdk";
 
 //#region src/ndjson-stream.ts
 /**
@@ -50,6 +50,14 @@ const finishPartSchema = z.object({
 	totalUsage: streamUsageSchema,
 	metadata: streamMetadataSchema
 });
+const handlerCompletePartSchema = z.object({
+	type: z.literal("handler-complete"),
+	eventId: z.string(),
+	taskId: z.string(),
+	success: z.boolean(),
+	durationMs: z.number().int().nullable().optional(),
+	error: z.string().nullable().optional()
+});
 const textStartPartSchema = z.object({
 	type: z.literal("text-start"),
 	id: z.string(),
@@ -127,6 +135,7 @@ const textStreamPartSchema = z.discriminatedUnion("type", [
 	startStepPartSchema,
 	finishStepPartSchema,
 	finishPartSchema,
+	handlerCompletePartSchema,
 	textStartPartSchema,
 	textDeltaPartSchema,
 	textEndPartSchema,
@@ -145,10 +154,14 @@ const textStreamPartSchema = z.discriminatedUnion("type", [
 * Uses @ai-sdk/provider-utils for SSE parsing.
 */
 async function* createTaskEventGenerator(config, taskId, options = {}) {
-	const { signal } = options;
+	const { signal, streamUrl, streamHeaders } = options;
+	const headers = {
+		...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+		...streamHeaders ?? {}
+	};
 	const { value: responseStream } = await getFromApi({
-		url: `${config.baseURL}/tasks/${encodeURIComponent(taskId)}/stream`,
-		headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+		url: streamUrl ?? `${config.baseURL}/tasks/${encodeURIComponent(taskId)}/stream`,
+		headers,
 		abortSignal: signal,
 		successfulResponseHandler: createEventSourceResponseHandler(textStreamPartSchema),
 		failedResponseHandler: async ({ response }) => {
@@ -175,9 +188,16 @@ async function* createTaskEventGenerator(config, taskId, options = {}) {
 * Creates a ReadableStream that transforms v2 TextStreamPart events to AI SDK v3 format.
 * Implements a thin passthrough adapter with minimal transformation logic.
 */
-function createTerminalUseTransformStream(config, taskId, signal) {
-	const eventGenerator = createTaskEventGenerator(config, taskId, { signal });
+function createTerminalUseTransformStream(config, taskId, signal, arg4, arg5) {
+	const { streamOverride, closeConfig } = resolveStreamArgs(arg4, arg5);
+	const eventGenerator = createTaskEventGenerator(config, taskId, {
+		signal,
+		streamUrl: streamOverride?.streamUrl,
+		streamHeaders: streamOverride?.streamHeaders
+	});
 	let emittedStreamStart = false;
+	const pendingParts = [];
+	const trackedParts = createStreamedPartTracker();
 	return new ReadableStream({
 		async pull(controller) {
 			if (!emittedStreamStart) {
@@ -188,6 +208,13 @@ function createTerminalUseTransformStream(config, taskId, signal) {
 				});
 				return;
 			}
+			if (pendingParts.length > 0) {
+				const pendingPart = pendingParts.shift();
+				if (pendingPart) {
+					controller.enqueue(pendingPart);
+					return;
+				}
+			}
 			try {
 				while (true) {
 					const { value, done } = await eventGenerator.next();
@@ -196,14 +223,16 @@ function createTerminalUseTransformStream(config, taskId, signal) {
 						return;
 					}
 					const event = value;
-					const transformed = transformEvent(event, taskId);
-					if (event.type === "finish" || event.type === "error") {
-						if (transformed) controller.enqueue(transformed);
+					const transformedParts = transformEvent(event, taskId, trackedParts);
+					if (shouldCloseStream(event, closeConfig)) {
+						for (const part of transformedParts) controller.enqueue(part);
 						controller.close();
 						return;
 					}
-					if (transformed) {
-						controller.enqueue(transformed);
+					if (transformedParts.length > 0) {
+						const [firstPart, ...restParts] = transformedParts;
+						controller.enqueue(firstPart);
+						if (restParts.length > 0) pendingParts.push(...restParts);
 						return;
 					}
 				}
@@ -219,19 +248,19 @@ function createTerminalUseTransformStream(config, taskId, signal) {
 }
 /**
 * Transforms a single v2 TextStreamPart event to AI SDK v3 LanguageModelV3StreamPart.
-* Returns null for events that should be skipped (e.g., finish-step, start).
+* Returns an array to support synthesizing start parts for orphan deltas.
 */
-function transformEvent(event, taskId) {
+function transformEvent(event, taskId, trackedParts) {
 	switch (event.type) {
-		case "start": return null;
-		case "start-step": return {
+		case "start": return [];
+		case "start-step": return [{
 			type: "response-metadata",
 			id: taskId,
 			timestamp: /* @__PURE__ */ new Date(),
 			modelId: "terminaluse-agent"
-		};
-		case "finish-step": return null;
-		case "finish": return {
+		}];
+		case "finish-step": return [];
+		case "finish": return [{
 			type: "finish",
 			finishReason: {
 				unified: event.finishReason,
@@ -250,76 +279,145 @@ function transformEvent(event, taskId) {
 					reasoning: void 0
 				}
 			}
-		};
-		case "text-start": return {
-			type: "text-start",
-			id: event.id
-		};
-		case "text-delta": return {
-			type: "text-delta",
-			id: event.id,
-			delta: event.text
-		};
-		case "text-end": return {
-			type: "text-end",
-			id: event.id
-		};
-		case "reasoning-start": return {
-			type: "reasoning-start",
-			id: event.id
-		};
-		case "reasoning-delta": return {
-			type: "reasoning-delta",
-			id: event.id,
-			delta: event.text
-		};
-		case "reasoning-end": return {
-			type: "reasoning-end",
-			id: event.id
-		};
-		case "tool-input-start": return {
-			type: "tool-input-start",
-			id: event.id,
-			toolName: event.toolName,
-			providerExecuted: true,
-			dynamic: true
-		};
-		case "tool-input-delta": return {
-			type: "tool-input-delta",
-			id: event.id,
-			delta: event.delta
-		};
-		case "tool-input-end": return {
-			type: "tool-input-end",
-			id: event.id
-		};
-		case "tool-call": return {
+		}];
+		case "handler-complete": return [];
+		case "text-start":
+			if (trackedParts.text.open.has(event.id)) return [];
+			trackedParts.text.open.add(event.id);
+			return [{
+				type: "text-start",
+				id: event.id
+			}];
+		case "text-delta": {
+			const deltaPart = {
+				type: "text-delta",
+				id: event.id,
+				delta: event.text
+			};
+			if (trackedParts.text.open.has(event.id)) return [deltaPart];
+			if (trackedParts.text.open.size > 0) return [];
+			trackedParts.text.open.add(event.id);
+			return [{
+				type: "text-start",
+				id: event.id
+			}, deltaPart];
+		}
+		case "text-end":
+			if (!trackedParts.text.open.has(event.id)) return [];
+			trackedParts.text.open.delete(event.id);
+			return [{
+				type: "text-end",
+				id: event.id
+			}];
+		case "reasoning-start":
+			if (trackedParts.reasoning.open.has(event.id)) return [];
+			trackedParts.reasoning.open.add(event.id);
+			return [{
+				type: "reasoning-start",
+				id: event.id
+			}];
+		case "reasoning-delta": {
+			const deltaPart = {
+				type: "reasoning-delta",
+				id: event.id,
+				delta: event.text
+			};
+			if (trackedParts.reasoning.open.has(event.id)) return [deltaPart];
+			if (trackedParts.reasoning.open.size > 0) return [];
+			trackedParts.reasoning.open.add(event.id);
+			return [{
+				type: "reasoning-start",
+				id: event.id
+			}, deltaPart];
+		}
+		case "reasoning-end":
+			if (!trackedParts.reasoning.open.has(event.id)) return [];
+			trackedParts.reasoning.open.delete(event.id);
+			return [{
+				type: "reasoning-end",
+				id: event.id
+			}];
+		case "tool-input-start":
+			if (trackedParts.toolInput.open.has(event.id)) return [];
+			trackedParts.toolInput.open.add(event.id);
+			return [{
+				type: "tool-input-start",
+				id: event.id,
+				toolName: event.toolName,
+				providerExecuted: true,
+				dynamic: true
+			}];
+		case "tool-input-delta":
+			if (!trackedParts.toolInput.open.has(event.id)) return [];
+			return [{
+				type: "tool-input-delta",
+				id: event.id,
+				delta: event.delta
+			}];
+		case "tool-input-end":
+			if (!trackedParts.toolInput.open.has(event.id)) return [];
+			trackedParts.toolInput.open.delete(event.id);
+			return [{
+				type: "tool-input-end",
+				id: event.id
+			}];
+		case "tool-call": return [{
 			type: "tool-call",
 			toolCallId: event.toolCallId,
 			toolName: event.toolName,
 			input: JSON.stringify(event.input),
 			providerExecuted: true,
 			dynamic: true
-		};
+		}];
 		case "tool-result": {
 			const result = event.output ?? "";
-			return {
+			return [{
 				type: "tool-result",
 				toolCallId: event.toolCallId,
 				toolName: event.toolName,
 				result
-			};
+			}];
 		}
-		case "error": return {
+		case "error": return [{
 			type: "error",
 			error: event.error
-		};
-		default: return null;
+		}];
+		default: return [];
 	}
 }
+function createStreamedPartTracker() {
+	return {
+		text: createSegmentTracker(),
+		reasoning: createSegmentTracker(),
+		toolInput: createSegmentTracker()
+	};
+}
+function createSegmentTracker() {
+	return { open: /* @__PURE__ */ new Set() };
+}
+function shouldCloseStream(event, closeConfig) {
+	if (event.type === "error") return true;
+	if (closeConfig.closeMode === "legacy") return event.type === "finish";
+	return event.type === "handler-complete" && event.eventId === closeConfig.eventId;
+}
+function resolveStreamArgs(arg4, arg5) {
+	if (isStreamCloseConfig(arg4)) return {
+		streamOverride: void 0,
+		closeConfig: arg4
+	};
+	return {
+		streamOverride: arg4,
+		closeConfig: arg5 ?? { closeMode: "legacy" }
+	};
+}
+function isStreamCloseConfig(value) {
+	if (!value || typeof value !== "object") return false;
+	return "closeMode" in value;
+}
 
 //#endregion
 //#region src/provider.ts
+const HANDLER_COMPLETE_CLOSE_CAPABILITY = "handler-complete-close-v1";
 /**
 * Creates a custom AI SDK provider for TerminalUse agents.
 *
@@ -372,7 +470,7 @@ function createTerminalUseProvider(config) {
 				const { prompt, providerOptions, abortSignal } = options;
 				const tuOptions = providerOptions?.terminaluse;
 				if (!tuOptions?.taskId) throw new Error("taskId is required. Create a task via /api/tasks first.");
-				const { taskId } = tuOptions;
+				const { taskId, skipSend = false } = tuOptions;
 				const explicitEvent = tuOptions.event;
 				const defaultEventContent = (() => {
 					const userContent = prompt.at(-1)?.content;
@@ -386,22 +484,54 @@ function createTerminalUseProvider(config) {
 						text: textContent || ""
 					};
 				})();
-				const requestBody = {
-					task_id: taskId,
-					content: explicitEvent?.content ?? defaultEventContent,
-					...explicitEvent?.idempotencyKey ? { idempotency_key: explicitEvent.idempotencyKey } : {},
-					...typeof explicitEvent?.persistMessage === "boolean" ? { persist_message: explicitEvent.persistMessage } : {}
-				};
-				try {
-					await client.tasks.sendEvent(requestBody);
-				} catch (error) {
-					throw new Error(`Failed to send message: ${error instanceof Error ? error.message : String(error)}`);
+				if (!skipSend) {
+					const requestBody = {
+						task_id: taskId,
+						content: explicitEvent?.content ?? defaultEventContent,
+						...explicitEvent?.idempotencyKey ? { idempotency_key: explicitEvent.idempotencyKey } : {},
+						...typeof explicitEvent?.persistMessage === "boolean" ? { persist_message: explicitEvent.persistMessage } : {}
+					};
+					let sendEventResponse;
+					try {
+						sendEventResponse = await client.tasks.sendEvent(requestBody);
+					} catch (error) {
+						throw new Error(`Failed to send message: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					const closeConfig = resolveStreamCloseConfig(sendEventResponse);
+					return { stream: typeof tuOptions.streamUrl === "string" || tuOptions.streamHeaders && Object.keys(tuOptions.streamHeaders).length > 0 ? createTerminalUseTransformStream(tuConfig, taskId, abortSignal, {
+						streamUrl: tuOptions.streamUrl,
+						streamHeaders: tuOptions.streamHeaders
+					}, closeConfig) : createTerminalUseTransformStream(tuConfig, taskId, abortSignal, closeConfig) };
 				}
-				return { stream: createTerminalUseTransformStream(tuConfig, taskId, abortSignal) };
+				return { stream: typeof tuOptions.streamUrl === "string" || tuOptions.streamHeaders && Object.keys(tuOptions.streamHeaders).length > 0 ? createTerminalUseTransformStream(tuConfig, taskId, abortSignal, {
+					streamUrl: tuOptions.streamUrl,
+					streamHeaders: tuOptions.streamHeaders
+				}) : createTerminalUseTransformStream(tuConfig, taskId, abortSignal) };
 			}
 		};
 	} };
 }
+function resolveStreamCloseConfig(response) {
+	const eventId = getStringProperty(response, "id");
+	const streamCapabilities = getStringArrayProperty(response, "streamCapabilities") ?? getStringArrayProperty(response, "stream_capabilities");
+	if (eventId && streamCapabilities?.includes(HANDLER_COMPLETE_CLOSE_CAPABILITY)) return {
+		closeMode: "handler-complete",
+		eventId
+	};
+	return { closeMode: "legacy" };
+}
+function getStringProperty(value, key) {
+	if (!value || typeof value !== "object") return;
+	const maybeValue = value[key];
+	return typeof maybeValue === "string" ? maybeValue : void 0;
+}
+function getStringArrayProperty(value, key) {
+	if (!value || typeof value !== "object") return;
+	const maybeArray = value[key];
+	if (!Array.isArray(maybeArray)) return;
+	if (!maybeArray.every((entry) => typeof entry === "string")) return;
+	return maybeArray;
+}
 
 //#endregion
 export { createTerminalUseProvider };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terminaluse/vercel-ai-sdk-provider",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Vercel AI SDK provider for TerminalUse agents",
   "repository": {
     "type": "git",