@rulvar/openai 1.5.2 → 1.6.0

package/README.md

@@ -6,7 +6,7 @@ points the same adapter at any OpenAI-compatible endpoint (Ollama, vLLM,
 gateways) with an explicit id and baseURL. Models are addressed as
 `'openai:<model>'` in routing.
 
-Part of [rulvar](https://rulvar.com), an embeddable TypeScript engine
+Part of [Rulvar](https://rulvar.com), an embeddable TypeScript engine
 for durable, budget-bounded multi-agent LLM workflows, where a completed
 LLM call is never paid for twice. Full documentation:
 [docs.rulvar.com](https://docs.rulvar.com).

package/dist/index.d.ts

@@ -9,7 +9,15 @@ interface OpenAiModelInfo {
 }
 /** Static seed table of the current model set. */
 declare const OPENAI_MODELS: Record<string, OpenAiModelInfo>;
-/** Unknown OpenAI models are assumed current-generation Responses models. */
+/**
+* Unknown OpenAI models are assumed current-generation Responses models
+* with conservative transport caps and NO pricing: a fabricated price row
+* silently misprices every model newer than this table (it priced
+* gpt-5.6-sol as gpt-5.4 before the 5.6 entries landed). Hosts price an
+* unrecognized hosted model via a versioned createEngine({ pricing }) row;
+* until then its usage surfaces in CostReport.unpriced and a run ceiling
+* warns that it cannot bound the model.
+*/
 declare function openAiModelInfo(model: string): OpenAiModelInfo;
 //#endregion
 //#region src/adapter.d.ts
@@ -98,15 +106,17 @@ type ResponsesStreamEvent = Record<string, unknown> & {
 /** Normalizes Responses usage: input_tokens already includes cached reads. */
 declare function normalizeOpenAiUsage(raw: Record<string, unknown> | undefined): Usage;
 /**
-* Maps the typed Responses SSE stream to ChatEvents.
-* Canonical parts come from the typed output array,
-* never the output_text aggregate. Raw output items ride
+* Maps the typed Responses SSE stream to ChatEvents, yielding each
+* canonical event AS the corresponding provider event is consumed: the
+* consumer's pull drives the provider read (natural backpressure, no
+* buffering, no detached work). Canonical parts come from the typed
+* output array, never the output_text aggregate. Raw output items ride
 * finish.providerMetadata.openai.outputItems so the runtime can retain
 * reasoning items as provider-raw parts.
 */
-declare function mapResponsesStream(stream: AsyncIterable<ResponsesStreamEvent>, ids: OpenAiIdMap, emit: (event: ChatEvent) => void, options?: {
+declare function mapResponsesStream(stream: AsyncIterable<ResponsesStreamEvent>, ids: OpenAiIdMap, options?: {
   effortDownmapped?: boolean;
-}): Promise<void>;
+}): AsyncGenerator<ChatEvent, void>;
 /** Projects SDK/API errors into the retryable WireError vocabulary. */
 declare function openAiErrorToWire(error: unknown): WireError;
 /**
@@ -117,7 +127,11 @@ declare function openAiErrorToWire(error: unknown): WireError;
 * events, never silent.
 */
 declare function buildChatCompletionsParams(req: ChatRequest, ids: OpenAiIdMap): Record<string, unknown>;
-/** Delta-patched chunk assembly for the degraded path. */
-declare function mapChatCompletionsStream(stream: AsyncIterable<Record<string, unknown>>, ids: OpenAiIdMap, emit: (event: ChatEvent) => void): Promise<void>;
+/**
+* Delta-patched chunk assembly for the degraded path; yields each
+* canonical event as its chunk is consumed (same live-streaming contract
+* as mapResponsesStream).
+*/
+declare function mapChatCompletionsStream(stream: AsyncIterable<Record<string, unknown>>, ids: OpenAiIdMap): AsyncGenerator<ChatEvent, void>;
 //#endregion
 export { CONSERVATIVE_COMPATIBLE_CAPS, OPENAI_MODELS, type OpenAiAdapterOptions, type OpenAiClientLike, type OpenAiCompatibleConfig, OpenAiIdMap, type OpenAiModelInfo, type ResponsesStreamEvent, buildChatCompletionsParams, buildResponsesParams, mapChatCompletionsStream, mapOpenAiEffort, mapResponsesStream, normalizeOpenAiUsage, openAiErrorToWire, openAiModelInfo, openai, openaiCompatible };

package/dist/index.js

@@ -16,49 +16,72 @@ function responses(contextWindow, maxOutputTokens, pricing) {
 			reasoningEfforts: [...REASONING_EFFORTS, "max"],
 			contextWindow,
 			maxOutputTokens,
-			pricing: {
-				inputUsdPerMTok: pricing.in,
-				outputUsdPerMTok: pricing.out,
-				cacheReadUsdPerMTok: pricing.cacheRead
-			}
+			...pricing === void 0 ? {} : { pricing }
 		},
 		api: "responses",
 		reasoning: true
 	};
 }
+/**
+* GPT-5.6 Sol (developers.openai.com/api/docs/models/gpt-5.6-sol):
+* prompts strictly above 272K input tokens price the FULL request at
+* 2x input and 1.5x output; cache writes bill at 1.25x uncached input.
+*/
+const GPT_56_SOL = responses(105e4, 128e3, {
+	inputUsdPerMTok: 5,
+	outputUsdPerMTok: 30,
+	cacheReadUsdPerMTok: .5,
+	cacheWriteUsdPerMTok: 6.25,
+	tiers: [{
+		aboveInputTokens: 272e3,
+		inputMultiplier: 2,
+		outputMultiplier: 1.5
+	}]
+});
 /** Static seed table of the current model set. */
 const OPENAI_MODELS = {
+	"gpt-5.6-sol": GPT_56_SOL,
+	"gpt-5.6": GPT_56_SOL,
 	"gpt-5.5": responses(4e5, 128e3, {
-		in: 10,
-		out: 40,
-		cacheRead: 1
+		inputUsdPerMTok: 10,
+		outputUsdPerMTok: 40,
+		cacheReadUsdPerMTok: 1
 	}),
 	"gpt-5.5-pro": responses(4e5, 128e3, {
-		in: 40,
-		out: 160,
-		cacheRead: 4
+		inputUsdPerMTok: 40,
+		outputUsdPerMTok: 160,
+		cacheReadUsdPerMTok: 4
 	}),
 	"gpt-5.4": responses(272e3, 1e5, {
-		in: 6,
-		out: 24,
-		cacheRead: .6
+		inputUsdPerMTok: 6,
+		outputUsdPerMTok: 24,
+		cacheReadUsdPerMTok: .6
 	}),
 	"gpt-5.4-mini": responses(272e3, 1e5, {
-		in: 1.2,
-		out: 4.8,
-		cacheRead: .12
+		inputUsdPerMTok: 1.2,
+		outputUsdPerMTok: 4.8,
+		cacheReadUsdPerMTok: .12
 	})
 };
-/** Unknown OpenAI models are assumed current-generation Responses models. */
+/**
+* Unknown OpenAI models are assumed current-generation Responses models
+* with conservative transport caps and NO pricing: a fabricated price row
+* silently misprices every model newer than this table (it priced
+* gpt-5.6-sol as gpt-5.4 before the 5.6 entries landed). Hosts price an
+* unrecognized hosted model via a versioned createEngine({ pricing }) row;
+* until then its usage surfaces in CostReport.unpriced and a run ceiling
+* warns that it cannot bound the model.
+*/
 function openAiModelInfo(model) {
 	const exact = OPENAI_MODELS[model];
 	if (exact !== void 0) return exact;
-	for (const [name, info] of Object.entries(OPENAI_MODELS)) if (model.startsWith(`${name}-`)) return info;
-	return responses(272e3, 1e5, {
-		in: 6,
-		out: 24,
-		cacheRead: .6
-	});
+	let best;
+	for (const [name, info] of Object.entries(OPENAI_MODELS)) if (model.startsWith(`${name}-`) && (best === void 0 || name.length > best.name.length)) best = {
+		name,
+		info
+	};
+	if (best !== void 0) return best.info;
+	return responses(272e3, 1e5);
 }
 //#endregion
 //#region src/wire.ts
@@ -244,13 +267,15 @@ function normalizeOpenAiUsage(raw) {
 	return usage;
 }
 /**
-* Maps the typed Responses SSE stream to ChatEvents.
-* Canonical parts come from the typed output array,
-* never the output_text aggregate. Raw output items ride
+* Maps the typed Responses SSE stream to ChatEvents, yielding each
+* canonical event AS the corresponding provider event is consumed: the
+* consumer's pull drives the provider read (natural backpressure, no
+* buffering, no detached work). Canonical parts come from the typed
+* output array, never the output_text aggregate. Raw output items ride
 * finish.providerMetadata.openai.outputItems so the runtime can retain
 * reasoning items as provider-raw parts.
 */
-async function mapResponsesStream(stream, ids, emit, options) {
+async function* mapResponsesStream(stream, ids, options) {
 	const callIdByItemId = /* @__PURE__ */ new Map();
 	for await (const event of stream) switch (event.type) {
 		case "response.output_item.added": {
@@ -258,22 +283,22 @@ async function mapResponsesStream(stream, ids, emit, options) {
 			if (item?.type === "function_call") {
 				const callId = item.call_id ?? item.id;
 				if (typeof item.id === "string") callIdByItemId.set(item.id, callId);
-				emit({
+				yield {
 					type: "tool-call-start",
 					id: ids.canonicalFor(callId),
 					name: item.name ?? ""
-				});
+				};
 			}
 			break;
 		}
 		case "response.function_call_arguments.delta": {
 			const itemId = event.item_id;
 			const callId = itemId === void 0 ? void 0 : callIdByItemId.get(itemId);
-			if (callId !== void 0) emit({
+			if (callId !== void 0) yield {
 				type: "tool-call-delta",
 				id: ids.canonicalFor(callId),
 				argsTextDelta: event.delta ?? ""
-			});
+			};
 			break;
 		}
 		case "response.output_item.done": {
@@ -286,35 +311,35 @@ async function mapResponsesStream(stream, ids, emit, options) {
 				} catch {
 					args = { __unparsed: item.arguments };
 				}
-				emit({
+				yield {
 					type: "tool-call-end",
 					id: ids.canonicalFor(callId),
 					args
-				});
+				};
 			}
 			break;
 		}
 		case "response.output_text.delta":
-			emit({
+			yield {
 				type: "text-delta",
 				text: event.delta ?? ""
-			});
+			};
 			break;
 		case "response.reasoning_summary_text.delta":
 		case "response.reasoning_text.delta":
-			emit({
+			yield {
 				type: "reasoning-delta",
 				text: event.delta ?? ""
-			});
+			};
 			break;
 		case "response.completed":
 		case "response.incomplete": {
 			const response = event.response;
 			const usage = normalizeOpenAiUsage(response?.usage);
-			emit({
+			yield {
 				type: "usage",
 				usage
-			});
+			};
 			let finish = { reason: "stop" };
 			if (event.type === "response.incomplete") {
 				const details = response?.incomplete_details;
@@ -336,29 +361,27 @@ async function mapResponsesStream(stream, ids, emit, options) {
 			if (reasoningItems.length > 0) meta.retainedParts = reasoningItems;
 			if (typeof response?.id === "string") meta.responseId = response.id;
 			if (options?.effortDownmapped === true) meta.effortDownmapped = "max->xhigh";
-			emit({
+			yield {
 				type: "finish",
 				finish,
 				usage,
 				providerMetadata: { openai: meta }
-			});
+			};
 			return;
 		}
-		case "response.failed": {
-			const error = event.response?.error;
-			emit({
+		case "response.failed":
+			yield {
 				type: "error",
 				error: {
 					code: "agent",
-					message: error?.message ?? "response.failed",
+					message: (event.response?.error)?.message ?? "response.failed",
 					retryable: false,
 					data: { kind: "transport" }
 				}
-			});
+			};
 			return;
-		}
 		case "error":
-			emit({
+			yield {
 				type: "error",
 				error: {
 					code: "agent",
@@ -366,7 +389,7 @@ async function mapResponsesStream(stream, ids, emit, options) {
 					retryable: false,
 					data: { kind: "transport" }
 				}
-			});
+			};
 			return;
 		default: break;
 	}
@@ -484,8 +507,12 @@ function buildChatCompletionsParams(req, ids) {
 	};
 	return params;
 }
-/** Delta-patched chunk assembly for the degraded path. */
-async function mapChatCompletionsStream(stream, ids, emit) {
+/**
+* Delta-patched chunk assembly for the degraded path; yields each
+* canonical event as its chunk is consumed (same live-streaming contract
+* as mapResponsesStream).
+*/
+async function* mapChatCompletionsStream(stream, ids) {
 	const pendingCalls = /* @__PURE__ */ new Map();
 	let finishReason;
 	let usage = {
@@ -497,10 +524,10 @@ async function mapChatCompletionsStream(stream, ids, emit) {
 	for await (const chunk of stream) {
 		const choice = chunk.choices?.[0];
 		const delta = choice?.delta;
-		if (typeof delta?.content === "string" && delta.content !== "") emit({
+		if (typeof delta?.content === "string" && delta.content !== "") yield {
 			type: "text-delta",
 			text: delta.content
-		});
+		};
 		const toolCalls = delta?.tool_calls;
 		if (toolCalls !== void 0) for (const call of toolCalls) {
 			const index = call.index ?? 0;
@@ -513,20 +540,20 @@ async function mapChatCompletionsStream(stream, ids, emit) {
 					args: ""
 				};
 				pendingCalls.set(index, pending);
-				emit({
+				yield {
 					type: "tool-call-start",
 					id: ids.canonicalFor(pending.id),
 					name: fn?.name ?? ""
-				});
+				};
 			}
 			if (typeof fn?.name === "string") pending.name += fn.name;
 			if (typeof fn?.arguments === "string" && fn.arguments !== "") {
 				pending.args += fn.arguments;
-				emit({
+				yield {
 					type: "tool-call-delta",
 					id: ids.canonicalFor(pending.id),
 					argsTextDelta: fn.arguments
-				});
+				};
 			}
 		}
 		if (typeof choice?.finish_reason === "string") finishReason = choice.finish_reason;
@@ -548,17 +575,17 @@ async function mapChatCompletionsStream(stream, ids, emit) {
 		} catch {
 			args = { __unparsed: pending.args };
 		}
-		emit({
+		yield {
 			type: "tool-call-end",
 			id: ids.canonicalFor(pending.id),
 			args
-		});
+		};
 	}
-	emit({
+	yield {
 		type: "usage",
 		usage
-	});
-	emit({
+	};
+	yield {
 		type: "finish",
 		finish: finishReason === "length" ? { reason: "max-tokens" } : finishReason === "tool_calls" ? { reason: "tool-calls" } : finishReason === "content_filter" ? {
 			reason: "refusal",
@@ -566,7 +593,7 @@ async function mapChatCompletionsStream(stream, ids, emit) {
 		} : { reason: "stop" },
 		usage,
 		providerMetadata: { openai: { degradedPath: "chat" } }
-	});
+	};
 }
 //#endregion
 //#region src/adapter.ts
@@ -594,32 +621,27 @@ function openai(options = {}) {
 		},
 		async *stream(req, signal) {
 			const info = openAiModelInfo(req.model);
-			const pending = [];
-			const emit = (event) => {
-				pending.push(event);
-			};
 			try {
 				if (info.api === "responses") {
 					const { params, effortDownmapped } = buildResponsesParams(req, ids);
-					await mapResponsesStream(await client.responses.create({
+					yield* mapResponsesStream(await client.responses.create({
 						...params,
 						stream: true
-					}, signal === void 0 ? void 0 : { signal }), ids, emit, { effortDownmapped });
+					}, signal === void 0 ? void 0 : { signal }), ids, { effortDownmapped });
 				} else {
 					const params = buildChatCompletionsParams(req, ids);
-					await mapChatCompletionsStream(await client.chat.completions.create({
+					yield* mapChatCompletionsStream(await client.chat.completions.create({
 						...params,
 						stream: true,
 						stream_options: { include_usage: true }
-					}, signal === void 0 ? void 0 : { signal }), ids, emit);
+					}, signal === void 0 ? void 0 : { signal }), ids);
 				}
 			} catch (thrown) {
-				if (signal?.aborted !== true) pending.push({
+				if (signal?.aborted !== true) yield {
 					type: "error",
 					error: openAiErrorToWire(thrown)
-				});
+				};
 			}
-			for (const event of pending) yield event;
 		}
 	};
 }
@@ -672,24 +694,19 @@ function openaiCompatible(cfg) {
 			};
 		},
 		async *stream(req, signal) {
-			const pending = [];
-			const emit = (event) => {
-				pending.push(event);
-			};
 			try {
 				const params = buildChatCompletionsParams(req, ids);
-				await mapChatCompletionsStream(await client.chat.completions.create({
+				yield* mapChatCompletionsStream(await client.chat.completions.create({
 					...params,
 					stream: true,
 					stream_options: { include_usage: true }
-				}, signal === void 0 ? void 0 : { signal }), ids, emit);
+				}, signal === void 0 ? void 0 : { signal }), ids);
 			} catch (thrown) {
-				if (signal?.aborted !== true) pending.push({
+				if (signal?.aborted !== true) yield {
 					type: "error",
 					error: openAiErrorToWire(thrown)
-				});
+				};
 			}
-			for (const event of pending) yield event;
 		}
 	};
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rulvar/openai",
-  "version": "1.5.2",
-  "description": "rulvar first-class provider adapter for the OpenAI Responses API, plus the openaiCompatible factory.",
+  "version": "1.6.0",
+  "description": "Rulvar first-class provider adapter for the OpenAI Responses API, plus the openaiCompatible factory.",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "openai": "^6.45.0",
-    "@rulvar/core": "1.5.2"
+    "@rulvar/core": "1.6.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",