@alvin0/ai-agent-sdk-protocol-responses 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alvin0 (chaulamdinhai) <chaulamdinhai@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @alvin0/ai-agent-sdk-protocol-responses
+
+Runtime: **Universal** (Edge/Worker, browser, Deno, Bun, and Node).
+
+```sh
+pnpm add @alvin0/ai-agent-sdk-core @alvin0/ai-agent-sdk-protocol-responses
+```
+
+Universal OpenAI Responses/Codex wire schema, request serializer, stream translator, and dialect. It owns no endpoint, credentials, fetch implementation, filesystem access, or Node.js APIs.
+
+```ts
+import { openAiResponsesProtocol } from '@alvin0/ai-agent-sdk-protocol-responses'
+```
+
+Composition: `provider-author.protocol`. Lifecycle: `inert-value`; select it in
+`createRuntimeHttpProvider()` without any startup or cleanup obligation.
+
+The only runtime dependency is `@alvin0/ai-agent-sdk-core`.

package/dist/index.d.ts

@@ -0,0 +1,363 @@
+import { GenerateOptions, StreamChunk, UsageCounters } from "@alvin0/ai-agent-sdk-core";
+import { ModelTarget, ResolvedModelInfo } from "@alvin0/ai-agent-sdk-core/provider";
+//#region src/contract.d.ts
+/** The request fields a pure wire protocol is allowed to inspect. */
+interface ProtocolRequest {
+  readonly options: GenerateOptions;
+  readonly maxTokens: number;
+}
+/** One decoded SSE event, expressed without depending on an HTTP transport. */
+interface ProtocolSseEvent {
+  readonly event: string | undefined;
+  readonly data: string;
+}
+/** Protocol-internal chunks may carry a partial untrusted usage report. */
+type ProtocolStreamChunk = Exclude<StreamChunk, {
+  readonly type: 'usage';
+}> | {
+  readonly type: 'usage';
+  readonly usage: UsageCounters;
+};
+/** Structural protocol contract implemented without importing provider-http. */
+interface ProtocolDefinition<Dialect> {
+  readonly id: string;
+  readonly defaultDialect: Dialect;
+  endpointPath(request: ProtocolRequest, dialect: Dialect): string;
+  protocolHeaders?(dialect: Dialect): Record<string, string>;
+  serialize(request: ProtocolRequest, dialect: Dialect): unknown | Promise<unknown>;
+  translate(events: AsyncIterable<ProtocolSseEvent>, request: ProtocolRequest, displayName: string): AsyncGenerator<ProtocolStreamChunk>;
+}
+//#endregion
+//#region src/wire.d.ts
+/**
+ * The OpenAI Responses API wire shapes, shared by the `openai` and `codex`
+ * providers.
+ *
+ * Both speak the same protocol — Codex's own client dropped Chat Completions
+ * entirely (`wire_api = "chat"` is a hard error there now) — so the dialect
+ * differences are narrow enough to express as a profile rather than a second
+ * implementation. What actually differs is the base URL, the auth headers, and
+ * whether sampling knobs are accepted; see {@link ResponsesDialect}.
+ *
+ * These types never leave this folder.
+ *
+ * @module ai-agent-sdk/providers/responses/wire
+ */
+/** Detail level requested for an input image. */
+type WireImageDetail = 'auto' | 'low' | 'high' | 'original';
+/** One part of a message item's content. */
+type WireContentPart = {
+  type: 'input_text';
+  text: string;
+} | {
+  type: 'input_image';
+  image_url: string;
+  detail?: WireImageDetail;
+} | {
+  type: 'input_image';
+  file_id: string;
+  detail?: WireImageDetail;
+} | {
+  type: 'output_text';
+  text: string;
+  annotations?: WireTextAnnotation[];
+};
+interface WireTextAnnotation {
+  type: 'url_citation';
+  url: string;
+  title?: string;
+  start_index?: number;
+  end_index?: number;
+}
+/** One summary paragraph of a reasoning item. */
+interface WireReasoningSummary {
+  type: 'summary_text';
+  text: string;
+}
+/** One body paragraph of a reasoning item. */
+interface WireReasoningContent {
+  type: 'reasoning_text';
+  text: string;
+}
+/**
+ * An item in the `input` array.
+ *
+ * Note the shape of the conversation here: this is a FLAT list of items, not a
+ * list of messages with nested content. A tool result is its own top-level
+ * `function_call_output` item rather than a part inside a user message, and one
+ * assistant turn that reasoned, spoke, and called two tools becomes four items.
+ * That is the main thing serialization has to get right.
+ */
+type WireInputItem = {
+  type: 'message';
+  role: 'user' | 'assistant' | 'developer' | 'system';
+  content: WireContentPart[];
+  phase?: 'commentary' | 'final_answer';
+} | {
+  type: 'function_call';
+  /** Correlates with the matching output item. */
+  call_id: string;
+  name: string;
+  /** JSON-encoded STRING, not an object. */
+  arguments: string;
+  /** Server-assigned item id, echoed back when known. */
+  id?: string;
+} | {
+  type: 'function_call_output';
+  call_id: string;
+  /** Either plain text or structured content items. */
+  output: string | WireContentPart[];
+} | {
+  type: 'reasoning';
+  id?: string;
+  summary: WireReasoningSummary[];
+  content?: WireReasoningContent[];
+  /**
+   * Opaque encrypted reasoning, returned when `include` requests it.
+   *
+   * Echoing it back is what lets the model keep its chain of thought across a
+   * tool-use loop; dropping it silently degrades multi-step quality.
+   */
+  encrypted_content?: string | null;
+} | {
+  /** Provider-native web-search item replayed on a later request. */
+  type: 'web_search_call';
+  id?: string;
+  status?: string;
+  action?: unknown;
+} | {
+  /** Provider-native image-generation item replayed on a later request. */
+  type: 'image_generation_call';
+  id?: string;
+  status?: string;
+  result?: string | null;
+};
+/** A function tool, flat rather than nested under a `function` key. */
+interface WireFunctionTool {
+  type: 'function';
+  name: string;
+  description: string;
+  strict: boolean;
+  parameters: Record<string, unknown>;
+}
+interface WireNativeTool {
+  type: string;
+  [key: string]: unknown;
+}
+type WireTool = WireFunctionTool | WireNativeTool;
+/** How the model must choose among the offered tools. */
+type WireToolChoice = 'auto' | 'none' | 'required' | {
+  type: 'function';
+  name: string;
+} | {
+  type: string;
+};
+/** Reasoning controls. */
+interface WireReasoning {
+  effort?: string;
+  summary?: 'auto' | 'concise' | 'detailed' | 'none';
+}
+/** Output text controls. */
+interface WireTextControls {
+  format?: WireTextFormat;
+  verbosity?: 'low' | 'medium' | 'high';
+}
+type WireTextFormat = {
+  type: 'text';
+} | {
+  type: 'json_schema';
+  name: string;
+  schema: Readonly<Record<string, unknown>>;
+  strict: true;
+};
+/** The request body. */
+interface WireRequest {
+  model: string;
+  /** System prompt. Its own field here, not a message item. */
+  instructions?: string;
+  input: WireInputItem[];
+  tools?: WireTool[];
+  tool_choice?: WireToolChoice;
+  parallel_tool_calls?: boolean;
+  reasoning?: WireReasoning;
+  text?: WireTextControls;
+  /** Whether the provider retains the response server-side. */
+  store: boolean;
+  stream: boolean;
+  /** Extra payloads to include, e.g. `reasoning.encrypted_content`. */
+  include?: string[];
+  /** Stable key that lets the provider reuse a cached prompt prefix. */
+  prompt_cache_key?: string;
+  max_output_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+}
+/** Cached-token breakdown of the input count. */
+interface WireInputTokensDetails {
+  /** Portion of `input_tokens` served from cache — a SUBSET, not an addition. */
+  cached_tokens?: number;
+  /** Codex-backend extension. */
+  cache_write_tokens?: number;
+}
+/** Reasoning breakdown of the output count. */
+interface WireOutputTokensDetails {
+  reasoning_tokens?: number;
+}
+/** Token accounting as the Responses API reports it. */
+interface WireUsage {
+  input_tokens?: number;
+  input_tokens_details?: WireInputTokensDetails | null;
+  output_tokens?: number;
+  output_tokens_details?: WireOutputTokensDetails | null;
+  total_tokens?: number;
+}
+/** A completed output item, as `response.output_item.done` delivers it. */
+interface WireOutputItem {
+  id?: string;
+  type?: string;
+  role?: string;
+  content?: unknown;
+  summary?: unknown;
+  encrypted_content?: string | null;
+  call_id?: string;
+  name?: string;
+  arguments?: string;
+  phase?: string;
+  status?: string;
+  action?: unknown;
+  result?: string | null;
+}
+/** The error payload in `response.failed` and in HTTP error bodies. */
+interface WireErrorBody {
+  type?: string;
+  code?: string;
+  message?: string;
+}
+/** Why a response stopped short of completion. */
+interface WireIncompleteDetails {
+  reason?: string;
+}
+/** The `response` object carried by lifecycle events. */
+interface WireResponse {
+  id?: string;
+  status?: string;
+  usage?: WireUsage | null;
+  error?: WireErrorBody | null;
+  incomplete_details?: WireIncompleteDetails | null;
+}
+/** One decoded streaming event. */
+interface WireStreamEvent {
+  type?: string;
+  response?: WireResponse;
+  item?: WireOutputItem;
+  item_id?: string;
+  output_index?: number;
+  content_index?: number;
+  summary_index?: number;
+  delta?: string;
+  text?: string;
+  partial_image_b64?: string;
+  partial_image_index?: number;
+  /** Present on a top-level `error` event, which carries its fields inline. */
+  code?: string;
+  message?: string;
+}
+/**
+ * The narrow set of differences between the two endpoints that speak this
+ * protocol.
+ *
+ * Expressed as data rather than as subclasses because the differences are all
+ * "send this field or not" — behaviour is identical.
+ */
+interface ResponsesDialect {
+  /**
+   * Whether `temperature` / `top_p` may be sent.
+   *
+   * The ChatGPT-backed Codex endpoint has no such fields in its request schema,
+   * so sending them risks a rejection for no benefit.
+   */
+  readonly sampling: boolean;
+  /** Whether `max_output_tokens` may be sent. */
+  readonly maxOutputTokens: boolean;
+  /** Whether the endpoint accepts `text.format` JSON Schema controls. */
+  readonly structuredOutputs: boolean;
+  /** Value for `store`. Codex always sends false. */
+  readonly store: boolean;
+  /** Values for `include`. */
+  readonly include: readonly string[];
+  /** Whether to ask for reasoning summaries, and how detailed. */
+  readonly reasoningSummary?: 'auto' | 'concise' | 'detailed';
+  /** Whether assistant message phase may be replayed on input. */
+  readonly messagePhase?: boolean;
+  /**
+   * Stable key letting the provider reuse a cached prompt prefix across turns.
+   *
+   * A dialect knob rather than an adapter concern because `prompt_cache_key` is a
+   * field of THIS protocol; putting it here means any endpoint speaking Responses
+   * gets prefix caching without post-processing the serialized body.
+   */
+  readonly promptCacheKey?: string;
+}
+//#endregion
+//#region src/protocol.d.ts
+/** Protocol id, usable as a stable string in configuration. */
+declare const OPENAI_RESPONSES_PROTOCOL_ID = "openai-responses";
+interface RuntimeProtocolRequest extends ProtocolRequest {
+  readonly model: ResolvedModelInfo;
+  readonly connection: {
+    readonly baseUrl: string;
+    readonly headers: Readonly<Record<string, string>>;
+  };
+}
+/** Marker-based runtime view, kept structurally independent from provider-http. */
+interface ResponsesProtocolDefinition {
+  readonly kind: 'http-wire-protocol';
+  readonly apiVersion: 1;
+  readonly id: string;
+  readonly defaultDialect: ResponsesDialect;
+  readonly exampleModel?: ModelTarget;
+  readonly endpointPath: (request: RuntimeProtocolRequest, dialect: ResponsesDialect) => string;
+  readonly protocolHeaders?: (dialect: ResponsesDialect) => Readonly<Record<string, string>>;
+  readonly serialize: (request: RuntimeProtocolRequest, dialect: ResponsesDialect) => Readonly<Record<string, unknown>>;
+  readonly translate: (events: AsyncIterable<ProtocolSseEvent>, request: RuntimeProtocolRequest, displayName: string) => AsyncGenerator<ProtocolStreamChunk>;
+}
+/** The OpenAI Responses wire protocol. */
+declare const openAiResponsesProtocol: ProtocolDefinition<ResponsesDialect> & ResponsesProtocolDefinition;
+//#endregion
+//#region src/serialize.d.ts
+/**
+ * Adapter-private state kept on a {@link ReasoningBlock} so a reasoning item can
+ * be echoed back byte-identically on the next request of a tool-use loop.
+ */
+interface ResponsesReasoningState {
+  /** Server-assigned item id. */
+  id?: string;
+  /** Opaque encrypted chain of thought. */
+  encryptedContent?: string;
+  /** Summary paragraphs, in order. */
+  summary?: readonly string[];
+}
+/**
+ * Build the Responses request body.
+ * @param request - the resolved request, model, and connection.
+ * @param dialect - which optional fields this endpoint accepts.
+ * @returns the wire body, ready to serialize.
+ */
+declare function serializeResponsesRequest(request: ProtocolRequest, dialect: ResponsesDialect): WireRequest;
+//#endregion
+//#region src/translate.d.ts
+/**
+ * Translate one Responses SSE stream.
+ *
+ * Owns termination. This API sends no `[DONE]` sentinel: the stream ends on
+ * `response.completed`, `response.failed`, or `response.incomplete`, and a body
+ * that ends without one of those was truncated — which is a failure, not an
+ * empty success, because a truncated turn cannot be trusted.
+ * @param events - decoded SSE events.
+ * @param displayName - provider name, used in diagnostics.
+ * @returns the chunk stream.
+ */
+declare function translateResponsesStream(events: AsyncIterable<ProtocolSseEvent>, displayName: string, request?: ProtocolRequest): AsyncGenerator<ProtocolStreamChunk>;
+//#endregion
+export { OPENAI_RESPONSES_PROTOCOL_ID, type ProtocolDefinition, type ProtocolRequest, type ProtocolSseEvent, type ProtocolStreamChunk, type ResponsesDialect, type ResponsesProtocolDefinition, type ResponsesReasoningState, type WireContentPart, type WireErrorBody, type WireFunctionTool, type WireImageDetail, type WireIncompleteDetails, type WireInputItem, type WireInputTokensDetails, type WireNativeTool, type WireOutputItem, type WireOutputTokensDetails, type WireReasoning, type WireReasoningContent, type WireReasoningSummary, type WireRequest, type WireResponse, type WireStreamEvent, type WireTextAnnotation, type WireTextControls, type WireTextFormat, type WireTool, type WireToolChoice, type WireUsage, openAiResponsesProtocol, serializeResponsesRequest, translateResponsesStream };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/contract.ts","../src/wire.ts","../src/protocol.ts","../src/serialize.ts","../src/translate.ts"],"mappings":";;;;UAGiB;WACN,SAAS;WACT;;;UAIM;WACN;WACA;;;KAIC,sBACR,QAAQ;WAAwB;;WACrB;WAAwB,OAAO;;;UAG7B,mBAAmB;WACzB;WACA,gBAAgB;EACzB,aAAa,SAAS,iBAAiB,SAAS;EAChD,iBAAiB,SAAS,UAAU;EACpC,UAAU,SAAS,iBAAiB,SAAS,oBAAoB;EACjE,UACE,QAAQ,cAAc,mBACtB,SAAS,iBACT,sBACC,eAAe;;;;;;;;;;;;;;;;;;;KCdR;;KAGA;EACN;EAAoB;;EACpB;EAAqB;EAAmB,SAAS;;EACjD;EAAqB;EAAiB,SAAS;;EAC/C;EAAqB;EAAc,cAAc;;UAEtC;EACf;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;;;UAIe;EACf;EACA;;;;;;;;;;;KAYU;EAER;EACA;EACA,SAAS;EACT;;EAGA;;EAEA;EACA;;EAEA;;EAEA;;EAGA;EACA;;EAEA,iBAAiB;;EAGjB;EACA;EACA,SAAS;EACT,UAAU;;;;;;;EAOV;;;EAIA;EACA;EACA;EACA;;;EAIA;EACA;EACA;EACA;;;UAIa;EACf;EACA;EACA;EACA;EACA,YAAY;;UAGG;EACf;GACC;;KAGS,WAAW,mBAAmB;;KAG9B;EAIN;EAAkB;;EAClB;;;UAGW;EACf;EACA;;;UAIe;EACf,SAAS;EACT;;KAGU;EACN;;EAEF;EACA;EACA,QAAQ,SAAS;EACjB;;;UAIa;EACf;;EAEA;EACA,OAAO;EACP,QAAQ;EACR,cAAc;EACd;EACA,YAAY;EACZ,OAAO;;EAEP;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;;UAIe;;EAEf;;EAEA;;;UAIe;EACf;;;UAIe;EACf;EACA,uBAAuB;EACvB;EACA,wBAAwB;EACxB;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;;;UAIe;EACf;;;UAIe;EACf;EACA;EACA,QAAQ;EACR,QAAQ;EACR,qBAAqB;;;UAIN;EACf;EACA,WAAW;EACX,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;;;;;;;;;UAUe;;;;;;;WAON;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;WAQA;;;;;cCvQE;UAmBH,+BAA+B;WAC9B,OAAO;WACP;aACE;aACA,SAAS,SAAS;;;;UAKd;WACN;WACA;WACA;WACA,gBAAgB;WAChB,eAAe;WACf,eAAe,SAAS,wBAAwB,SAAS;WACzD,mBAAmB,SAAS,qBAAqB,SAAS;WAC1D,YACP,SAAS,wBACT,SAAS,qBACN,SAAS;WACL,YACP,QAAQ,cAAc,mBACtB,SAAS,wBACT,wBACG,eAAe;;;cAIT,yBAAyB,mBAAmB,oBACrD;;;;;;;UC/Ba;;EAEf;;EAEA;;EAEA;;;;;;;;iBAoSc,0BACd,SAAS,iBACT,SAAS,mBACR;;;;;;;;;;;;;;iBC9DoB,yBACrB,QAAQ,cAAc,mBACtB,qBACA,UAAU,kBACT,eAAe"}

package/dist/index.js

@@ -0,0 +1,664 @@
+import { CONTEXT_WINDOW_EXCEEDED_CODE, MODEL_ERROR_CODES, ModelError, QUOTA_EXCEEDED_CODE, ToolCallId, isJsonValue, isNativeToolSchema } from "@alvin0/ai-agent-sdk-core";
+
+//#region src/serialize.ts
+/** Read the reasoning state back off a block, tolerating anything unexpected. */
+function reasoningStateOf(value) {
+	if (typeof value !== "object" || value === null) return {};
+	const state = value;
+	return {
+		...typeof state.id === "string" ? { id: state.id } : {},
+		...typeof state.encryptedContent === "string" ? { encryptedContent: state.encryptedContent } : {},
+		...Array.isArray(state.summary) ? { summary: state.summary } : {}
+	};
+}
+function textAnnotations$1(block) {
+	return block.annotations?.flatMap((annotation) => annotation.type === "url-citation" ? [{
+		type: "url_citation",
+		url: annotation.url,
+		...annotation.title === void 0 ? {} : { title: annotation.title },
+		...annotation.startIndex === void 0 ? {} : { start_index: annotation.startIndex },
+		...annotation.endIndex === void 0 ? {} : { end_index: annotation.endIndex }
+	}] : []);
+}
+function imagePart(block) {
+	const detail = block.detail;
+	if (block.source.kind === "file") return {
+		type: "input_image",
+		file_id: block.source.fileId,
+		...detail === void 0 ? {} : { detail }
+	};
+	return {
+		type: "input_image",
+		image_url: block.source.kind === "url" ? block.source.url : `data:${block.source.mediaType};base64,${block.source.data}`,
+		...detail === void 0 ? {} : { detail }
+	};
+}
+/** Convert one content block to a request-side content part. */
+function contentPart(block, role) {
+	if (block.type === "text") {
+		if (role !== "assistant") return {
+			type: "input_text",
+			text: block.text
+		};
+		const annotations = textAnnotations$1(block);
+		return {
+			type: "output_text",
+			text: block.text,
+			...annotations === void 0 ? {} : { annotations }
+		};
+	}
+	if (block.type === "image") return imagePart(block);
+}
+/** Render a tool result's blocks as the wire's polymorphic `output` value. */
+function toolResultOutput(blocks) {
+	if (!blocks.some((block) => block.type === "image")) return blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+	return blocks.map((block) => contentPart(block, "user")).filter((part) => part !== void 0);
+}
+/**
+* Expand one message into zero or more wire items, appending them in order.
+*
+* Content parts accumulate into a single message item, which is FLUSHED whenever
+* a block appears that has to become its own top-level item. That flushing is
+* what preserves "spoke, then called a tool, then spoke again" as three items in
+* the right order instead of collapsing it.
+*/
+function appendMessage(message, items, dialectMessagePhase) {
+	const role = message.role === "assistant" ? "assistant" : "user";
+	let parts = [];
+	let phase;
+	const flush = () => {
+		if (parts.length === 0) return;
+		items.push({
+			type: "message",
+			role,
+			content: parts,
+			...role === "assistant" && dialectMessagePhase && phase !== void 0 ? { phase: phase === "final-answer" ? "final_answer" : phase } : {}
+		});
+		parts = [];
+		phase = void 0;
+	};
+	for (const block of message.content) switch (block.type) {
+		case "text":
+		case "image": {
+			if (block.type === "text" && block.phase !== void 0 && phase !== void 0 && phase !== block.phase) flush();
+			if (block.type === "text" && block.phase !== void 0) phase = block.phase;
+			const part = contentPart(block, role);
+			if (part !== void 0) parts.push(part);
+			break;
+		}
+		case "reasoning": {
+			flush();
+			const state = reasoningStateOf(block.providerState);
+			const summary = state.summary !== void 0 && state.summary.length > 0 ? state.summary : block.text.length > 0 ? [block.text] : [];
+			items.push({
+				type: "reasoning",
+				...state.id === void 0 ? {} : { id: state.id },
+				summary: summary.map((text) => ({
+					type: "summary_text",
+					text
+				})),
+				...state.encryptedContent === void 0 ? {} : { encrypted_content: state.encryptedContent }
+			});
+			break;
+		}
+		case "tool-call":
+			flush();
+			items.push({
+				type: "function_call",
+				call_id: block.id,
+				name: block.name,
+				arguments: block.arguments.length > 0 ? block.arguments : "{}"
+			});
+			break;
+		case "tool-result":
+			flush();
+			items.push({
+				type: "function_call_output",
+				call_id: block.toolCallId,
+				output: toolResultOutput(block.content)
+			});
+			break;
+		case "native-tool-call": {
+			flush();
+			const replay = nativeReplayItem(block.providerState);
+			if (replay !== void 0) items.push(replay);
+			break;
+		}
+	}
+	flush();
+}
+/** Collect the system prompt from the request plus any system-role messages. */
+function instructionsOf(request) {
+	const fromMessages = request.options.messages.filter((message) => message.role === "system").flatMap((message) => message.content).filter((block) => block.type === "text").map((block) => block.text);
+	return (request.options.system === void 0 ? fromMessages : [request.options.system, ...fromMessages]).join("\n\n");
+}
+/** Map the neutral tool-choice vocabulary onto this API's. */
+function toolChoiceOf(choice) {
+	if (typeof choice === "string") return choice;
+	if (choice.type === "native") return { type: nativeWireType(choice.name) };
+	return {
+		type: "function",
+		name: choice.name
+	};
+}
+/** Map a tool schema; `strict: false` because caller schemas are not vetted. */
+function functionTool(tool) {
+	return {
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		strict: false,
+		parameters: tool.parameters
+	};
+}
+function nativeWireType(name) {
+	if (name === "web-search") return "web_search";
+	if (name === "image-generation") return "image_generation";
+	return name.replaceAll("-", "_");
+}
+function webSearchTool(tool) {
+	if (tool.blockedDomains !== void 0) throw new ModelError("OpenAI Responses web search does not support blockedDomains; use allowedDomains", MODEL_ERROR_CODES.INVALID_REQUEST);
+	if (tool.maxUses !== void 0) throw new ModelError("OpenAI Responses web search does not support maxUses", MODEL_ERROR_CODES.INVALID_REQUEST);
+	return {
+		type: "web_search",
+		...tool.searchContextSize === void 0 ? {} : { search_context_size: tool.searchContextSize },
+		...tool.allowedDomains === void 0 ? {} : { filters: { allowed_domains: [...tool.allowedDomains] } },
+		...tool.userLocation === void 0 ? {} : { user_location: {
+			type: "approximate",
+			...tool.userLocation
+		} }
+	};
+}
+function imageGenerationTool(tool) {
+	return {
+		type: "image_generation",
+		...tool.size === void 0 ? {} : { size: tool.size },
+		...tool.quality === void 0 ? {} : { quality: tool.quality },
+		...tool.format === void 0 ? {} : { output_format: tool.format },
+		...tool.background === void 0 ? {} : { background: tool.background },
+		...tool.partialImages === void 0 ? {} : { partial_images: tool.partialImages }
+	};
+}
+function toolOf(tool) {
+	if (!isNativeToolSchema(tool)) return functionTool(tool);
+	if (tool.name === "web-search") return webSearchTool(tool);
+	return imageGenerationTool(tool);
+}
+function textControls(format, dialect) {
+	if (format === void 0) return void 0;
+	if (format.type === "text") return dialect.structuredOutputs ? { format: { type: "text" } } : void 0;
+	if (!dialect.structuredOutputs) throw new ModelError("This Responses endpoint does not support JSON Schema output", MODEL_ERROR_CODES.INVALID_REQUEST);
+	return { format: {
+		type: "json_schema",
+		name: format.name,
+		schema: format.schema,
+		strict: true
+	} };
+}
+function nativeReplayItem(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const item = value;
+	if (item.type === "web_search_call") return {
+		type: "web_search_call",
+		...typeof item.id === "string" ? { id: item.id } : {},
+		...typeof item.status === "string" ? { status: item.status } : {},
+		...item.action === void 0 ? {} : { action: structuredClone(item.action) }
+	};
+	if (item.type === "image_generation_call") return {
+		type: "image_generation_call",
+		...typeof item.id === "string" ? { id: item.id } : {},
+		...typeof item.status === "string" ? { status: item.status } : {},
+		...typeof item.result === "string" || item.result === null ? { result: item.result } : {}
+	};
+}
+/**
+* Build the Responses request body.
+* @param request - the resolved request, model, and connection.
+* @param dialect - which optional fields this endpoint accepts.
+* @returns the wire body, ready to serialize.
+*/
+function serializeResponsesRequest(request, dialect) {
+	const { options } = request;
+	const input = [];
+	for (const message of options.messages) {
+		if (message.role === "system") continue;
+		appendMessage(message, input, dialect.messagePhase === true);
+	}
+	const instructions = instructionsOf(request);
+	const tools = options.tools === void 0 || options.tools.length === 0 ? void 0 : options.tools.map(toolOf);
+	const text = textControls(options.outputFormat, dialect);
+	return {
+		model: options.model,
+		...instructions.length === 0 ? {} : { instructions },
+		input,
+		...tools === void 0 ? {} : { tools },
+		...options.toolChoice === void 0 ? {} : { tool_choice: toolChoiceOf(options.toolChoice) },
+		...tools === void 0 ? {} : { parallel_tool_calls: true },
+		...options.reasoningEffort === void 0 && dialect.reasoningSummary === void 0 ? {} : { reasoning: {
+			...options.reasoningEffort === void 0 ? {} : { effort: String(options.reasoningEffort) },
+			...dialect.reasoningSummary === void 0 ? {} : { summary: dialect.reasoningSummary }
+		} },
+		...text === void 0 ? {} : { text },
+		store: dialect.store,
+		stream: true,
+		...dialect.include.length === 0 ? {} : { include: [...dialect.include] },
+		...dialect.promptCacheKey === void 0 ? {} : { prompt_cache_key: dialect.promptCacheKey },
+		...dialect.maxOutputTokens ? { max_output_tokens: request.maxTokens } : {},
+		...dialect.sampling && options.temperature !== void 0 ? { temperature: options.temperature } : {},
+		...dialect.sampling && options.topP !== void 0 ? { top_p: options.topP } : {}
+	};
+}
+
+//#endregion
+//#region src/translate.ts
+/**
+* Responses API SSE events to the SDK's chunk protocol.
+*
+* Two design notes worth reading before changing anything here.
+*
+* First, block correlation is keyed on `item_id`, not on the provider's
+* `output_index`. Item ids are stable and present on every delta event, whereas
+* index fields vary by event type, so keying on the id and assigning our OWN
+* indices in first-seen order is both simpler and closer to what our protocol
+* promises.
+*
+* Second, reasoning state is carried on the reasoning BLOCK
+* (`ReasoningBlock.providerState`) rather than in the stream's `replayState`
+* envelope. The envelope has to stay positionally aligned with emitted blocks and
+* is discarded whole when it drifts; attaching the state to the block it belongs
+* to cannot drift, and it survives assembly for free.
+*
+* @module ai-agent-sdk/providers/responses/translate
+*/
+function textPhase(value) {
+	if (value === "commentary") return "commentary";
+	if (value === "final_answer") return "final-answer";
+}
+/** Map an output item's wire type onto one of our block types. */
+function itemKind(type) {
+	switch (type) {
+		case "message": return "text";
+		case "reasoning": return "reasoning";
+		case "function_call": return "tool-call";
+		case "web_search_call": return "native-tool-call";
+		case "image_generation_call": return "native-tool-call";
+		default: return;
+	}
+}
+function nativeName(type) {
+	if (type === "web_search_call") return "web-search";
+	if (type === "image_generation_call") return "image-generation";
+	return type?.replace(/_call$/, "").replaceAll("_", "-") ?? "native-tool";
+}
+function textAnnotations(item) {
+	if (!Array.isArray(item.content)) return [];
+	return item.content.flatMap((part) => {
+		if (typeof part !== "object" || part === null) return [];
+		const annotations = part.annotations;
+		if (!Array.isArray(annotations)) return [];
+		return annotations.flatMap((annotation) => {
+			if (typeof annotation !== "object" || annotation === null) return [];
+			const record = annotation;
+			if (record.type !== "url_citation" || typeof record.url !== "string") return [];
+			return [{
+				type: "url-citation",
+				url: record.url,
+				...typeof record.title === "string" ? { title: record.title } : {},
+				...typeof record.start_index === "number" ? { startIndex: record.start_index } : {},
+				...typeof record.end_index === "number" ? { endIndex: record.end_index } : {}
+			}];
+		});
+	});
+}
+/** Collect the text of a done item's `content` array. */
+function itemText(item) {
+	const content = item.content;
+	if (!Array.isArray(content)) return "";
+	return content.map((part) => {
+		if (typeof part !== "object" || part === null) return "";
+		const record = part;
+		return typeof record.text === "string" ? record.text : "";
+	}).join("");
+}
+/** Collect the summary paragraphs of a done reasoning item. */
+function itemSummary(item) {
+	const summary = item.summary;
+	if (!Array.isArray(summary)) return [];
+	return summary.map((part) => {
+		if (typeof part !== "object" || part === null) return "";
+		const record = part;
+		return typeof record.text === "string" ? record.text : "";
+	}).filter((text) => text.length > 0);
+}
+/**
+* Normalize usage, honouring the SDK's disjoint-count convention.
+*
+* This API reports `input_tokens` as the TOTAL input and
+* `input_tokens_details.cached_tokens` as a subset of it. Our convention is that
+* the three input figures are disjoint and sum to what is billed, so the cached
+* portion is subtracted back out here. Skip that and every cost estimate
+* double-counts cache hits.
+*/
+function mapUsage(usage) {
+	const source = usage;
+	const details = recordOrUndefined(source.input_tokens_details);
+	const outputDetails = recordOrUndefined(source.output_tokens_details);
+	const rawInput = source.input_tokens;
+	const outputTokens = source.output_tokens;
+	const cacheRead = details?.cached_tokens;
+	const cacheWrite = details?.cache_write_tokens;
+	const reasoning = outputDetails?.reasoning_tokens;
+	const totalTokens = source.total_tokens;
+	if (![
+		rawInput,
+		outputTokens,
+		cacheRead,
+		cacheWrite,
+		reasoning,
+		totalTokens
+	].some((value) => value !== void 0)) return void 0;
+	const normalized = {
+		...outputTokens === void 0 ? {} : { outputTokens },
+		...totalTokens === void 0 ? {} : { totalTokens },
+		...cacheRead === void 0 || cacheRead === 0 ? {} : { cacheReadTokens: cacheRead },
+		...cacheWrite === void 0 || cacheWrite === 0 ? {} : { cacheWriteTokens: cacheWrite },
+		...reasoning === void 0 || reasoning === 0 ? {} : { reasoningTokens: reasoning }
+	};
+	if (rawInput !== void 0) normalized.inputTokens = typeof rawInput === "number" && (cacheRead === void 0 || typeof cacheRead === "number") ? rawInput - (cacheRead ?? 0) : rawInput;
+	return normalized;
+}
+function recordOrUndefined(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+/** Codes that mean "do not retry this"; everything else stays retryable. */
+const TERMINAL_ERROR_CODES = Object.freeze({
+	context_length_exceeded: CONTEXT_WINDOW_EXCEEDED_CODE,
+	insufficient_quota: QUOTA_EXCEEDED_CODE,
+	invalid_prompt: MODEL_ERROR_CODES.INVALID_REQUEST,
+	bio_policy: MODEL_ERROR_CODES.INVALID_REQUEST,
+	cyber_policy: MODEL_ERROR_CODES.INVALID_REQUEST,
+	misalignment_policy_violation: MODEL_ERROR_CODES.INVALID_REQUEST,
+	rate_limit_exceeded: MODEL_ERROR_CODES.RATE_LIMIT
+});
+/** Turn a `response.failed` payload into a typed, correctly classified error. */
+function failedError(response, displayName) {
+	const error = response?.error ?? void 0;
+	const code = error?.code ?? error?.type;
+	const message = error?.message ?? `${displayName} reported a failed response`;
+	const mapped = code === void 0 ? void 0 : TERMINAL_ERROR_CODES[code];
+	return new ModelError(message, mapped ?? MODEL_ERROR_CODES.SERVER, {});
+}
+/** Build the authoritative block for a completed item. */
+function doneBlock(item, open, imageMediaType) {
+	switch (open.kind) {
+		case "text": {
+			const text = itemText(item);
+			const phase = textPhase(item.phase) ?? open.phase;
+			return {
+				type: "text",
+				text: text.length > 0 ? text : open.text,
+				...phase === void 0 ? {} : { phase },
+				...textAnnotations(item).length === 0 ? {} : { annotations: textAnnotations(item) }
+			};
+		}
+		case "reasoning": {
+			const summary = itemSummary(item);
+			const state = {
+				...typeof item.id === "string" ? { id: item.id } : {},
+				...typeof item.encrypted_content === "string" ? { encryptedContent: item.encrypted_content } : {},
+				...summary.length > 0 ? { summary } : {}
+			};
+			return {
+				type: "reasoning",
+				text: summary.length > 0 ? summary.join("\n\n") : open.text,
+				providerState: state
+			};
+		}
+		case "tool-call": {
+			const args = typeof item.arguments === "string" && item.arguments.length > 0 ? item.arguments : open.args;
+			return {
+				type: "tool-call",
+				id: ToolCallId(item.call_id ?? open.callId),
+				name: item.name ?? open.name,
+				arguments: args.length > 0 ? args : "{}"
+			};
+		}
+		case "native-tool-call": {
+			const content = open.nativeName === "image-generation" && typeof item.result === "string" && item.result.length > 0 ? [{
+				type: "image",
+				source: {
+					kind: "base64",
+					mediaType: imageMediaType,
+					data: item.result
+				}
+			}] : [];
+			return {
+				type: "native-tool-call",
+				id: item.id ?? open.callId,
+				name: open.nativeName,
+				...typeof item.status === "string" ? { status: item.status } : {},
+				...isJsonValue(item.action) ? { arguments: item.action } : {},
+				content,
+				providerState: item
+			};
+		}
+		default: return;
+	}
+}
+/**
+* Translate one Responses SSE stream.
+*
+* Owns termination. This API sends no `[DONE]` sentinel: the stream ends on
+* `response.completed`, `response.failed`, or `response.incomplete`, and a body
+* that ends without one of those was truncated — which is a failure, not an
+* empty success, because a truncated turn cannot be trusted.
+* @param events - decoded SSE events.
+* @param displayName - provider name, used in diagnostics.
+* @returns the chunk stream.
+*/
+async function* translateResponsesStream(events, displayName, request) {
+	const open = /* @__PURE__ */ new Map();
+	let nextIndex = 0;
+	let sawToolCall = false;
+	let terminated = false;
+	const imageMediaType = requestedImageMediaType(request);
+	for await (const raw of events) {
+		let event;
+		try {
+			event = JSON.parse(raw.data);
+		} catch (error) {
+			throw new ModelError(`${displayName} sent a malformed stream event`, MODEL_ERROR_CODES.MALFORMED_RESPONSE, { cause: error });
+		}
+		switch (event.type) {
+			case "response.output_item.added": {
+				const item = event.item;
+				const id = item?.id ?? event.item_id;
+				const kind = itemKind(item?.type);
+				if (item === void 0 || id === void 0 || kind === void 0) break;
+				if (open.has(id)) break;
+				const entry = {
+					index: nextIndex++,
+					kind,
+					text: "",
+					args: "",
+					callId: item.call_id ?? id,
+					name: item.name ?? "",
+					nativeName: nativeName(item.type),
+					summaryIndex: void 0,
+					phase: textPhase(item.phase)
+				};
+				open.set(id, entry);
+				if (kind === "tool-call") sawToolCall = true;
+				yield {
+					type: "block-start",
+					index: entry.index,
+					blockType: kindToBlockType(kind)
+				};
+				break;
+			}
+			case "response.output_text.delta": {
+				const entry = event.item_id === void 0 ? void 0 : open.get(event.item_id);
+				if (entry === void 0 || event.delta === void 0) break;
+				entry.text += event.delta;
+				yield {
+					type: "text-delta",
+					index: entry.index,
+					text: event.delta,
+					...entry.phase === void 0 ? {} : { phase: entry.phase }
+				};
+				break;
+			}
+			case "response.reasoning_summary_text.delta": {
+				const entry = event.item_id === void 0 ? void 0 : open.get(event.item_id);
+				if (entry === void 0 || event.delta === void 0) break;
+				const separator = entry.summaryIndex !== void 0 && event.summary_index !== void 0 && event.summary_index !== entry.summaryIndex ? "\n\n" : "";
+				entry.summaryIndex = event.summary_index;
+				const text = `${separator}${event.delta}`;
+				entry.text += text;
+				yield {
+					type: "reasoning-delta",
+					index: entry.index,
+					text
+				};
+				break;
+			}
+			case "response.reasoning_text.delta": {
+				const entry = event.item_id === void 0 ? void 0 : open.get(event.item_id);
+				if (entry === void 0 || event.delta === void 0) break;
+				entry.text += event.delta;
+				yield {
+					type: "reasoning-delta",
+					index: entry.index,
+					text: event.delta
+				};
+				break;
+			}
+			case "response.function_call_arguments.delta": {
+				const entry = event.item_id === void 0 ? void 0 : open.get(event.item_id);
+				if (entry === void 0 || event.delta === void 0) break;
+				entry.args += event.delta;
+				yield {
+					type: "tool-call-delta",
+					index: entry.index,
+					id: ToolCallId(entry.callId),
+					...entry.name.length > 0 ? { name: entry.name } : {},
+					argumentsDelta: event.delta
+				};
+				break;
+			}
+			case "response.image_generation_call.partial_image": {
+				const itemId = event.item_id;
+				const entry = itemId === void 0 ? void 0 : open.get(itemId);
+				if (itemId === void 0 || entry === void 0 || event.partial_image_b64 === void 0) break;
+				yield {
+					type: "image-delta",
+					index: entry.index,
+					itemId,
+					data: event.partial_image_b64,
+					mediaType: imageMediaType,
+					...event.partial_image_index === void 0 ? {} : { partialIndex: event.partial_image_index }
+				};
+				break;
+			}
+			case "response.output_item.done": {
+				const item = event.item;
+				const id = item?.id ?? event.item_id;
+				const entry = id === void 0 ? void 0 : open.get(id);
+				if (item === void 0 || entry === void 0) break;
+				const block = doneBlock(item, entry, imageMediaType);
+				if (block !== void 0) yield {
+					type: "block-end",
+					index: entry.index,
+					block
+				};
+				break;
+			}
+			case "response.completed": {
+				const usage = event.response?.usage ?? void 0;
+				const mapped = usage === void 0 ? void 0 : mapUsage(usage);
+				if (mapped !== void 0) yield {
+					type: "usage",
+					usage: mapped
+				};
+				yield {
+					type: "finish",
+					reason: sawToolCall ? { kind: "tool-calls" } : { kind: "stop" }
+				};
+				terminated = true;
+				return;
+			}
+			case "response.incomplete": {
+				const usage = event.response?.usage ?? void 0;
+				const mapped = usage === void 0 ? void 0 : mapUsage(usage);
+				if (mapped !== void 0) yield {
+					type: "usage",
+					usage: mapped
+				};
+				const why = event.response?.incomplete_details?.reason;
+				if (why === "max_output_tokens") {
+					yield {
+						type: "finish",
+						reason: { kind: "max-tokens" }
+					};
+					terminated = true;
+					return;
+				}
+				throw new ModelError(`${displayName} returned an incomplete response (${why ?? "unknown reason"})`, MODEL_ERROR_CODES.SERVER);
+			}
+			case "response.failed": throw failedError(event.response, displayName);
+			case "error": throw failedError({ error: {
+				...event.code === void 0 ? {} : { code: event.code },
+				...event.message === void 0 ? {} : { message: event.message }
+			} }, displayName);
+		}
+	}
+	if (!terminated) throw new ModelError(`${displayName} stream ended before the response completed`, MODEL_ERROR_CODES.STREAM_CLOSED);
+}
+/** Our block-type tag for one item kind. */
+function kindToBlockType(kind) {
+	return kind;
+}
+function requestedImageMediaType(request) {
+	const tool = request?.options.tools?.find((candidate) => "type" in candidate && candidate.type === "native" && candidate.name === "image-generation");
+	if (tool === void 0 || !("format" in tool)) return "image/png";
+	if (tool.format === "jpeg") return "image/jpeg";
+	if (tool.format === "webp") return "image/webp";
+	return "image/png";
+}
+
+//#endregion
+//#region src/protocol.ts
+/** Protocol id, usable as a stable string in configuration. */
+const OPENAI_RESPONSES_PROTOCOL_ID = "openai-responses";
+/**
+* Conservative defaults.
+*
+* `store: false` because retaining prompts server-side should be an explicit
+* decision, not something an SDK turns on for you. `include` carries
+* `reasoning.encrypted_content` because without it a reasoning model loses its
+* chain of thought between a tool call and the tool's result.
+*/
+const DEFAULT_DIALECT = Object.freeze({
+	sampling: true,
+	maxOutputTokens: true,
+	structuredOutputs: true,
+	store: false,
+	include: Object.freeze(["reasoning.encrypted_content"]),
+	reasoningSummary: "auto"
+});
+/** The OpenAI Responses wire protocol. */
+const openAiResponsesProtocol = Object.freeze({
+	kind: "http-wire-protocol",
+	apiVersion: 1,
+	id: OPENAI_RESPONSES_PROTOCOL_ID,
+	defaultDialect: DEFAULT_DIALECT,
+	endpointPath: () => "/responses",
+	serialize(request, dialect) {
+		return serializeResponsesRequest(request, dialect);
+	},
+	translate: (events, request, displayName) => translateResponsesStream(events, displayName, request)
+});
+
+//#endregion
+export { OPENAI_RESPONSES_PROTOCOL_ID, openAiResponsesProtocol, serializeResponsesRequest, translateResponsesStream };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["textAnnotations"],"sources":["../src/serialize.ts","../src/translate.ts","../src/protocol.ts"],"sourcesContent":["/**\n * Normalized request to Responses API wire JSON.\n *\n * The interesting work is flattening. Our conversation is a list of messages,\n * each holding an ordered list of content blocks; the wire wants a FLAT list of\n * items where a tool result and a tool call are peers of a message rather than\n * parts of one. So one assistant message that reasoned, spoke, and called two\n * tools expands to four items, and their relative order must be preserved\n * because the model reads it as its own prior turn.\n *\n * @module ai-agent-sdk/providers/responses/serialize\n */\n\nimport type { ProtocolRequest } from './contract.ts'\nimport { MODEL_ERROR_CODES, ModelError } from '@alvin0/ai-agent-sdk-core'\nimport type { ContentBlock, ImageBlock, TextBlock } from '@alvin0/ai-agent-sdk-core'\nimport type { Message } from '@alvin0/ai-agent-sdk-core'\nimport {\n  isNativeToolSchema,\n  type ModelOutputFormat,\n  type ModelToolSchema,\n  type NativeImageGenerationTool,\n  type NativeWebSearchTool,\n  type ToolChoice,\n  type ToolSchema,\n} from '@alvin0/ai-agent-sdk-core'\nimport type {\n  ResponsesDialect,\n  WireContentPart,\n  WireInputItem,\n  WireRequest,\n  WireTool,\n  WireToolChoice,\n  WireTextControls,\n} from './wire.ts'\n\n/**\n * Adapter-private state kept on a {@link ReasoningBlock} so a reasoning item can\n * be echoed back byte-identically on the next request of a tool-use loop.\n */\nexport interface ResponsesReasoningState {\n  /** Server-assigned item id. */\n  id?: string\n  /** Opaque encrypted chain of thought. */\n  encryptedContent?: string\n  /** Summary paragraphs, in order. */\n  summary?: readonly string[]\n}\n\n/** Read the reasoning state back off a block, tolerating anything unexpected. */\nfunction reasoningStateOf(value: unknown): ResponsesReasoningState {\n  if (typeof value !== 'object' || value === null) return {}\n  const state = value as ResponsesReasoningState\n  return {\n    ...typeof state.id === 'string' ? { id: state.id } : {},\n    ...typeof state.encryptedContent === 'string'\n      ? { encryptedContent: state.encryptedContent }\n      : {},\n    ...Array.isArray(state.summary) ? { summary: state.summary } : {},\n  }\n}\n\nfunction textAnnotations(block: TextBlock) {\n  return block.annotations?.flatMap(annotation => annotation.type === 'url-citation'\n    ? [{\n      type: 'url_citation' as const,\n      url: annotation.url,\n      ...annotation.title === undefined ? {} : { title: annotation.title },\n      ...annotation.startIndex === undefined ? {} : { start_index: annotation.startIndex },\n      ...annotation.endIndex === undefined ? {} : { end_index: annotation.endIndex },\n    }]\n    : [])\n}\n\nfunction imagePart(block: ImageBlock): WireContentPart {\n  const detail = block.detail\n  if (block.source.kind === 'file') {\n    return { type: 'input_image', file_id: block.source.fileId, ...detail === undefined ? {} : { detail } }\n  }\n  const image_url = block.source.kind === 'url'\n    ? block.source.url\n    : `data:${block.source.mediaType};base64,${block.source.data}`\n  return { type: 'input_image', image_url, ...detail === undefined ? {} : { detail } }\n}\n\n/** Convert one content block to a request-side content part. */\nfunction contentPart(block: ContentBlock, role: 'user' | 'assistant'): WireContentPart | undefined {\n  if (block.type === 'text') {\n    // An assistant turn's own text must come back as `output_text`; sending it as\n    // `input_text` would present the model's prior words as if the user said them.\n    if (role !== 'assistant') return { type: 'input_text', text: block.text }\n    const annotations = textAnnotations(block)\n    return {\n      type: 'output_text', text: block.text,\n      ...annotations === undefined ? {} : { annotations },\n    }\n  }\n  if (block.type === 'image') return imagePart(block)\n  return undefined\n}\n\n/** Render a tool result's blocks as the wire's polymorphic `output` value. */\nfunction toolResultOutput(blocks: readonly ContentBlock[]): string | WireContentPart[] {\n  const hasImage = blocks.some(block => block.type === 'image')\n  if (!hasImage) {\n    // The common case. A plain string keeps the payload small and is what the\n    // API documents first.\n    return blocks\n      .filter((block): block is Extract<ContentBlock, { type: 'text' }> => block.type === 'text')\n      .map(block => block.text)\n      .join('\\n')\n  }\n  return blocks\n    .map(block => contentPart(block, 'user'))\n    .filter((part): part is WireContentPart => part !== undefined)\n}\n\n/**\n * Expand one message into zero or more wire items, appending them in order.\n *\n * Content parts accumulate into a single message item, which is FLUSHED whenever\n * a block appears that has to become its own top-level item. That flushing is\n * what preserves \"spoke, then called a tool, then spoke again\" as three items in\n * the right order instead of collapsing it.\n */\nfunction appendMessage(message: Message, items: WireInputItem[], dialectMessagePhase: boolean): void {\n  const role = message.role === 'assistant' ? 'assistant' : 'user'\n  let parts: WireContentPart[] = []\n  let phase: Extract<ContentBlock, { type: 'text' }>['phase']\n\n  const flush = (): void => {\n    if (parts.length === 0) return\n    items.push({\n      type: 'message', role, content: parts,\n      ...role === 'assistant' && dialectMessagePhase && phase !== undefined\n        ? { phase: phase === 'final-answer' ? 'final_answer' as const : phase }\n        : {},\n    })\n    parts = []\n    phase = undefined\n  }\n\n  for (const block of message.content) {\n    switch (block.type) {\n      case 'text':\n      case 'image': {\n        if (block.type === 'text' && block.phase !== undefined && phase !== undefined && phase !== block.phase) flush()\n        if (block.type === 'text' && block.phase !== undefined) phase = block.phase\n        const part = contentPart(block, role)\n        if (part !== undefined) parts.push(part)\n        break\n      }\n      case 'reasoning': {\n        flush()\n        const state = reasoningStateOf(block.providerState)\n        // Prefer the recorded summary paragraphs; fall back to the block's text so\n        // a hand-built or replayed message still carries something.\n        const summary = state.summary !== undefined && state.summary.length > 0\n          ? state.summary\n          : block.text.length > 0 ? [block.text] : []\n        items.push({\n          type: 'reasoning',\n          ...state.id === undefined ? {} : { id: state.id },\n          summary: summary.map(text => ({ type: 'summary_text' as const, text })),\n          ...state.encryptedContent === undefined\n            ? {}\n            : { encrypted_content: state.encryptedContent },\n        })\n        break\n      }\n      case 'tool-call': {\n        flush()\n        items.push({\n          type: 'function_call',\n          call_id: block.id,\n          name: block.name,\n          // Empty arguments must still be valid JSON, or the provider rejects it.\n          arguments: block.arguments.length > 0 ? block.arguments : '{}',\n        })\n        break\n      }\n      case 'tool-result': {\n        flush()\n        items.push({\n          type: 'function_call_output',\n          call_id: block.toolCallId,\n          output: toolResultOutput(block.content),\n        })\n        break\n      }\n      case 'native-tool-call': {\n        flush()\n        const replay = nativeReplayItem(block.providerState)\n        if (replay !== undefined) items.push(replay)\n        break\n      }\n      default:\n        // A content block introduced by declaration merging. Skipping is correct:\n        // this serializer cannot know its wire form, and inventing one would\n        // corrupt the request.\n        break\n    }\n  }\n  flush()\n}\n\n/** Collect the system prompt from the request plus any system-role messages. */\nfunction instructionsOf(request: ProtocolRequest): string {\n  const fromMessages = request.options.messages\n    .filter(message => message.role === 'system')\n    .flatMap(message => message.content)\n    .filter((block): block is Extract<ContentBlock, { type: 'text' }> => block.type === 'text')\n    .map(block => block.text)\n  const all = request.options.system === undefined\n    ? fromMessages\n    : [request.options.system, ...fromMessages]\n  return all.join('\\n\\n')\n}\n\n/** Map the neutral tool-choice vocabulary onto this API's. */\nfunction toolChoiceOf(choice: ToolChoice): WireToolChoice {\n  if (typeof choice === 'string') return choice\n  if (choice.type === 'native') return { type: nativeWireType(choice.name) }\n  return { type: 'function', name: choice.name }\n}\n\n/** Map a tool schema; `strict: false` because caller schemas are not vetted. */\nfunction functionTool(tool: ToolSchema): WireTool {\n  return {\n    type: 'function',\n    name: tool.name,\n    description: tool.description,\n    // Strict mode imposes real JSON-Schema restrictions (no optional fields\n    // without null, `additionalProperties: false` required). Opting a caller's\n    // schema in silently would turn a working tool into a request rejection.\n    strict: false,\n    parameters: tool.parameters,\n  }\n}\n\nfunction nativeWireType(name: string): string {\n  if (name === 'web-search') return 'web_search'\n  if (name === 'image-generation') return 'image_generation'\n  return name.replaceAll('-', '_')\n}\n\nfunction webSearchTool(tool: NativeWebSearchTool): WireTool {\n  if (tool.blockedDomains !== undefined) {\n    throw new ModelError(\n      'OpenAI Responses web search does not support blockedDomains; use allowedDomains',\n      MODEL_ERROR_CODES.INVALID_REQUEST,\n    )\n  }\n  if (tool.maxUses !== undefined) {\n    throw new ModelError(\n      'OpenAI Responses web search does not support maxUses',\n      MODEL_ERROR_CODES.INVALID_REQUEST,\n    )\n  }\n  return {\n    type: 'web_search',\n    ...tool.searchContextSize === undefined ? {} : { search_context_size: tool.searchContextSize },\n    ...tool.allowedDomains === undefined ? {} : { filters: { allowed_domains: [...tool.allowedDomains] } },\n    ...tool.userLocation === undefined ? {} : {\n      user_location: { type: 'approximate', ...tool.userLocation },\n    },\n  }\n}\n\nfunction imageGenerationTool(tool: NativeImageGenerationTool): WireTool {\n  return {\n    type: 'image_generation',\n    ...tool.size === undefined ? {} : { size: tool.size },\n    ...tool.quality === undefined ? {} : { quality: tool.quality },\n    ...tool.format === undefined ? {} : { output_format: tool.format },\n    ...tool.background === undefined ? {} : { background: tool.background },\n    ...tool.partialImages === undefined ? {} : { partial_images: tool.partialImages },\n  }\n}\n\nfunction toolOf(tool: ModelToolSchema): WireTool {\n  if (!isNativeToolSchema(tool)) return functionTool(tool)\n  if (tool.name === 'web-search') return webSearchTool(tool)\n  return imageGenerationTool(tool)\n}\n\nfunction textControls(\n  format: ModelOutputFormat | undefined,\n  dialect: ResponsesDialect,\n): WireTextControls | undefined {\n  if (format === undefined) return undefined\n  if (format.type === 'text') {\n    return dialect.structuredOutputs ? { format: { type: 'text' } } : undefined\n  }\n  if (!dialect.structuredOutputs) {\n    throw new ModelError(\n      'This Responses endpoint does not support JSON Schema output',\n      MODEL_ERROR_CODES.INVALID_REQUEST,\n    )\n  }\n  return {\n    format: {\n      type: 'json_schema',\n      name: format.name,\n      schema: format.schema,\n      strict: true,\n    },\n  }\n}\n\nfunction nativeReplayItem(value: unknown): WireInputItem | undefined {\n  if (typeof value !== 'object' || value === null) return undefined\n  const item = value as Record<string, unknown>\n  if (item.type === 'web_search_call') {\n    return {\n      type: 'web_search_call',\n      ...typeof item.id === 'string' ? { id: item.id } : {},\n      ...typeof item.status === 'string' ? { status: item.status } : {},\n      ...item.action === undefined ? {} : { action: structuredClone(item.action) },\n    }\n  }\n  if (item.type === 'image_generation_call') {\n    return {\n      type: 'image_generation_call',\n      ...typeof item.id === 'string' ? { id: item.id } : {},\n      ...typeof item.status === 'string' ? { status: item.status } : {},\n      ...typeof item.result === 'string' || item.result === null ? { result: item.result } : {},\n    }\n  }\n  return undefined\n}\n\n/**\n * Build the Responses request body.\n * @param request - the resolved request, model, and connection.\n * @param dialect - which optional fields this endpoint accepts.\n * @returns the wire body, ready to serialize.\n */\nexport function serializeResponsesRequest(\n  request: ProtocolRequest,\n  dialect: ResponsesDialect,\n): WireRequest {\n  const { options } = request\n  const input: WireInputItem[] = []\n  for (const message of options.messages) {\n    if (message.role === 'system') continue // folded into `instructions`\n    appendMessage(message, input, dialect.messagePhase === true)\n  }\n\n  const instructions = instructionsOf(request)\n  const tools = options.tools === undefined || options.tools.length === 0\n    ? undefined\n    : options.tools.map(toolOf)\n  const text = textControls(options.outputFormat, dialect)\n\n  return {\n    model: options.model,\n    ...instructions.length === 0 ? {} : { instructions },\n    input,\n    ...tools === undefined ? {} : { tools },\n    ...options.toolChoice === undefined ? {} : { tool_choice: toolChoiceOf(options.toolChoice) },\n    ...tools === undefined ? {} : { parallel_tool_calls: true },\n    ...options.reasoningEffort === undefined && dialect.reasoningSummary === undefined\n      ? {}\n      : {\n        reasoning: {\n          ...options.reasoningEffort === undefined\n            ? {}\n            : { effort: String(options.reasoningEffort) },\n          ...dialect.reasoningSummary === undefined\n            ? {}\n            : { summary: dialect.reasoningSummary },\n        },\n      },\n    ...text === undefined ? {} : { text },\n    store: dialect.store,\n    stream: true,\n    ...dialect.include.length === 0 ? {} : { include: [...dialect.include] },\n    ...dialect.promptCacheKey === undefined ? {} : { prompt_cache_key: dialect.promptCacheKey },\n    ...dialect.maxOutputTokens ? { max_output_tokens: request.maxTokens } : {},\n    ...dialect.sampling && options.temperature !== undefined\n      ? { temperature: options.temperature }\n      : {},\n    ...dialect.sampling && options.topP !== undefined ? { top_p: options.topP } : {},\n  }\n}\n","/**\n * Responses API SSE events to the SDK's chunk protocol.\n *\n * Two design notes worth reading before changing anything here.\n *\n * First, block correlation is keyed on `item_id`, not on the provider's\n * `output_index`. Item ids are stable and present on every delta event, whereas\n * index fields vary by event type, so keying on the id and assigning our OWN\n * indices in first-seen order is both simpler and closer to what our protocol\n * promises.\n *\n * Second, reasoning state is carried on the reasoning BLOCK\n * (`ReasoningBlock.providerState`) rather than in the stream's `replayState`\n * envelope. The envelope has to stay positionally aligned with emitted blocks and\n * is discarded whole when it drifts; attaching the state to the block it belongs\n * to cannot drift, and it survives assembly for free.\n *\n * @module ai-agent-sdk/providers/responses/translate\n */\n\nimport {\n  CONTEXT_WINDOW_EXCEEDED_CODE,\n  QUOTA_EXCEEDED_CODE,\n} from '@alvin0/ai-agent-sdk-core'\nimport { MODEL_ERROR_CODES, ModelError } from '@alvin0/ai-agent-sdk-core'\nimport { ToolCallId } from '@alvin0/ai-agent-sdk-core'\nimport { isJsonValue } from '@alvin0/ai-agent-sdk-core'\nimport type {\n  AssistantTextPhase,\n  ContentBlock,\n  ImageMediaType,\n  TextAnnotation,\n} from '@alvin0/ai-agent-sdk-core'\nimport type { FinishReason, UsageCounters } from '@alvin0/ai-agent-sdk-core'\nimport type { ProtocolRequest, ProtocolSseEvent, ProtocolStreamChunk } from './contract.ts'\nimport type { ResponsesReasoningState } from './serialize.ts'\nimport type {\n  WireErrorBody,\n  WireOutputItem,\n  WireResponse,\n  WireStreamEvent,\n  WireUsage,\n} from './wire.ts'\n\n/** Which of our block types one output item maps to. */\ntype ItemKind = 'text' | 'reasoning' | 'tool-call' | 'native-tool-call'\n\ninterface OpenItem {\n  readonly index: number\n  readonly kind: ItemKind\n  text: string\n  args: string\n  callId: string\n  name: string\n  nativeName: string\n  /** Last `summary_index` seen, so a new paragraph gets a separator. */\n  summaryIndex: number | undefined\n  phase: AssistantTextPhase | undefined\n}\n\nfunction textPhase(value: string | undefined): AssistantTextPhase | undefined {\n  if (value === 'commentary') return 'commentary'\n  if (value === 'final_answer') return 'final-answer'\n  return undefined\n}\n\n/** Map an output item's wire type onto one of our block types. */\nfunction itemKind(type: string | undefined): ItemKind | undefined {\n  switch (type) {\n    case 'message': return 'text'\n    case 'reasoning': return 'reasoning'\n    case 'function_call': return 'tool-call'\n    case 'web_search_call': return 'native-tool-call'\n    case 'image_generation_call': return 'native-tool-call'\n    default: return undefined\n  }\n}\n\nfunction nativeName(type: string | undefined): string {\n  if (type === 'web_search_call') return 'web-search'\n  if (type === 'image_generation_call') return 'image-generation'\n  return type?.replace(/_call$/, '').replaceAll('_', '-') ?? 'native-tool'\n}\n\nfunction textAnnotations(item: WireOutputItem): TextAnnotation[] {\n  if (!Array.isArray(item.content)) return []\n  return item.content.flatMap((part) => {\n    if (typeof part !== 'object' || part === null) return []\n    const annotations = (part as Record<string, unknown>).annotations\n    if (!Array.isArray(annotations)) return []\n    return annotations.flatMap((annotation): TextAnnotation[] => {\n      if (typeof annotation !== 'object' || annotation === null) return []\n      const record = annotation as Record<string, unknown>\n      if (record.type !== 'url_citation' || typeof record.url !== 'string') return []\n      return [{\n        type: 'url-citation',\n        url: record.url,\n        ...typeof record.title === 'string' ? { title: record.title } : {},\n        ...typeof record.start_index === 'number' ? { startIndex: record.start_index } : {},\n        ...typeof record.end_index === 'number' ? { endIndex: record.end_index } : {},\n      }]\n    })\n  })\n}\n\n/** Collect the text of a done item's `content` array. */\nfunction itemText(item: WireOutputItem): string {\n  const content = item.content\n  if (!Array.isArray(content)) return ''\n  return content\n    .map((part) => {\n      if (typeof part !== 'object' || part === null) return ''\n      const record = part as Record<string, unknown>\n      return typeof record.text === 'string' ? record.text : ''\n    })\n    .join('')\n}\n\n/** Collect the summary paragraphs of a done reasoning item. */\nfunction itemSummary(item: WireOutputItem): string[] {\n  const summary = item.summary\n  if (!Array.isArray(summary)) return []\n  return summary\n    .map((part) => {\n      if (typeof part !== 'object' || part === null) return ''\n      const record = part as Record<string, unknown>\n      return typeof record.text === 'string' ? record.text : ''\n    })\n    .filter(text => text.length > 0)\n}\n\n/**\n * Normalize usage, honouring the SDK's disjoint-count convention.\n *\n * This API reports `input_tokens` as the TOTAL input and\n * `input_tokens_details.cached_tokens` as a subset of it. Our convention is that\n * the three input figures are disjoint and sum to what is billed, so the cached\n * portion is subtracted back out here. Skip that and every cost estimate\n * double-counts cache hits.\n */\nfunction mapUsage(usage: WireUsage): UsageCounters | undefined {\n  const source = usage as unknown as Record<string, unknown>\n  const details = recordOrUndefined(source.input_tokens_details)\n  const outputDetails = recordOrUndefined(source.output_tokens_details)\n  const rawInput = source.input_tokens\n  const outputTokens = source.output_tokens\n  const cacheRead = details?.cached_tokens\n  const cacheWrite = details?.cache_write_tokens\n  const reasoning = outputDetails?.reasoning_tokens\n  const totalTokens = source.total_tokens\n  const hasAny = [rawInput, outputTokens, cacheRead, cacheWrite, reasoning, totalTokens]\n    .some(value => value !== undefined)\n  if (!hasAny) return undefined\n\n  const normalized: Record<string, unknown> = {\n    ...outputTokens === undefined ? {} : { outputTokens },\n    ...totalTokens === undefined ? {} : { totalTokens },\n    // Omitted cache details are authoritative zero for Responses. Present\n    // malformed values are retained for the accounting validator.\n    ...cacheRead === undefined || cacheRead === 0 ? {} : { cacheReadTokens: cacheRead },\n    ...cacheWrite === undefined || cacheWrite === 0 ? {} : { cacheWriteTokens: cacheWrite },\n    ...reasoning === undefined || reasoning === 0 ? {} : { reasoningTokens: reasoning },\n  }\n  if (rawInput !== undefined) {\n    normalized.inputTokens = typeof rawInput === 'number'\n      && (cacheRead === undefined || typeof cacheRead === 'number')\n      ? rawInput - (cacheRead ?? 0)\n      : rawInput\n  }\n  return normalized as UsageCounters\n}\n\nfunction recordOrUndefined(value: unknown): Record<string, unknown> | undefined {\n  return typeof value === 'object' && value !== null ? value as Record<string, unknown> : undefined\n}\n\n/** Codes that mean \"do not retry this\"; everything else stays retryable. */\nconst TERMINAL_ERROR_CODES: Readonly<Record<string, string>> = Object.freeze({\n  context_length_exceeded: CONTEXT_WINDOW_EXCEEDED_CODE,\n  insufficient_quota: QUOTA_EXCEEDED_CODE,\n  invalid_prompt: MODEL_ERROR_CODES.INVALID_REQUEST,\n  bio_policy: MODEL_ERROR_CODES.INVALID_REQUEST,\n  cyber_policy: MODEL_ERROR_CODES.INVALID_REQUEST,\n  misalignment_policy_violation: MODEL_ERROR_CODES.INVALID_REQUEST,\n  rate_limit_exceeded: MODEL_ERROR_CODES.RATE_LIMIT,\n})\n\n/** Turn a `response.failed` payload into a typed, correctly classified error. */\nfunction failedError(response: WireResponse | undefined, displayName: string): ModelError {\n  const error = response?.error ?? undefined\n  const code = error?.code ?? error?.type\n  const message = error?.message ?? `${displayName} reported a failed response`\n  const mapped = code === undefined ? undefined : TERMINAL_ERROR_CODES[code]\n  return new ModelError(\n    message,\n    // An unrecognized failure defaults to SERVER, which IS in the retryable set:\n    // the request produced nothing, so repeating it is safe and often works.\n    mapped ?? MODEL_ERROR_CODES.SERVER,\n    {},\n  )\n}\n\n/** Build the authoritative block for a completed item. */\nfunction doneBlock(\n  item: WireOutputItem,\n  open: OpenItem,\n  imageMediaType: ImageMediaType,\n): ContentBlock | undefined {\n  switch (open.kind) {\n    case 'text': {\n      const text = itemText(item)\n      const phase = textPhase(item.phase) ?? open.phase\n      return {\n        type: 'text',\n        text: text.length > 0 ? text : open.text,\n        ...phase === undefined ? {} : { phase },\n        ...textAnnotations(item).length === 0 ? {} : { annotations: textAnnotations(item) },\n      }\n    }\n    case 'reasoning': {\n      const summary = itemSummary(item)\n      const state: ResponsesReasoningState = {\n        ...typeof item.id === 'string' ? { id: item.id } : {},\n        ...typeof item.encrypted_content === 'string'\n          ? { encryptedContent: item.encrypted_content }\n          : {},\n        ...summary.length > 0 ? { summary } : {},\n      }\n      return {\n        type: 'reasoning',\n        text: summary.length > 0 ? summary.join('\\n\\n') : open.text,\n        providerState: state,\n      }\n    }\n    case 'tool-call': {\n      const args = typeof item.arguments === 'string' && item.arguments.length > 0\n        ? item.arguments\n        : open.args\n      return {\n        type: 'tool-call',\n        id: ToolCallId(item.call_id ?? open.callId),\n        name: item.name ?? open.name,\n        arguments: args.length > 0 ? args : '{}',\n      }\n    }\n    case 'native-tool-call': {\n      const content: ContentBlock[] = open.nativeName === 'image-generation'\n        && typeof item.result === 'string' && item.result.length > 0\n        ? [{\n          type: 'image',\n          source: { kind: 'base64', mediaType: imageMediaType, data: item.result },\n        }]\n        : []\n      return {\n        type: 'native-tool-call',\n        id: item.id ?? open.callId,\n        name: open.nativeName,\n        ...typeof item.status === 'string' ? { status: item.status } : {},\n        ...isJsonValue(item.action) ? { arguments: item.action } : {},\n        content,\n        providerState: item,\n      }\n    }\n    default:\n      return undefined\n  }\n}\n\n/**\n * Translate one Responses SSE stream.\n *\n * Owns termination. This API sends no `[DONE]` sentinel: the stream ends on\n * `response.completed`, `response.failed`, or `response.incomplete`, and a body\n * that ends without one of those was truncated — which is a failure, not an\n * empty success, because a truncated turn cannot be trusted.\n * @param events - decoded SSE events.\n * @param displayName - provider name, used in diagnostics.\n * @returns the chunk stream.\n */\nexport async function* translateResponsesStream(\n  events: AsyncIterable<ProtocolSseEvent>,\n  displayName: string,\n  request?: ProtocolRequest,\n): AsyncGenerator<ProtocolStreamChunk> {\n  const open = new Map<string, OpenItem>()\n  let nextIndex = 0\n  let sawToolCall = false\n  let terminated = false\n  const imageMediaType = requestedImageMediaType(request)\n\n  for await (const raw of events) {\n    let event: WireStreamEvent\n    try {\n      event = JSON.parse(raw.data) as WireStreamEvent\n    } catch (error: unknown) {\n      throw new ModelError(\n        `${displayName} sent a malformed stream event`,\n        MODEL_ERROR_CODES.MALFORMED_RESPONSE,\n        { cause: error },\n      )\n    }\n\n    switch (event.type) {\n      case 'response.output_item.added': {\n        const item = event.item\n        const id = item?.id ?? event.item_id\n        const kind = itemKind(item?.type)\n        if (item === undefined || id === undefined || kind === undefined) break\n        if (open.has(id)) break\n        const entry: OpenItem = {\n          index: nextIndex++,\n          kind,\n          text: '',\n          args: '',\n          callId: item.call_id ?? id,\n          name: item.name ?? '',\n          nativeName: nativeName(item.type),\n          summaryIndex: undefined,\n          phase: textPhase(item.phase),\n        }\n        open.set(id, entry)\n        if (kind === 'tool-call') sawToolCall = true\n        yield { type: 'block-start', index: entry.index, blockType: kindToBlockType(kind) }\n        break\n      }\n\n      case 'response.output_text.delta': {\n        const entry = event.item_id === undefined ? undefined : open.get(event.item_id)\n        if (entry === undefined || event.delta === undefined) break\n        entry.text += event.delta\n        yield {\n          type: 'text-delta', index: entry.index, text: event.delta,\n          ...entry.phase === undefined ? {} : { phase: entry.phase },\n        }\n        break\n      }\n\n      case 'response.reasoning_summary_text.delta': {\n        const entry = event.item_id === undefined ? undefined : open.get(event.item_id)\n        if (entry === undefined || event.delta === undefined) break\n        // A new summary paragraph starts; separate it from the previous one so the\n        // assembled text does not run two thoughts together.\n        const separator = entry.summaryIndex !== undefined\n          && event.summary_index !== undefined\n          && event.summary_index !== entry.summaryIndex\n          ? '\\n\\n'\n          : ''\n        entry.summaryIndex = event.summary_index\n        const text = `${separator}${event.delta}`\n        entry.text += text\n        yield { type: 'reasoning-delta', index: entry.index, text }\n        break\n      }\n\n      case 'response.reasoning_text.delta': {\n        const entry = event.item_id === undefined ? undefined : open.get(event.item_id)\n        if (entry === undefined || event.delta === undefined) break\n        entry.text += event.delta\n        yield { type: 'reasoning-delta', index: entry.index, text: event.delta }\n        break\n      }\n\n      case 'response.function_call_arguments.delta': {\n        const entry = event.item_id === undefined ? undefined : open.get(event.item_id)\n        if (entry === undefined || event.delta === undefined) break\n        entry.args += event.delta\n        yield {\n          type: 'tool-call-delta',\n          index: entry.index,\n          id: ToolCallId(entry.callId),\n          ...entry.name.length > 0 ? { name: entry.name } : {},\n          argumentsDelta: event.delta,\n        }\n        break\n      }\n\n      case 'response.image_generation_call.partial_image': {\n        const itemId = event.item_id\n        const entry = itemId === undefined ? undefined : open.get(itemId)\n        if (itemId === undefined || entry === undefined || event.partial_image_b64 === undefined) break\n        yield {\n          type: 'image-delta',\n          index: entry.index,\n          itemId,\n          data: event.partial_image_b64,\n          mediaType: imageMediaType,\n          ...event.partial_image_index === undefined\n            ? {}\n            : { partialIndex: event.partial_image_index },\n        }\n        break\n      }\n\n      case 'response.output_item.done': {\n        const item = event.item\n        const id = item?.id ?? event.item_id\n        const entry = id === undefined ? undefined : open.get(id)\n        if (item === undefined || entry === undefined) break\n        const block = doneBlock(item, entry, imageMediaType)\n        if (block !== undefined) yield { type: 'block-end', index: entry.index, block }\n        break\n      }\n\n      case 'response.completed': {\n        const usage = event.response?.usage ?? undefined\n        const mapped = usage === undefined ? undefined : mapUsage(usage)\n        if (mapped !== undefined) yield { type: 'usage', usage: mapped }\n        // This API has no explicit stop reason. Tool calls in the output ARE the\n        // signal that the turn expects results back, which is what an agent loop\n        // branches on.\n        const reason: FinishReason = sawToolCall ? { kind: 'tool-calls' } : { kind: 'stop' }\n        yield { type: 'finish', reason }\n        terminated = true\n        return\n      }\n\n      case 'response.incomplete': {\n        const usage = event.response?.usage ?? undefined\n        const mapped = usage === undefined ? undefined : mapUsage(usage)\n        if (mapped !== undefined) yield { type: 'usage', usage: mapped }\n        const why = event.response?.incomplete_details?.reason\n        if (why === 'max_output_tokens') {\n          yield { type: 'finish', reason: { kind: 'max-tokens' } }\n          terminated = true\n          return\n        }\n        throw new ModelError(\n          `${displayName} returned an incomplete response (${why ?? 'unknown reason'})`,\n          MODEL_ERROR_CODES.SERVER,\n        )\n      }\n\n      case 'response.failed':\n        throw failedError(event.response, displayName)\n\n      case 'error': {\n        // A top-level error event carries its fields inline rather than under a\n        // `response` object, so it is reshaped to reuse the same classifier.\n        const inline: WireErrorBody = {\n          ...event.code === undefined ? {} : { code: event.code },\n          ...event.message === undefined ? {} : { message: event.message },\n        }\n        throw failedError({ error: inline }, displayName)\n      }\n\n      default:\n        // Every other lifecycle and progress event (`response.created`,\n        // `content_part.*`, `*.done` text echoes, `ping`) carries nothing this\n        // protocol needs. Falling through is correct and keeps new event types\n        // from breaking the stream.\n        break\n    }\n  }\n\n  if (!terminated) {\n    throw new ModelError(\n      `${displayName} stream ended before the response completed`,\n      MODEL_ERROR_CODES.STREAM_CLOSED,\n    )\n  }\n}\n\n/** Our block-type tag for one item kind. */\nfunction kindToBlockType(kind: ItemKind): 'text' | 'reasoning' | 'tool-call' | 'native-tool-call' {\n  return kind\n}\n\nfunction requestedImageMediaType(request: ProtocolRequest | undefined): ImageMediaType {\n  const tool = request?.options.tools?.find(candidate => 'type' in candidate\n    && candidate.type === 'native'\n    && candidate.name === 'image-generation')\n  if (tool === undefined || !('format' in tool)) return 'image/png'\n  if (tool.format === 'jpeg') return 'image/jpeg'\n  if (tool.format === 'webp') return 'image/webp'\n  return 'image/png'\n}\n","/**\n * The OpenAI Responses protocol, as a reusable {@link WireProtocol}.\n *\n * Spoken by `api.openai.com`, by the ChatGPT-backed Codex endpoint, and by a\n * growing number of compatible gateways. None of them needs its own translation\n * code — they differ only in the dialect knobs below.\n *\n * @module ai-agent-sdk/providers/protocols/openai-responses\n */\n\nimport type {\n  ProtocolDefinition,\n  ProtocolRequest,\n  ProtocolSseEvent,\n  ProtocolStreamChunk,\n} from './contract.ts'\nimport type { ModelTarget, ResolvedModelInfo } from '@alvin0/ai-agent-sdk-core/provider'\nimport { serializeResponsesRequest } from './serialize.ts'\nimport { translateResponsesStream } from './translate.ts'\nimport type { ResponsesDialect } from './wire.ts'\n\n/** Protocol id, usable as a stable string in configuration. */\nexport const OPENAI_RESPONSES_PROTOCOL_ID = 'openai-responses'\n\n/**\n * Conservative defaults.\n *\n * `store: false` because retaining prompts server-side should be an explicit\n * decision, not something an SDK turns on for you. `include` carries\n * `reasoning.encrypted_content` because without it a reasoning model loses its\n * chain of thought between a tool call and the tool's result.\n */\nconst DEFAULT_DIALECT: ResponsesDialect = Object.freeze({\n  sampling: true,\n  maxOutputTokens: true,\n  structuredOutputs: true,\n  store: false,\n  include: Object.freeze(['reasoning.encrypted_content']),\n  reasoningSummary: 'auto',\n})\n\ninterface RuntimeProtocolRequest extends ProtocolRequest {\n  readonly model: ResolvedModelInfo\n  readonly connection: {\n    readonly baseUrl: string\n    readonly headers: Readonly<Record<string, string>>\n  }\n}\n\n/** Marker-based runtime view, kept structurally independent from provider-http. */\nexport interface ResponsesProtocolDefinition {\n  readonly kind: 'http-wire-protocol'\n  readonly apiVersion: 1\n  readonly id: string\n  readonly defaultDialect: ResponsesDialect\n  readonly exampleModel?: ModelTarget\n  readonly endpointPath: (request: RuntimeProtocolRequest, dialect: ResponsesDialect) => string\n  readonly protocolHeaders?: (dialect: ResponsesDialect) => Readonly<Record<string, string>>\n  readonly serialize: (\n    request: RuntimeProtocolRequest,\n    dialect: ResponsesDialect,\n  ) => Readonly<Record<string, unknown>>\n  readonly translate: (\n    events: AsyncIterable<ProtocolSseEvent>,\n    request: RuntimeProtocolRequest,\n    displayName: string,\n  ) => AsyncGenerator<ProtocolStreamChunk>\n}\n\n/** The OpenAI Responses wire protocol. */\nexport const openAiResponsesProtocol: ProtocolDefinition<ResponsesDialect>\n  & ResponsesProtocolDefinition = Object.freeze({\n  kind: 'http-wire-protocol' as const,\n  apiVersion: 1 as const,\n  id: OPENAI_RESPONSES_PROTOCOL_ID,\n  defaultDialect: DEFAULT_DIALECT,\n  endpointPath: () => '/responses',\n  serialize(request: ProtocolRequest, dialect: ResponsesDialect): Readonly<Record<string, unknown>> {\n    return serializeResponsesRequest(request, dialect) as unknown as Readonly<Record<string, unknown>>\n  },\n  // Params are annotated because `Object.freeze` erases the contextual typing the\n  // `WireProtocol` annotation would otherwise supply.\n  translate: (\n    events: AsyncIterable<ProtocolSseEvent>,\n    request: ProtocolRequest,\n    displayName: string,\n  ): AsyncGenerator<ProtocolStreamChunk> => translateResponsesStream(events, displayName, request),\n})\n\nexport type { ResponsesDialect }\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@alvin0/ai-agent-sdk-protocol-responses",
+  "author": {
+    "name": "alvin0 - chaulamdinhai",
+    "email": "chaulamdinhai@gmail.com"
+  },
+  "version": "0.1.0",
+  "description": "Universal OpenAI Responses and Codex wire schema, serializer, translator, and dialect for ai-agent-sdk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alvin0/ai-agent-sdk.git",
+    "directory": "packages/protocol-responses"
+  },
+  "homepage": "https://github.com/alvin0/ai-agent-sdk/tree/main/packages/protocol-responses#readme",
+  "bugs": {
+    "url": "https://github.com/alvin0/ai-agent-sdk/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "@alvin0/ai-agent-sdk-core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@alvin0/ai-agent-sdk-core": "^0.1.0",
+    "@arethetypeswrong/cli": "0.18.5",
+    "playwright": "1.62.1",
+    "publint": "0.3.24",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
+    "vitest": "4.1.11",
+    "wrangler": "4.127.1"
+  },
+  "aiAgentSdk": {
+    "runtime": "universal",
+    "coreApi": 1,
+    "roles": [
+      "wire-protocol"
+    ]
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true});require('node:fs').rmSync('artifacts',{recursive:true,force:true})\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --config vitest.config.ts",
+    "pack": "pnpm pack --pack-destination artifacts",
+    "test:pack": "node ../../scripts/test-packed-protocol.mts protocol-responses",
+    "check:publint": "publint",
+    "check:types": "attw --profile esm-only --pack ."
+  }
+}