@effect-uai/responses 0.1.0

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/models.ts","../src/streamEvents.ts","../src/Responses.ts","../src/codec.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,525 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Context, Effect, Layer, Match, Option, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { matchType } from "@effect-uai/core/Match";
+import { LanguageModel } from "@effect-uai/core/LanguageModel";
+import * as SSE from "@effect-uai/core/SSE";
+//#region src/codec.ts
+var codec_exports = /* @__PURE__ */ __exportAll({
+	WireOutputItem: () => WireOutputItem,
+	WireResponseCompleted: () => WireResponseCompleted,
+	itemsToInput: () => itemsToInput,
+	turnFromCompleted: () => turnFromCompleted,
+	wireItemToItem: () => wireItemToItem
+});
+const WireUrlCitation = Schema.Struct({
+	type: Schema.Literal("url_citation"),
+	url: Schema.String,
+	start_index: Schema.Number,
+	end_index: Schema.Number,
+	title: Schema.String
+});
+const WireFileCitation = Schema.Struct({
+	type: Schema.Literal("file_citation"),
+	file_id: Schema.String,
+	index: Schema.Number
+});
+const WireContainerFileCitation = Schema.Struct({
+	type: Schema.Literal("container_file_citation"),
+	container_id: Schema.String,
+	file_id: Schema.String,
+	start_index: Schema.Number,
+	end_index: Schema.Number
+});
+const WireFilePath = Schema.Struct({
+	type: Schema.Literal("file_path"),
+	file_id: Schema.String,
+	index: Schema.Number
+});
+const WireAnnotation = Schema.Union([
+	WireUrlCitation,
+	WireFileCitation,
+	WireContainerFileCitation,
+	WireFilePath
+]);
+const WireOutputTextContent = Schema.Struct({
+	type: Schema.Literal("output_text"),
+	text: Schema.String,
+	annotations: Schema.optional(Schema.NullOr(Schema.Array(WireAnnotation)))
+});
+const WireRefusalContent = Schema.Struct({
+	type: Schema.Literal("refusal"),
+	refusal: Schema.String
+});
+const WireMessageContent = Schema.Union([WireOutputTextContent, WireRefusalContent]);
+const WireSummaryText = Schema.Struct({
+	type: Schema.Literal("summary_text"),
+	text: Schema.String
+});
+const WireMessage = Schema.Struct({
+	type: Schema.Literal("message"),
+	id: Schema.optional(Schema.String),
+	role: Schema.Literal("assistant"),
+	content: Schema.Array(WireMessageContent)
+});
+const WireFunctionCall = Schema.Struct({
+	type: Schema.Literal("function_call"),
+	id: Schema.optional(Schema.String),
+	call_id: Schema.String,
+	name: Schema.String,
+	arguments: Schema.String
+});
+const WireReasoning = Schema.Struct({
+	type: Schema.Literal("reasoning"),
+	id: Schema.optional(Schema.String),
+	summary: Schema.optional(Schema.Array(WireSummaryText)),
+	encrypted_content: Schema.optional(Schema.String)
+});
+const WireOutputItem = Schema.Union([
+	WireMessage,
+	WireFunctionCall,
+	WireReasoning
+]);
+const WireInputTokensDetails = Schema.Struct({ cached_tokens: Schema.optional(Schema.NullOr(Schema.Number)) });
+const WireOutputTokensDetails = Schema.Struct({ reasoning_tokens: Schema.optional(Schema.NullOr(Schema.Number)) });
+const WireUsage = Schema.Struct({
+	input_tokens: Schema.optional(Schema.Number),
+	output_tokens: Schema.optional(Schema.Number),
+	total_tokens: Schema.optional(Schema.Number),
+	input_tokens_details: Schema.optional(Schema.NullOr(WireInputTokensDetails)),
+	output_tokens_details: Schema.optional(Schema.NullOr(WireOutputTokensDetails))
+});
+const WireResponseError = Schema.Struct({
+	code: Schema.optional(Schema.NullOr(Schema.String)),
+	message: Schema.optional(Schema.NullOr(Schema.String))
+});
+const WireResponseCompleted = Schema.Struct({
+	id: Schema.optional(Schema.NullOr(Schema.String)),
+	status: Schema.optional(Schema.NullOr(Schema.String)),
+	output: Schema.optional(Schema.NullOr(Schema.Array(WireOutputItem))),
+	usage: Schema.optional(Schema.NullOr(WireUsage)),
+	incomplete_details: Schema.optional(Schema.NullOr(Schema.Struct({ reason: Schema.optional(Schema.NullOr(Schema.String)) }))),
+	error: Schema.optional(Schema.NullOr(WireResponseError))
+});
+/**
+* If an item carries `providerData` from a prior OpenAI turn, re-emit it
+* verbatim - preserves `encrypted_content`, item ids, and any field this
+* codec doesn't model.
+*/
+const passthrough = (item) => item.providerData !== void 0 && typeof item.providerData === "object" && item.providerData !== null ? item.providerData : void 0;
+const contentBlockToInput = Match.type().pipe(matchType("input_text", (b) => ({
+	type: "input_text",
+	text: b.text
+})), matchType("input_image", (b) => ({
+	type: "input_image",
+	image_url: b.source._tag === "url" ? b.source.url : `data:${b.source.media_type};base64,${b.source.data}`
+})), matchType("output_text", (b) => ({
+	type: "output_text",
+	text: b.text
+})), matchType("refusal", (b) => ({
+	type: "refusal",
+	refusal: b.text
+})), Match.exhaustive);
+const itemToInput = (item) => passthrough(item) ?? Match.value(item).pipe(matchType("message", (m) => ({
+	type: "message",
+	role: m.role,
+	content: m.content.map(contentBlockToInput)
+})), matchType("function_call", (f) => ({
+	type: "function_call",
+	call_id: f.call_id,
+	name: f.name,
+	arguments: f.arguments
+})), matchType("function_call_output", (o) => ({
+	type: "function_call_output",
+	call_id: o.call_id,
+	output: o.output
+})), matchType("reasoning", (r) => ({
+	type: "reasoning",
+	...r.id !== void 0 && { id: r.id },
+	...r.summary !== void 0 && { summary: [{
+		type: "summary_text",
+		text: r.summary
+	}] },
+	...r.signature !== void 0 && { encrypted_content: r.signature }
+})), Match.exhaustive);
+/** Convert our `Item[]` history into the Responses API `input` array. */
+const itemsToInput = (items) => items.map(itemToInput);
+const wireMessageContentToBlock = Match.type().pipe(matchType("output_text", (c) => ({
+	type: "output_text",
+	text: c.text,
+	...c.annotations !== void 0 && c.annotations !== null && { annotations: c.annotations }
+})), matchType("refusal", (c) => ({
+	type: "refusal",
+	text: c.refusal
+})), Match.exhaustive);
+const wireItemToItem = (wire) => Match.value(wire).pipe(matchType("message", (m) => ({
+	type: "message",
+	role: m.role,
+	content: m.content.map(wireMessageContentToBlock),
+	providerData: m
+})), matchType("function_call", (f) => ({
+	type: "function_call",
+	call_id: f.call_id,
+	name: f.name,
+	arguments: f.arguments,
+	providerData: f
+})), matchType("reasoning", (r) => ({
+	type: "reasoning",
+	...r.id !== void 0 && { id: r.id },
+	...r.summary !== void 0 && { summary: r.summary.map((s) => s.text).join("\n") },
+	...r.encrypted_content !== void 0 && { signature: r.encrypted_content },
+	providerData: r
+})), Match.exhaustive);
+const reasonToStop = Match.type().pipe(Match.when("max_output_tokens", () => "max_tokens"), Match.when("refusal", () => "refusal"), Match.when("content_filter", () => "content_filter"), Match.when("max_tool_calls", () => "max_tool_calls"), Match.option);
+const hasRefusalContent = (payload) => (payload.output ?? []).some((i) => i.type === "message" && i.content.some((c) => c.type === "refusal"));
+const stopReasonFromCompleted = (payload) => Option.match(reasonToStop(payload.incomplete_details?.reason ?? ""), {
+	onSome: (s) => s,
+	onNone: () => hasRefusalContent(payload) ? "refusal" : (payload.output ?? []).some((i) => i.type === "function_call") ? "tool_calls" : "stop"
+});
+const cachedTokens = (payload) => payload.usage?.input_tokens_details?.cached_tokens ?? void 0;
+const reasoningTokens = (payload) => payload.usage?.output_tokens_details?.reasoning_tokens ?? void 0;
+const turnFromCompleted = (payload) => {
+	const cached = cachedTokens(payload);
+	const reasoning = reasoningTokens(payload);
+	return {
+		items: (payload.output ?? []).map(wireItemToItem),
+		usage: {
+			...payload.usage?.input_tokens !== void 0 && { input_tokens: payload.usage.input_tokens },
+			...payload.usage?.output_tokens !== void 0 && { output_tokens: payload.usage.output_tokens },
+			...payload.usage?.total_tokens !== void 0 && { total_tokens: payload.usage.total_tokens },
+			...cached !== void 0 && { input_tokens_details: { cached_tokens: cached } },
+			...reasoning !== void 0 && { output_tokens_details: { reasoning_tokens: reasoning } }
+		},
+		stop_reason: stopReasonFromCompleted(payload)
+	};
+};
+//#endregion
+//#region src/streamEvents.ts
+var streamEvents_exports = /* @__PURE__ */ __exportAll({
+	KnownProviderEvent: () => KnownProviderEvent,
+	ProviderEvent: () => ProviderEvent,
+	eventToDeltas: () => eventToDeltas,
+	makeCallIdLookup: () => makeCallIdLookup
+});
+const OutputItemAdded = Schema.Struct({
+	type: Schema.Literal("response.output_item.added"),
+	item: WireOutputItem
+});
+const OutputTextDelta = Schema.Struct({
+	type: Schema.Literal("response.output_text.delta"),
+	delta: Schema.String
+});
+const FunctionArgsDelta = Schema.Struct({
+	type: Schema.Literal("response.function_call_arguments.delta"),
+	item_id: Schema.String,
+	delta: Schema.String
+});
+const ReasoningTextDelta = Schema.Struct({
+	type: Schema.Literal("response.reasoning_text.delta"),
+	delta: Schema.String
+});
+const ReasoningSummaryDelta = Schema.Struct({
+	type: Schema.Literal("response.reasoning_summary_text.delta"),
+	delta: Schema.String
+});
+const RefusalDelta = Schema.Struct({
+	type: Schema.Literal("response.refusal.delta"),
+	delta: Schema.String
+});
+const RefusalDone = Schema.Struct({
+	type: Schema.Literal("response.refusal.done"),
+	refusal: Schema.optional(Schema.String)
+});
+const Completed = Schema.Struct({
+	type: Schema.Literal("response.completed"),
+	response: WireResponseCompleted
+});
+const Incomplete = Schema.Struct({
+	type: Schema.Literal("response.incomplete"),
+	response: WireResponseCompleted
+});
+const Failed = Schema.Struct({
+	type: Schema.Literal("response.failed"),
+	response: WireResponseCompleted
+});
+const ErrorEvent = Schema.Struct({
+	type: Schema.Literal("error"),
+	message: Schema.optional(Schema.String),
+	code: Schema.optional(Schema.String)
+});
+/**
+* Catch-all variant for wire events that fail to decode against any known
+* schema, plus events that fail to JSON-parse. The decoder never produces
+* this directly - it's synthesized by `sseEventToProviderEvent` when
+* `decodeKnown` fails.
+*/
+const Unknown = Schema.Struct({
+	type: Schema.Literal("_unknown"),
+	raw: Schema.Unknown
+});
+/**
+* Internal: union of variants we actually know how to decode from the wire.
+* Used as the decode target; failures are caught and re-emitted as `Unknown`.
+*/
+const KnownProviderEvent = Schema.Union([
+	OutputItemAdded,
+	OutputTextDelta,
+	FunctionArgsDelta,
+	ReasoningTextDelta,
+	ReasoningSummaryDelta,
+	RefusalDelta,
+	RefusalDone,
+	Completed,
+	Incomplete,
+	Failed,
+	ErrorEvent
+]);
+/**
+* Public: every event the native stream can emit. Discriminated on `type`.
+* The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`
+* cannot silently miss a wire event we didn't model.
+*/
+const ProviderEvent = Schema.Union([
+	OutputItemAdded,
+	OutputTextDelta,
+	FunctionArgsDelta,
+	ReasoningTextDelta,
+	ReasoningSummaryDelta,
+	RefusalDelta,
+	RefusalDone,
+	Completed,
+	Incomplete,
+	Failed,
+	ErrorEvent,
+	Unknown
+]);
+const makeCallIdLookup = () => {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		resolve: (id) => map.get(id),
+		remember: (id, callId) => {
+			map.set(id, callId);
+		}
+	};
+};
+/**
+* Translate a decoded provider event into zero-or-more `TurnEvent`s.
+* Mutates `lookup` to record `(item_id → call_id)` from `output_item.added`
+* so subsequent `function_call_arguments.delta` events can be tagged with
+* the right call id.
+*/
+const eventToDeltas = (event, lookup) => Match.value(event).pipe(matchType("response.output_item.added", ({ item }) => {
+	if (item.type !== "function_call") return [];
+	if (item.id !== void 0) lookup.remember(item.id, item.call_id);
+	return [{
+		type: "tool_call_start",
+		call_id: item.call_id,
+		name: item.name
+	}];
+}), matchType("response.output_text.delta", ({ delta }) => [{
+	type: "text_delta",
+	text: delta
+}]), matchType("response.function_call_arguments.delta", ({ item_id, delta }) => {
+	const call_id = lookup.resolve(item_id);
+	return call_id === void 0 ? [] : [{
+		type: "tool_call_args_delta",
+		call_id,
+		delta
+	}];
+}), matchType("response.reasoning_text.delta", ({ delta }) => [{
+	type: "reasoning_delta",
+	text: delta,
+	kind: "trace"
+}]), matchType("response.reasoning_summary_text.delta", ({ delta }) => [{
+	type: "reasoning_delta",
+	text: delta,
+	kind: "summary"
+}]), matchType("response.refusal.delta", ({ delta }) => [{
+	type: "refusal_delta",
+	text: delta
+}]), matchType("response.refusal.done", () => []), matchType("response.completed", ({ response }) => [{
+	type: "turn_complete",
+	turn: turnFromCompleted(response)
+}]), matchType("response.incomplete", ({ response }) => [{
+	type: "turn_complete",
+	turn: turnFromCompleted(response)
+}]), matchType("response.failed", () => []), matchType("error", () => []), matchType("_unknown", () => []), Match.exhaustive);
+//#endregion
+//#region src/Responses.ts
+/**
+* Provider-typed service tag. Yield this when you want Responses-specific
+* options (`reasoning.effort`, `store`, `previousResponseId`) at the call
+* site. Yield the generic `LanguageModel` tag for provider-portable code -
+* both are registered by `layer`.
+*/
+var Responses = class extends Context.Service()("@betalyra/effect-uai/providers/responses/Responses") {};
+const jsonSchemaFormat = (format) => ({
+	type: "json_schema",
+	name: format.name,
+	schema: format.schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }),
+	...format.description !== void 0 && { description: format.description },
+	...format.strict !== void 0 && { strict: format.strict }
+});
+const buildText = (request) => {
+	const format = request.structured !== void 0 ? jsonSchemaFormat(request.structured) : request.responseFormat;
+	const text = {};
+	if (format !== void 0) text.format = format;
+	if (request.verbosity !== void 0) text.verbosity = request.verbosity;
+	return Object.keys(text).length === 0 ? void 0 : text;
+};
+const buildBody = (request) => {
+	const text = buildText(request);
+	return {
+		model: request.model,
+		input: itemsToInput(request.history),
+		stream: true,
+		...request.tools !== void 0 && request.tools.length > 0 && { tools: request.tools.map((t) => ({
+			type: "function",
+			name: t.name,
+			description: t.description,
+			parameters: t.inputSchema,
+			...t.strict !== void 0 && { strict: t.strict }
+		})) },
+		...request.toolChoice !== void 0 && { tool_choice: request.toolChoice },
+		...request.temperature !== void 0 && { temperature: request.temperature },
+		...request.maxOutputTokens !== void 0 && { max_output_tokens: request.maxOutputTokens },
+		...request.reasoning !== void 0 && { reasoning: request.reasoning },
+		...request.store !== void 0 && { store: request.store },
+		...request.previousResponseId !== void 0 && { previous_response_id: request.previousResponseId },
+		...request.instructions !== void 0 && { instructions: request.instructions },
+		...request.topP !== void 0 && { top_p: request.topP },
+		...request.parallelToolCalls !== void 0 && { parallel_tool_calls: request.parallelToolCalls },
+		...request.metadata !== void 0 && { metadata: request.metadata },
+		...request.user !== void 0 && { user: request.user },
+		...request.safetyIdentifier !== void 0 && { safety_identifier: request.safetyIdentifier },
+		...request.promptCacheKey !== void 0 && { prompt_cache_key: request.promptCacheKey },
+		...request.truncation !== void 0 && { truncation: request.truncation },
+		...text !== void 0 && { text }
+	};
+};
+const decodeKnown = Schema.decodeUnknownEffect(KnownProviderEvent);
+const makeUnknown = (raw) => ({
+	type: "_unknown",
+	raw
+});
+/**
+* Lift events that carry a terminal failure signal (`error`,
+* `response.failed`) to a typed `AiError`. Other events are not failures
+* and produce `Option.none`.
+*/
+const eventToError = Match.type().pipe(matchType("error", (e) => new AiError.Unavailable({
+	provider: "responses",
+	raw: e
+})), matchType("response.failed", (e) => {
+	const code = e.response.error?.code;
+	const message = e.response.error?.message;
+	return new AiError.GenerationFailed({
+		provider: "responses",
+		...code !== void 0 && code !== null && { code },
+		...message !== void 0 && message !== null && { message },
+		raw: e
+	});
+}), Match.option);
+const sseEventToProviderEvent = (ev) => Effect.try({
+	try: () => JSON.parse(ev.data),
+	catch: () => ev.data
+}).pipe(Effect.flatMap((parsed) => decodeKnown(parsed).pipe(Effect.orElseSucceed(() => makeUnknown(parsed)))), Effect.orElseSucceed(() => makeUnknown(ev.data)));
+const httpStatusError = (status, body) => {
+	const provider = "responses";
+	const raw = body;
+	if (status === 429) return new AiError.RateLimited({
+		provider,
+		raw
+	});
+	if (status === 408 || status === 504) return new AiError.Timeout({
+		provider,
+		raw
+	});
+	if (status === 401) return new AiError.AuthFailed({
+		provider,
+		subtype: "auth",
+		raw
+	});
+	if (status === 403) return new AiError.AuthFailed({
+		provider,
+		subtype: "permission",
+		raw
+	});
+	if (status === 402) return new AiError.AuthFailed({
+		provider,
+		subtype: "billing",
+		raw
+	});
+	if (status === 413) return new AiError.ContextLengthExceeded({
+		provider,
+		raw
+	});
+	if (status >= 500) return new AiError.Unavailable({
+		provider,
+		status,
+		raw
+	});
+	return new AiError.InvalidRequest({
+		provider,
+		raw
+	});
+};
+const buildNativeStream = (cfg) => {
+	const url = `${cfg.baseUrl ?? "https://api.openai.com/v1"}/responses`;
+	return (request) => Stream.unwrap(Effect.gen(function* () {
+		const client = yield* HttpClient.HttpClient;
+		const httpRequest = HttpClientRequest.post(url).pipe(HttpClientRequest.bearerToken(cfg.apiKey), HttpClientRequest.bodyJsonUnsafe(buildBody(request)), HttpClientRequest.accept("text/event-stream"));
+		const response = yield* client.execute(httpRequest).pipe(Effect.mapError((cause) => new AiError.Unavailable({
+			provider: "responses",
+			raw: cause
+		})));
+		if (response.status >= 400) {
+			const body = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+			return Stream.fail(httpStatusError(response.status, body));
+		}
+		return response.stream.pipe(Stream.mapError((cause) => new AiError.Unavailable({
+			provider: "responses",
+			raw: cause
+		})), SSE.fromBytes, Stream.mapEffect(sseEventToProviderEvent), Stream.flatMap((event) => Option.match(eventToError(event), {
+			onNone: () => Stream.succeed(event),
+			onSome: Stream.fail
+		})));
+	}));
+};
+/**
+* Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.
+* Threads a fresh `CallIdLookup` per stream so `function_call_arguments.delta`
+* can be tagged with the right `call_id`.
+*/
+const toCanonical = (s) => Stream.unwrap(Effect.sync(() => {
+	const lookup = makeCallIdLookup();
+	return s.pipe(Stream.flatMap((event) => Stream.fromIterable(eventToDeltas(event, lookup))));
+}));
+/**
+* Build a `ResponsesService` value. For Layer-based setup, prefer `layer`.
+*/
+const make = (cfg) => Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
+	const streamNative = (request) => buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client));
+	return {
+		streamNative,
+		streamTurn: (request) => toCanonical(streamNative(request)),
+		toCanonical
+	};
+});
+/**
+* Layer that registers both the provider-specific `Responses` tag and the
+* generic `LanguageModel` tag, sharing one underlying implementation.
+*
+* The generic tag accepts `CommonRequest`; the typed tag accepts the full
+* `ResponsesRequest` surface.
+*/
+const layer = (cfg) => {
+	const typed = Layer.effect(Responses, make(cfg));
+	const generic = Layer.effect(LanguageModel, Effect.map(make(cfg), (s) => ({ streamTurn: (request) => s.streamTurn(request) })));
+	return Layer.merge(typed, generic);
+};
+//#endregion
+export { Responses, codec_exports as codec, layer, make, streamEvents_exports as streamEvents, toCanonical };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/codec.ts","../src/streamEvents.ts","../src/Responses.ts"],"sourcesContent":["import { Match, Option, Schema } from \"effect\"\nimport type { ContentBlock, Item } from \"@effect-uai/core/Items\"\nimport { matchType } from \"@effect-uai/core/Match\"\nimport type { Turn } from \"@effect-uai/core/Turn\"\n\n// ---------------------------------------------------------------------------\n// Wire schemas - minimal subset of the Responses API output we consume.\n// Reference: https://www.openresponses.org/specification\n// ---------------------------------------------------------------------------\n\nconst WireUrlCitation = Schema.Struct({\n  type: Schema.Literal(\"url_citation\"),\n  url: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n  title: Schema.String,\n})\n\nconst WireFileCitation = Schema.Struct({\n  type: Schema.Literal(\"file_citation\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\n\nconst WireContainerFileCitation = Schema.Struct({\n  type: Schema.Literal(\"container_file_citation\"),\n  container_id: Schema.String,\n  file_id: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n})\n\nconst WireFilePath = Schema.Struct({\n  type: Schema.Literal(\"file_path\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\n\nconst WireAnnotation = Schema.Union([\n  WireUrlCitation,\n  WireFileCitation,\n  WireContainerFileCitation,\n  WireFilePath,\n])\n\nconst WireOutputTextContent = Schema.Struct({\n  type: Schema.Literal(\"output_text\"),\n  text: Schema.String,\n  annotations: Schema.optional(Schema.NullOr(Schema.Array(WireAnnotation))),\n})\n\nconst WireRefusalContent = Schema.Struct({\n  type: Schema.Literal(\"refusal\"),\n  refusal: Schema.String,\n})\n\nconst WireMessageContent = Schema.Union([WireOutputTextContent, WireRefusalContent])\n\nconst WireSummaryText = Schema.Struct({\n  type: Schema.Literal(\"summary_text\"),\n  text: Schema.String,\n})\n\nconst WireMessage = Schema.Struct({\n  type: Schema.Literal(\"message\"),\n  id: Schema.optional(Schema.String),\n  role: Schema.Literal(\"assistant\"),\n  content: Schema.Array(WireMessageContent),\n})\n\nconst WireFunctionCall = Schema.Struct({\n  type: Schema.Literal(\"function_call\"),\n  id: Schema.optional(Schema.String),\n  call_id: Schema.String,\n  name: Schema.String,\n  arguments: Schema.String,\n})\n\nconst WireReasoning = Schema.Struct({\n  type: Schema.Literal(\"reasoning\"),\n  id: Schema.optional(Schema.String),\n  summary: Schema.optional(Schema.Array(WireSummaryText)),\n  encrypted_content: Schema.optional(Schema.String),\n})\n\nexport const WireOutputItem = Schema.Union([WireMessage, WireFunctionCall, WireReasoning])\nexport type WireOutputItem = typeof WireOutputItem.Type\n\nconst WireInputTokensDetails = Schema.Struct({\n  cached_tokens: Schema.optional(Schema.NullOr(Schema.Number)),\n})\n\nconst WireOutputTokensDetails = Schema.Struct({\n  reasoning_tokens: Schema.optional(Schema.NullOr(Schema.Number)),\n})\n\nconst WireUsage = Schema.Struct({\n  input_tokens: Schema.optional(Schema.Number),\n  output_tokens: Schema.optional(Schema.Number),\n  total_tokens: Schema.optional(Schema.Number),\n  input_tokens_details: Schema.optional(Schema.NullOr(WireInputTokensDetails)),\n  output_tokens_details: Schema.optional(Schema.NullOr(WireOutputTokensDetails)),\n})\n\nconst WireResponseError = Schema.Struct({\n  code: Schema.optional(Schema.NullOr(Schema.String)),\n  message: Schema.optional(Schema.NullOr(Schema.String)),\n})\n\n// Many Responses-API fields are emitted as explicit `null` rather than\n// missing - `Schema.optional` alone (T | undefined) doesn't cover that, so\n// we lift each through `NullOr` first. Used by `response.completed`,\n// `response.incomplete`, and `response.failed` events; not every field is\n// populated on every event (e.g. `error` only on failed, `incomplete_details`\n// only on incomplete).\nexport const WireResponseCompleted = Schema.Struct({\n  id: Schema.optional(Schema.NullOr(Schema.String)),\n  status: Schema.optional(Schema.NullOr(Schema.String)),\n  output: Schema.optional(Schema.NullOr(Schema.Array(WireOutputItem))),\n  usage: Schema.optional(Schema.NullOr(WireUsage)),\n  incomplete_details: Schema.optional(\n    Schema.NullOr(\n      Schema.Struct({\n        reason: Schema.optional(Schema.NullOr(Schema.String)),\n      }),\n    ),\n  ),\n  error: Schema.optional(Schema.NullOr(WireResponseError)),\n})\nexport type WireResponseCompleted = typeof WireResponseCompleted.Type\n\n// ---------------------------------------------------------------------------\n// History → request body input\n// ---------------------------------------------------------------------------\n\n/**\n * If an item carries `providerData` from a prior OpenAI turn, re-emit it\n * verbatim - preserves `encrypted_content`, item ids, and any field this\n * codec doesn't model.\n */\nconst passthrough = (item: Item): Record<string, unknown> | undefined =>\n  item.providerData !== undefined &&\n  typeof item.providerData === \"object\" &&\n  item.providerData !== null\n    ? (item.providerData as Record<string, unknown>)\n    : undefined\n\nconst contentBlockToInput = Match.type<ContentBlock>().pipe(\n  matchType(\"input_text\", (b) => ({ type: \"input_text\", text: b.text })),\n  matchType(\"input_image\", (b) => ({\n    type: \"input_image\",\n    image_url:\n      b.source._tag === \"url\"\n        ? b.source.url\n        : `data:${b.source.media_type};base64,${b.source.data}`,\n  })),\n  matchType(\"output_text\", (b) => ({ type: \"output_text\", text: b.text })),\n  matchType(\"refusal\", (b) => ({ type: \"refusal\", refusal: b.text })),\n  Match.exhaustive,\n)\n\nconst itemToInput = (item: Item): Record<string, unknown> =>\n  passthrough(item) ??\n  Match.value(item).pipe(\n    matchType(\"message\", (m) => ({\n      type: \"message\",\n      role: m.role,\n      content: m.content.map(contentBlockToInput),\n    })),\n    matchType(\"function_call\", (f) => ({\n      type: \"function_call\",\n      call_id: f.call_id,\n      name: f.name,\n      arguments: f.arguments,\n    })),\n    matchType(\"function_call_output\", (o) => ({\n      type: \"function_call_output\",\n      call_id: o.call_id,\n      output: o.output,\n    })),\n    matchType(\"reasoning\", (r) => ({\n      type: \"reasoning\",\n      ...(r.id !== undefined && { id: r.id }),\n      ...(r.summary !== undefined && {\n        summary: [{ type: \"summary_text\", text: r.summary }],\n      }),\n      ...(r.signature !== undefined && { encrypted_content: r.signature }),\n    })),\n    Match.exhaustive,\n  )\n\n/** Convert our `Item[]` history into the Responses API `input` array. */\nexport const itemsToInput = (items: ReadonlyArray<Item>): ReadonlyArray<Record<string, unknown>> =>\n  items.map(itemToInput)\n\n// ---------------------------------------------------------------------------\n// Wire output items → our Items\n// ---------------------------------------------------------------------------\n\nconst wireMessageContentToBlock = Match.type<typeof WireMessageContent.Type>().pipe(\n  matchType(\n    \"output_text\",\n    (c): ContentBlock => ({\n      type: \"output_text\",\n      text: c.text,\n      ...(c.annotations !== undefined && c.annotations !== null && { annotations: c.annotations }),\n    }),\n  ),\n  matchType(\"refusal\", (c): ContentBlock => ({ type: \"refusal\", text: c.refusal })),\n  Match.exhaustive,\n)\n\nexport const wireItemToItem = (wire: WireOutputItem): Item =>\n  Match.value(wire).pipe(\n    matchType(\"message\", (m) => ({\n      type: \"message\" as const,\n      role: m.role,\n      content: m.content.map(wireMessageContentToBlock),\n      providerData: m,\n    })),\n    matchType(\"function_call\", (f) => ({\n      type: \"function_call\" as const,\n      call_id: f.call_id,\n      name: f.name,\n      arguments: f.arguments,\n      providerData: f,\n    })),\n    matchType(\"reasoning\", (r) => ({\n      type: \"reasoning\" as const,\n      ...(r.id !== undefined && { id: r.id }),\n      ...(r.summary !== undefined && {\n        summary: r.summary.map((s) => s.text).join(\"\\n\"),\n      }),\n      ...(r.encrypted_content !== undefined && { signature: r.encrypted_content }),\n      providerData: r,\n    })),\n    Match.exhaustive,\n  )\n\n// ---------------------------------------------------------------------------\n// response.completed → Turn\n// ---------------------------------------------------------------------------\n\nconst reasonToStop = Match.type<string>().pipe(\n  Match.when(\"max_output_tokens\", () => \"max_tokens\" as const),\n  Match.when(\"refusal\", () => \"refusal\" as const),\n  Match.when(\"content_filter\", () => \"content_filter\" as const),\n  Match.when(\"max_tool_calls\", () => \"max_tool_calls\" as const),\n  Match.option,\n)\n\nconst hasRefusalContent = (payload: WireResponseCompleted): boolean =>\n  (payload.output ?? []).some(\n    (i) => i.type === \"message\" && i.content.some((c) => c.type === \"refusal\"),\n  )\n\nconst stopReasonFromCompleted = (payload: WireResponseCompleted): Turn[\"stop_reason\"] =>\n  Option.match(reasonToStop(payload.incomplete_details?.reason ?? \"\"), {\n    onSome: (s) => s,\n    onNone: () =>\n      hasRefusalContent(payload)\n        ? (\"refusal\" as const)\n        : (payload.output ?? []).some((i) => i.type === \"function_call\")\n          ? (\"tool_calls\" as const)\n          : (\"stop\" as const),\n  })\n\nconst cachedTokens = (payload: WireResponseCompleted): number | undefined =>\n  payload.usage?.input_tokens_details?.cached_tokens ?? undefined\n\nconst reasoningTokens = (payload: WireResponseCompleted): number | undefined =>\n  payload.usage?.output_tokens_details?.reasoning_tokens ?? undefined\n\nexport const turnFromCompleted = (payload: WireResponseCompleted): Turn => {\n  const cached = cachedTokens(payload)\n  const reasoning = reasoningTokens(payload)\n  return {\n    items: (payload.output ?? []).map(wireItemToItem),\n    usage: {\n      ...(payload.usage?.input_tokens !== undefined && {\n        input_tokens: payload.usage.input_tokens,\n      }),\n      ...(payload.usage?.output_tokens !== undefined && {\n        output_tokens: payload.usage.output_tokens,\n      }),\n      ...(payload.usage?.total_tokens !== undefined && {\n        total_tokens: payload.usage.total_tokens,\n      }),\n      ...(cached !== undefined && {\n        input_tokens_details: { cached_tokens: cached },\n      }),\n      ...(reasoning !== undefined && {\n        output_tokens_details: { reasoning_tokens: reasoning },\n      }),\n    },\n    stop_reason: stopReasonFromCompleted(payload),\n  }\n}\n","import { Match, Schema } from \"effect\"\nimport { matchType } from \"@effect-uai/core/Match\"\nimport type { TurnEvent } from \"@effect-uai/core/Turn\"\nimport { WireOutputItem, WireResponseCompleted, turnFromCompleted } from \"./codec.js\"\n\n// ---------------------------------------------------------------------------\n// Schemas for the SSE event payloads we care about. The Responses API ships\n// many event types; we model only the ones that map to a `TurnEvent`. All\n// others are silently ignored at the dispatch site.\n// ---------------------------------------------------------------------------\n\nconst OutputItemAdded = Schema.Struct({\n  type: Schema.Literal(\"response.output_item.added\"),\n  item: WireOutputItem,\n})\n\nconst OutputTextDelta = Schema.Struct({\n  type: Schema.Literal(\"response.output_text.delta\"),\n  delta: Schema.String,\n})\n\nconst FunctionArgsDelta = Schema.Struct({\n  type: Schema.Literal(\"response.function_call_arguments.delta\"),\n  item_id: Schema.String,\n  delta: Schema.String,\n})\n\nconst ReasoningTextDelta = Schema.Struct({\n  type: Schema.Literal(\"response.reasoning_text.delta\"),\n  delta: Schema.String,\n})\n\nconst ReasoningSummaryDelta = Schema.Struct({\n  type: Schema.Literal(\"response.reasoning_summary_text.delta\"),\n  delta: Schema.String,\n})\n\nconst RefusalDelta = Schema.Struct({\n  type: Schema.Literal(\"response.refusal.delta\"),\n  delta: Schema.String,\n})\n\nconst RefusalDone = Schema.Struct({\n  type: Schema.Literal(\"response.refusal.done\"),\n  refusal: Schema.optional(Schema.String),\n})\n\nconst Completed = Schema.Struct({\n  type: Schema.Literal(\"response.completed\"),\n  response: WireResponseCompleted,\n})\n\nconst Incomplete = Schema.Struct({\n  type: Schema.Literal(\"response.incomplete\"),\n  response: WireResponseCompleted,\n})\n\nconst Failed = Schema.Struct({\n  type: Schema.Literal(\"response.failed\"),\n  response: WireResponseCompleted,\n})\n\nconst ErrorEvent = Schema.Struct({\n  type: Schema.Literal(\"error\"),\n  message: Schema.optional(Schema.String),\n  code: Schema.optional(Schema.String),\n})\n\n/**\n * Catch-all variant for wire events that fail to decode against any known\n * schema, plus events that fail to JSON-parse. The decoder never produces\n * this directly - it's synthesized by `sseEventToProviderEvent` when\n * `decodeKnown` fails.\n */\nconst Unknown = Schema.Struct({\n  type: Schema.Literal(\"_unknown\"),\n  raw: Schema.Unknown,\n})\n\n/**\n * Internal: union of variants we actually know how to decode from the wire.\n * Used as the decode target; failures are caught and re-emitted as `Unknown`.\n */\nexport const KnownProviderEvent = Schema.Union([\n  OutputItemAdded,\n  OutputTextDelta,\n  FunctionArgsDelta,\n  ReasoningTextDelta,\n  ReasoningSummaryDelta,\n  RefusalDelta,\n  RefusalDone,\n  Completed,\n  Incomplete,\n  Failed,\n  ErrorEvent,\n])\n\n/**\n * Public: every event the native stream can emit. Discriminated on `type`.\n * The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`\n * cannot silently miss a wire event we didn't model.\n */\nexport const ProviderEvent = Schema.Union([\n  OutputItemAdded,\n  OutputTextDelta,\n  FunctionArgsDelta,\n  ReasoningTextDelta,\n  ReasoningSummaryDelta,\n  RefusalDelta,\n  RefusalDone,\n  Completed,\n  Incomplete,\n  Failed,\n  ErrorEvent,\n  Unknown,\n])\nexport type ProviderEvent = typeof ProviderEvent.Type\n\n// `call_id` lookup for `function_call_arguments.delta`. The SSE event\n// references the *item id*, not the call id; we keep a small map populated\n// from the `output_item.added` events.\nexport interface CallIdLookup {\n  readonly resolve: (itemId: string) => string | undefined\n  readonly remember: (itemId: string, callId: string) => void\n}\n\nexport const makeCallIdLookup = (): CallIdLookup => {\n  const map = new Map<string, string>()\n  return {\n    resolve: (id) => map.get(id),\n    remember: (id, callId) => {\n      map.set(id, callId)\n    },\n  }\n}\n\n/**\n * Translate a decoded provider event into zero-or-more `TurnEvent`s.\n * Mutates `lookup` to record `(item_id → call_id)` from `output_item.added`\n * so subsequent `function_call_arguments.delta` events can be tagged with\n * the right call id.\n */\nexport const eventToDeltas = (\n  event: ProviderEvent,\n  lookup: CallIdLookup,\n): ReadonlyArray<TurnEvent> =>\n  Match.value(event).pipe(\n    matchType(\"response.output_item.added\", ({ item }) => {\n      if (item.type !== \"function_call\") return []\n      if (item.id !== undefined) lookup.remember(item.id, item.call_id)\n      return [\n        {\n          type: \"tool_call_start\" as const,\n          call_id: item.call_id,\n          name: item.name,\n        },\n      ]\n    }),\n    matchType(\"response.output_text.delta\", ({ delta }) => [\n      { type: \"text_delta\" as const, text: delta },\n    ]),\n    matchType(\"response.function_call_arguments.delta\", ({ item_id, delta }) => {\n      const call_id = lookup.resolve(item_id)\n      return call_id === undefined\n        ? []\n        : [{ type: \"tool_call_args_delta\" as const, call_id, delta }]\n    }),\n    matchType(\"response.reasoning_text.delta\", ({ delta }) => [\n      { type: \"reasoning_delta\" as const, text: delta, kind: \"trace\" as const },\n    ]),\n    matchType(\"response.reasoning_summary_text.delta\", ({ delta }) => [\n      { type: \"reasoning_delta\" as const, text: delta, kind: \"summary\" as const },\n    ]),\n    matchType(\"response.refusal.delta\", ({ delta }) => [\n      { type: \"refusal_delta\" as const, text: delta },\n    ]),\n    // Terminal marker for the refusal stream; the deltas already covered\n    // the text, so no canonical event is emitted here.\n    matchType(\"response.refusal.done\", () => []),\n    matchType(\"response.completed\", ({ response }) => [\n      { type: \"turn_complete\" as const, turn: turnFromCompleted(response) },\n    ]),\n    // Incomplete = the model stopped early but produced a usable partial\n    // turn (max_tokens, content_filter, max_tool_calls, refusal). Same\n    // payload shape as `response.completed`; the stop_reason carries the\n    // reason.\n    matchType(\"response.incomplete\", ({ response }) => [\n      { type: \"turn_complete\" as const, turn: turnFromCompleted(response) },\n    ]),\n    // Failed and error are surfaced separately as `AiError` by the stream\n    // pipeline, not as canonical events.\n    matchType(\"response.failed\", () => []),\n    matchType(\"error\", () => []),\n    // No silent drops: unknown wire events flow through `streamNative` but\n    // produce no canonical delta. Step 3 (canonical `other` event) replaces\n    // this with a forwarded `other` delta on `TurnEvent`.\n    matchType(\"_unknown\", () => []),\n    Match.exhaustive,\n  )\n","import { Context, Effect, Layer, Match, Option, Redacted, Schema, Stream } from \"effect\"\nimport { HttpClient, HttpClientRequest } from \"effect/unstable/http\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport { matchType } from \"@effect-uai/core/Match\"\nimport * as StructuredFormat from \"@effect-uai/core/StructuredFormat\"\nimport {\n  type CommonRequest,\n  LanguageModel,\n  type LanguageModelService,\n} from \"@effect-uai/core/LanguageModel\"\nimport * as SSE from \"@effect-uai/core/SSE\"\nimport type { TurnEvent } from \"@effect-uai/core/Turn\"\nimport { itemsToInput } from \"./codec.js\"\nimport type { OpenAIModel } from \"./models.js\"\nimport {\n  KnownProviderEvent,\n  ProviderEvent,\n  eventToDeltas,\n  makeCallIdLookup,\n} from \"./streamEvents.js\"\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\nexport interface ResponsesRequest extends Omit<CommonRequest, \"model\"> {\n  /**\n   * Narrows `CommonRequest.model` (`string`) to the typed `OpenAIModel`\n   * literal union for autocomplete.\n   */\n  readonly model: OpenAIModel\n  readonly reasoning?: { readonly effort: \"low\" | \"medium\" | \"high\" }\n  readonly store?: boolean\n  readonly previousResponseId?: string\n  readonly instructions?: string\n  readonly parallelToolCalls?: boolean\n  readonly metadata?: Readonly<Record<string, string>>\n  readonly user?: string\n  readonly safetyIdentifier?: string\n  readonly promptCacheKey?: string\n  readonly truncation?: \"auto\" | \"disabled\"\n  /**\n   * Free-form JSON output: model emits valid JSON without schema\n   * constraints. Mutually exclusive with `structured` (schema wins if\n   * both are set).\n   */\n  readonly responseFormat?: { readonly type: \"json_object\" }\n  /**\n   * Answer length / level-of-detail hint. GPT-5+ models honour it;\n   * earlier models ignore.\n   */\n  readonly verbosity?: \"low\" | \"medium\" | \"high\"\n}\n\nexport interface ResponsesService {\n  /**\n   * Stream the provider's native event vocabulary (post-SSE-decode).\n   * Use this when you need full vendor fidelity. For provider-portable\n   * code, use `streamTurn` instead.\n   */\n  readonly streamNative: (\n    request: ResponsesRequest,\n  ) => Stream.Stream<ProviderEvent, AiError.AiError>\n  /**\n   * Stream canonical `TurnEvent`s. Implemented as\n   * `streamNative |> toCanonical`.\n   */\n  readonly streamTurn: (request: ResponsesRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n  /**\n   * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.\n   * Exposed for cases where consumers want to compose with `streamNative`\n   * directly (e.g. tap into natives + still get canonical downstream).\n   */\n  readonly toCanonical: <E, R>(\n    s: Stream.Stream<ProviderEvent, E, R>,\n  ) => Stream.Stream<TurnEvent, E, R>\n}\n\n/**\n * Provider-typed service tag. Yield this when you want Responses-specific\n * options (`reasoning.effort`, `store`, `previousResponseId`) at the call\n * site. Yield the generic `LanguageModel` tag for provider-portable code -\n * both are registered by `layer`.\n */\nexport class Responses extends Context.Service<Responses, ResponsesService>()(\n  \"@betalyra/effect-uai/providers/responses/Responses\",\n) {}\n\nexport interface Config {\n  readonly apiKey: Redacted.Redacted\n  readonly baseUrl?: string\n}\n\n// ---------------------------------------------------------------------------\n// Request body\n// ---------------------------------------------------------------------------\n\nconst jsonSchemaFormat = (\n  format: StructuredFormat.StructuredFormat<unknown>,\n): Record<string, unknown> => ({\n  type: \"json_schema\",\n  name: format.name,\n  schema: format.schema[\"~standard\"].jsonSchema.input({ target: \"draft-2020-12\" }),\n  ...(format.description !== undefined && { description: format.description }),\n  ...(format.strict !== undefined && { strict: format.strict }),\n})\n\nconst buildText = (request: ResponsesRequest): Record<string, unknown> | undefined => {\n  const format =\n    request.structured !== undefined ? jsonSchemaFormat(request.structured) : request.responseFormat\n  const text: Record<string, unknown> = {}\n  if (format !== undefined) text.format = format\n  if (request.verbosity !== undefined) text.verbosity = request.verbosity\n  return Object.keys(text).length === 0 ? undefined : text\n}\n\nconst buildBody = (request: ResponsesRequest): Record<string, unknown> => {\n  const text = buildText(request)\n  return {\n    model: request.model,\n    input: itemsToInput(request.history),\n    stream: true,\n    ...(request.tools !== undefined &&\n      request.tools.length > 0 && {\n        tools: request.tools.map((t) => ({\n          type: \"function\",\n          name: t.name,\n          description: t.description,\n          parameters: t.inputSchema,\n          ...(t.strict !== undefined && { strict: t.strict }),\n        })),\n      }),\n    ...(request.toolChoice !== undefined && { tool_choice: request.toolChoice }),\n    ...(request.temperature !== undefined && { temperature: request.temperature }),\n    ...(request.maxOutputTokens !== undefined && {\n      max_output_tokens: request.maxOutputTokens,\n    }),\n    ...(request.reasoning !== undefined && { reasoning: request.reasoning }),\n    ...(request.store !== undefined && { store: request.store }),\n    ...(request.previousResponseId !== undefined && {\n      previous_response_id: request.previousResponseId,\n    }),\n    ...(request.instructions !== undefined && { instructions: request.instructions }),\n    ...(request.topP !== undefined && { top_p: request.topP }),\n    ...(request.parallelToolCalls !== undefined && {\n      parallel_tool_calls: request.parallelToolCalls,\n    }),\n    ...(request.metadata !== undefined && { metadata: request.metadata }),\n    ...(request.user !== undefined && { user: request.user }),\n    ...(request.safetyIdentifier !== undefined && {\n      safety_identifier: request.safetyIdentifier,\n    }),\n    ...(request.promptCacheKey !== undefined && {\n      prompt_cache_key: request.promptCacheKey,\n    }),\n    ...(request.truncation !== undefined && { truncation: request.truncation }),\n    ...(text !== undefined && { text }),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// SSE event → provider event\n// ---------------------------------------------------------------------------\n\nconst decodeKnown = Schema.decodeUnknownEffect(KnownProviderEvent)\n\nconst makeUnknown = (raw: unknown): ProviderEvent => ({ type: \"_unknown\", raw })\n\n/**\n * Lift events that carry a terminal failure signal (`error`,\n * `response.failed`) to a typed `AiError`. Other events are not failures\n * and produce `Option.none`.\n */\nconst eventToError = Match.type<ProviderEvent>().pipe(\n  matchType(\n    \"error\",\n    (e): AiError.AiError => new AiError.Unavailable({ provider: \"responses\", raw: e }),\n  ),\n  matchType(\"response.failed\", (e): AiError.AiError => {\n    const code = e.response.error?.code\n    const message = e.response.error?.message\n    return new AiError.GenerationFailed({\n      provider: \"responses\",\n      ...(code !== undefined && code !== null && { code }),\n      ...(message !== undefined && message !== null && { message }),\n      raw: e,\n    })\n  }),\n  Match.option,\n)\n\nconst sseEventToProviderEvent = (ev: SSE.Event): Effect.Effect<ProviderEvent> =>\n  Effect.try({\n    try: () => JSON.parse(ev.data) as unknown,\n    catch: () => ev.data,\n  }).pipe(\n    Effect.flatMap((parsed) =>\n      decodeKnown(parsed).pipe(Effect.orElseSucceed(() => makeUnknown(parsed))),\n    ),\n    Effect.orElseSucceed(() => makeUnknown(ev.data)),\n  )\n\n// ---------------------------------------------------------------------------\n// Service implementation\n// ---------------------------------------------------------------------------\n\nconst httpStatusError = (status: number, body: string): AiError.AiError => {\n  const provider = \"responses\"\n  const raw = body\n  if (status === 429) return new AiError.RateLimited({ provider, raw })\n  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })\n  if (status === 401) return new AiError.AuthFailed({ provider, subtype: \"auth\", raw })\n  if (status === 403) return new AiError.AuthFailed({ provider, subtype: \"permission\", raw })\n  if (status === 402) return new AiError.AuthFailed({ provider, subtype: \"billing\", raw })\n  if (status === 413) return new AiError.ContextLengthExceeded({ provider, raw })\n  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })\n  return new AiError.InvalidRequest({ provider, raw })\n}\n\nconst buildNativeStream = (cfg: Config) => {\n  const url = `${cfg.baseUrl ?? \"https://api.openai.com/v1\"}/responses`\n  return (\n    request: ResponsesRequest,\n  ): Stream.Stream<ProviderEvent, AiError.AiError, HttpClient.HttpClient> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const client = yield* HttpClient.HttpClient\n        const httpRequest = HttpClientRequest.post(url).pipe(\n          HttpClientRequest.bearerToken(cfg.apiKey),\n          HttpClientRequest.bodyJsonUnsafe(buildBody(request)),\n          HttpClientRequest.accept(\"text/event-stream\"),\n        )\n        const response = yield* client\n          .execute(httpRequest)\n          .pipe(\n            Effect.mapError(\n              (cause) => new AiError.Unavailable({ provider: \"responses\", raw: cause }),\n            ),\n          )\n        if (response.status >= 400) {\n          const body = yield* response.text.pipe(Effect.orElseSucceed(() => \"\"))\n          return Stream.fail(httpStatusError(response.status, body))\n        }\n\n        return response.stream.pipe(\n          Stream.mapError(\n            (cause) => new AiError.Unavailable({ provider: \"responses\", raw: cause }),\n          ),\n          SSE.fromBytes,\n          Stream.mapEffect(sseEventToProviderEvent),\n          Stream.flatMap((event) =>\n            Option.match(eventToError(event), {\n              onNone: () => Stream.succeed(event),\n              onSome: Stream.fail,\n            }),\n          ),\n        )\n      }),\n    )\n}\n\n/**\n * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.\n * Threads a fresh `CallIdLookup` per stream so `function_call_arguments.delta`\n * can be tagged with the right `call_id`.\n */\nexport const toCanonical = <E, R>(\n  s: Stream.Stream<ProviderEvent, E, R>,\n): Stream.Stream<TurnEvent, E, R> =>\n  Stream.unwrap(\n    Effect.sync(() => {\n      const lookup = makeCallIdLookup()\n      return s.pipe(Stream.flatMap((event) => Stream.fromIterable(eventToDeltas(event, lookup))))\n    }),\n  )\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/**\n * Build a `ResponsesService` value. For Layer-based setup, prefer `layer`.\n */\nexport const make = (cfg: Config): Effect.Effect<ResponsesService, never, HttpClient.HttpClient> =>\n  Effect.map(HttpClient.HttpClient.asEffect(), (client) => {\n    const streamNative: ResponsesService[\"streamNative\"] = (request) =>\n      buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client))\n    return {\n      streamNative,\n      streamTurn: (request) => toCanonical(streamNative(request)),\n      toCanonical,\n    }\n  })\n\n/**\n * Layer that registers both the provider-specific `Responses` tag and the\n * generic `LanguageModel` tag, sharing one underlying implementation.\n *\n * The generic tag accepts `CommonRequest`; the typed tag accepts the full\n * `ResponsesRequest` surface.\n */\nexport const layer = (\n  cfg: Config,\n): Layer.Layer<Responses | LanguageModel, never, HttpClient.HttpClient> => {\n  const typed = Layer.effect(Responses, make(cfg))\n  const generic = Layer.effect(\n    LanguageModel,\n    Effect.map(\n      make(cfg),\n      (s): LanguageModelService => ({\n        streamTurn: (request) => s.streamTurn(request as ResponsesRequest),\n      }),\n    ),\n  )\n  return Layer.merge(typed, generic)\n}\n"],"mappings":"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"}