@dex-ai/openai 0.1.8

package/src/responses.ts

@@ -0,0 +1,386 @@
+/**
+ * Responses API streaming: POST /v1/responses → StreamPart async iterable.
+ *
+ * Supports streamed reasoning deltas (reasoning-delta StreamPart) that the
+ * Chat Completions endpoint does not expose.
+ */
+
+import type {
+	StreamPart,
+	ModelRequest,
+	FinishReason,
+	Usage,
+	ResponseMeta,
+	Content,
+	Message,
+} from "@dex-ai/sdk";
+import { parseSSE } from "./sse";
+import type { SSEFrame } from "./sse";
+import { OpenAIError } from "./errors";
+import { messagesToOAI, toolToOAI, toolChoiceToOAI } from "./translate";
+import { thinkingToReasoningEffort, modelSupportsReasoning } from "./thinking";
+
+/* ------------------------------------------------------------------ */
+/* Types                                                               */
+/* ------------------------------------------------------------------ */
+
+interface ToolCallAccumulator {
+	id: string;
+	callId: string;
+	name: string;
+	arguments: string;
+}
+
+interface ResponsesStreamOptions {
+	baseUrl: string;
+	apiKey: string;
+	modelId: string;
+	providerName: string;
+	rawChunks: boolean;
+	doFetch: (url: string, init: RequestInit) => Promise<Response>;
+	headers?: Record<string, string> | undefined;
+	/** Idle timeout in ms — if no SSE data arrives within this window, abort. Default: 120_000 (2min). */
+	streamIdleTimeoutMs?: number | undefined;
+}
+
+/* ------------------------------------------------------------------ */
+/* createResponsesStream                                               */
+/* ------------------------------------------------------------------ */
+
+export function createResponsesStream(
+	opts: ResponsesStreamOptions,
+	_modelMaxTokens?: number,
+): (req: ModelRequest) => AsyncIterable<StreamPart> {
+	const { baseUrl, apiKey, modelId, providerName, rawChunks, doFetch } = opts;
+	const url = `${baseUrl}/responses`;
+	const idleTimeoutMs = opts.streamIdleTimeoutMs ?? 120_000; // 2 min default
+
+	return async function* stream(req: ModelRequest): AsyncIterable<StreamPart> {
+		const startedAt = Date.now();
+
+		// Build request body — Responses API uses `input` instead of `messages`
+		const body: Record<string, unknown> = {
+			model: modelId,
+			input: messagesToOAI(req.messages),
+			stream: true,
+		};
+
+		if (req.maxTokens !== undefined) body.max_output_tokens = req.maxTokens;
+		if (req.temperature !== undefined) body.temperature = req.temperature;
+		if (req.topP !== undefined) body.top_p = req.topP;
+
+		// Tools
+		if (req.tools?.length) {
+			body.tools = req.tools.map((t) => {
+				const oai = toolToOAI(t);
+				return oai;
+			});
+			const tc = toolChoiceToOAI(req.toolChoice);
+			if (tc !== undefined) body.tool_choice = tc;
+		}
+
+		// Reasoning
+		if (modelSupportsReasoning(modelId)) {
+			const effort = thinkingToReasoningEffort(req.thinking, "responses");
+			if (effort !== undefined) {
+				body.reasoning = { effort };
+			}
+		}
+
+		// Provider options pass-through
+		if (req.providerOptions) Object.assign(body, req.providerOptions);
+
+		const init: RequestInit = {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`,
+				...opts.headers,
+			},
+			body: JSON.stringify(body),
+		};
+		if (req.signal) (init as { signal: AbortSignal }).signal = req.signal;
+
+		let res: Response;
+		try {
+			res = await doFetch(url, init);
+		} catch (err: unknown) {
+			if (err instanceof Error && err.name === "AbortError") {
+				yield { type: "abort", reason: err };
+				return;
+			}
+			throw err;
+		}
+
+		if (!res.ok) {
+			const error = await OpenAIError.fromResponse(res);
+			yield { type: "error", error, recoverable: false };
+			return;
+		}
+
+		if (!res.body) {
+			yield {
+				type: "error",
+				error: new Error("openai responses stream: empty body"),
+				recoverable: false,
+			};
+			return;
+		}
+
+		const meta: ResponseMeta = { providerName, modelId, startedAt };
+		yield { type: "response-start", meta };
+
+		// State
+		const textParts: string[] = [];
+		const reasoningParts: string[] = [];
+		const toolCalls: Map<string, ToolCallAccumulator> = new Map();
+		let messageStarted = false;
+		let finishReason: FinishReason = "stop";
+		let usage: Usage = { inputTokens: 0, outputTokens: 0 };
+		let responseId: string | undefined;
+
+		try {
+			const sseIter = parseSSE(res.body)[Symbol.asyncIterator]();
+			while (true) {
+				// Race next SSE frame against idle timeout
+				let timer: ReturnType<typeof setTimeout> | undefined;
+				const timeoutPromise = new Promise<never>((_, reject) => {
+					timer = setTimeout(
+						() =>
+							reject(
+								new Error(
+									`Stream idle timeout: no data received for ${idleTimeoutMs}ms`,
+								),
+							),
+						idleTimeoutMs,
+					);
+				});
+				let result: IteratorResult<SSEFrame, undefined>;
+				try {
+					result = await Promise.race([sseIter.next(), timeoutPromise]);
+				} finally {
+					clearTimeout(timer);
+				}
+				if (result.done) break;
+				const frame = result.value;
+				if (frame.data === "[DONE]") break;
+
+				if (rawChunks) {
+					yield { type: "raw-chunk", providerName, data: frame.data };
+				}
+
+				let event: any;
+				try {
+					event = JSON.parse(frame.data);
+				} catch {
+					continue;
+				}
+
+				const eventType = event.type as string | undefined;
+
+				switch (eventType) {
+					case "response.created": {
+						if (event.response?.id) responseId = event.response.id as string;
+						if (!messageStarted) {
+							messageStarted = true;
+							yield { type: "message-start", role: "assistant" };
+						}
+						break;
+					}
+
+					case "response.output_text.delta": {
+						if (!messageStarted) {
+							messageStarted = true;
+							yield { type: "message-start", role: "assistant" };
+						}
+						const text = event.delta as string;
+						if (text) {
+							textParts.push(text);
+							yield { type: "text-delta", delta: text };
+						}
+						break;
+					}
+
+					case "response.reasoning.delta": {
+						if (!messageStarted) {
+							messageStarted = true;
+							yield { type: "message-start", role: "assistant" };
+						}
+						const reasoning = event.delta as string;
+						if (reasoning) {
+							reasoningParts.push(reasoning);
+							yield { type: "reasoning-delta", delta: reasoning };
+						}
+						break;
+					}
+
+					case "response.function_call_arguments.delta": {
+						const itemId = (event.item_id as string) ?? "";
+						let acc = toolCalls.get(itemId);
+						if (!acc) {
+							acc = {
+								id: itemId,
+								callId: (event.call_id as string) ?? "",
+								name: (event.name as string) ?? "",
+								arguments: "",
+							};
+							toolCalls.set(itemId, acc);
+						}
+						if (event.name) acc.name = event.name as string;
+						if (event.call_id) acc.callId = event.call_id as string;
+						const argDelta = event.delta as string;
+						if (argDelta) {
+							acc.arguments += argDelta;
+							yield {
+								type: "tool-call-delta",
+								toolCallId: acc.callId || acc.id,
+								toolName: acc.name,
+								inputDelta: argDelta,
+							};
+						}
+						break;
+					}
+
+					case "response.function_call_arguments.done": {
+						const itemId = (event.item_id as string) ?? "";
+						const acc = toolCalls.get(itemId);
+						if (acc) {
+							if (event.call_id) acc.callId = event.call_id as string;
+							if (event.name) acc.name = event.name as string;
+							if (event.arguments) acc.arguments = event.arguments as string;
+						}
+						break;
+					}
+
+					case "response.completed": {
+						const r = event.response as Record<string, unknown> | undefined;
+						if (r) {
+							if (r.id) responseId = r.id as string;
+							const status = r.status as string | undefined;
+							if (status === "incomplete") finishReason = "length";
+							else if (status === "failed") finishReason = "error";
+
+							const u = r.usage as Record<string, unknown> | undefined;
+							if (u) {
+								usage = {
+									inputTokens: (u.input_tokens as number) ?? 0,
+									outputTokens: (u.output_tokens as number) ?? 0,
+									totalTokens: (u.total_tokens as number) ?? undefined,
+									...(typeof u.input_tokens_details === "object" &&
+									u.input_tokens_details !== null &&
+									(u.input_tokens_details as Record<string, unknown>)
+										.cached_tokens !== undefined
+										? {
+												cachedInputTokens: (
+													u.input_tokens_details as Record<string, unknown>
+												).cached_tokens as number,
+											}
+										: {}),
+									...(typeof u.output_tokens_details === "object" &&
+									u.output_tokens_details !== null &&
+									(u.output_tokens_details as Record<string, unknown>)
+										.reasoning_tokens !== undefined
+										? {
+												reasoningTokens: (
+													u.output_tokens_details as Record<string, unknown>
+												).reasoning_tokens as number,
+											}
+										: {}),
+								};
+							}
+						}
+						break;
+					}
+
+					case "response.output_item.done": {
+						// Tool call items complete
+						const item = event.item as Record<string, unknown> | undefined;
+						if (item && item.type === "function_call") {
+							const id = (item.id as string) ?? "";
+							const acc = toolCalls.get(id) ?? {
+								id,
+								callId: (item.call_id as string) ?? id,
+								name: (item.name as string) ?? "",
+								arguments: (item.arguments as string) ?? "",
+							};
+							toolCalls.set(id, acc);
+							if (item.call_id) acc.callId = item.call_id as string;
+							if (item.name) acc.name = item.name as string;
+							if (item.arguments) acc.arguments = item.arguments as string;
+						}
+						break;
+					}
+
+					default:
+						// Ignore unknown event types
+						break;
+				}
+			}
+		} catch (err: unknown) {
+			if (err instanceof Error && err.name === "AbortError") {
+				yield { type: "abort", reason: err };
+				return;
+			}
+			yield { type: "error", error: err, recoverable: false };
+			return;
+		}
+
+		// Determine finish reason from tool calls
+		if (toolCalls.size > 0 && finishReason === "stop") {
+			finishReason = "tool-calls";
+		}
+
+		// Emit finalized tool-calls
+		for (const [, acc] of toolCalls) {
+			let input: unknown = {};
+			try {
+				input = acc.arguments ? JSON.parse(acc.arguments) : {};
+			} catch {
+				input = acc.arguments;
+			}
+			yield {
+				type: "tool-call",
+				toolCallId: acc.callId || acc.id,
+				toolName: acc.name,
+				input,
+			};
+		}
+
+		// Assemble final message
+		const contentParts: Content[] = [];
+		if (reasoningParts.length > 0) {
+			contentParts.push({ type: "reasoning", text: reasoningParts.join("") });
+		}
+		if (textParts.length > 0) {
+			contentParts.push({ type: "text", text: textParts.join("") });
+		}
+		for (const [, acc] of toolCalls) {
+			let input: unknown = {};
+			try {
+				input = acc.arguments ? JSON.parse(acc.arguments) : {};
+			} catch {
+				input = acc.arguments;
+			}
+			contentParts.push({
+				type: "tool-call",
+				toolCallId: acc.callId || acc.id,
+				toolName: acc.name,
+				input,
+			});
+		}
+
+		const message: Message = { role: "assistant", content: contentParts };
+		yield { type: "message-stop", message };
+		yield { type: "finish", reason: finishReason, usage };
+		yield {
+			type: "response-stop",
+			meta: {
+				...meta,
+				...(responseId !== undefined ? { id: responseId } : {}),
+				endedAt: Date.now(),
+			},
+			usage,
+			finishReason,
+		};
+	};
+}

package/src/sse.ts

@@ -0,0 +1,35 @@
+/** Minimal SSE line parser for streaming API responses. */
+
+export interface SSEFrame {
+	data: string;
+}
+
+/** Parse a ReadableStream<Uint8Array> into SSE frames. Yields each `data:` payload (trimmed of the prefix). */
+export async function* parseSSE(
+	body: ReadableStream<Uint8Array>,
+): AsyncGenerator<SSEFrame> {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let nl: number;
+			while ((nl = buffer.indexOf("\n")) !== -1) {
+				const line = buffer.slice(0, nl).replace(/\r$/, "");
+				buffer = buffer.slice(nl + 1);
+				if (!line) continue;
+				if (line.startsWith("data: ")) {
+					yield { data: line.slice(6) };
+				} else if (line.startsWith("data:")) {
+					yield { data: line.slice(5) };
+				}
+				// ignore comments / other fields
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}