@effect-uai/responses 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/responses",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "OpenAI Responses API provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -49,7 +49,7 @@
   "devDependencies": {
     "effect": "4.0.0-beta.57",
     "typescript": "^6.0.3",
-    "@effect-uai/core": "0.5.1"
+    "@effect-uai/core": "0.6.0"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",

package/src/OpenAIEmbedding.ts

@@ -17,6 +17,7 @@ import {
   type EmbedResponse,
 } from "@effect-uai/core/EmbeddingModel"
 import type { OpenAIEmbeddingModel } from "./models.js"
+import { type OpenAiRegion, resolveHost } from "./region.js"
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -56,6 +57,7 @@ export class OpenAIEmbedding extends Context.Service<OpenAIEmbedding, OpenAIEmbe
 export type Config = {
   readonly apiKey: Redacted.Redacted
   readonly baseUrl?: string
+  readonly region?: OpenAiRegion
 }
 
 // ---------------------------------------------------------------------------
@@ -176,15 +178,13 @@ const transportFailure = (cause: unknown): AiError.AiError =>
 // HTTP plumbing
 // ---------------------------------------------------------------------------
 
-const baseUrl = (cfg: Config): string => cfg.baseUrl ?? "https://api.openai.com/v1"
-
 const postEmbed = (
   cfg: Config,
   body: WireBody,
 ): Effect.Effect<typeof WireResponse.Type, AiError.AiError, HttpClient.HttpClient> =>
   Effect.gen(function* () {
     const client = yield* HttpClient.HttpClient
-    const httpRequest = HttpClientRequest.post(`${baseUrl(cfg)}/embeddings`).pipe(
+    const httpRequest = HttpClientRequest.post(`${resolveHost(cfg)}/embeddings`).pipe(
       HttpClientRequest.bearerToken(cfg.apiKey),
       HttpClientRequest.bodyJsonUnsafe(body),
     )

package/src/Responses.ts

@@ -6,11 +6,13 @@ import {
   type CommonRequest,
   LanguageModel,
   type LanguageModelService,
+  turnFromStream,
 } from "@effect-uai/core/LanguageModel"
 import * as SSE from "@effect-uai/core/SSE"
-import type { TurnEvent } from "@effect-uai/core/Turn"
+import type { Turn, TurnEvent } from "@effect-uai/core/Turn"
 import { itemsToInput } from "./codec.js"
 import type { OpenAIModel } from "./models.js"
+import { type OpenAiRegion, resolveHost } from "./region.js"
 import {
   KnownProviderEvent,
   ProviderEvent,
@@ -65,6 +67,12 @@ export type ResponsesService = {
    * `streamNative |> toCanonical`.
    */
   readonly streamTurn: (request: ResponsesRequest) => Stream.Stream<TurnEvent, AiError.AiError>
+  /**
+   * Drain a single turn and return the assembled `Turn`. Derived from
+   * `streamTurn` — Responses doesn't expose a native non-streaming
+   * complete endpoint we'd want to take advantage of.
+   */
+  readonly turn: (request: ResponsesRequest) => Effect.Effect<Turn, AiError.AiError>
   /**
    * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.
    * Exposed for cases where consumers want to compose with `streamNative`
@@ -88,6 +96,7 @@ export class Responses extends Context.Service<Responses, ResponsesService>()(
 export type Config = {
   readonly apiKey: Redacted.Redacted
   readonly baseUrl?: string
+  readonly region?: OpenAiRegion
 }
 
 // ---------------------------------------------------------------------------
@@ -215,7 +224,7 @@ const httpStatusError = (status: number, body: string): AiError.AiError => {
 }
 
 const buildNativeStream = (cfg: Config) => {
-  const url = `${cfg.baseUrl ?? "https://api.openai.com/v1"}/responses`
+  const url = `${resolveHost(cfg)}/responses`
   return (
     request: ResponsesRequest,
   ): Stream.Stream<ProviderEvent, AiError.AiError, HttpClient.HttpClient> =>
@@ -282,9 +291,12 @@ export const make = (cfg: Config): Effect.Effect<ResponsesService, never, HttpCl
   Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
     const streamNative: ResponsesService["streamNative"] = (request) =>
       buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client))
+    const streamTurn: ResponsesService["streamTurn"] = (request) =>
+      toCanonical(streamNative(request))
     return {
       streamNative,
-      streamTurn: (request) => toCanonical(streamNative(request)),
+      streamTurn,
+      turn: turnFromStream(streamTurn),
       toCanonical,
     }
   })
@@ -306,6 +318,7 @@ export const layer = (
       make(cfg),
       (s): LanguageModelService => ({
         streamTurn: (request) => s.streamTurn(request as ResponsesRequest),
+        turn: (request) => s.turn(request as ResponsesRequest),
       }),
     ),
   )

package/src/codec.ts

@@ -1,5 +1,5 @@
 import { Encoding, Match, Option, Schema } from "effect"
-import type { ContentBlock, InputImage, Item } from "@effect-uai/core/Items"
+import type { ContentBlock, InputImage, HistoryItem } from "@effect-uai/core/Items"
 import type { Turn } from "@effect-uai/core/Turn"
 
 // ---------------------------------------------------------------------------
@@ -137,7 +137,7 @@ export type WireResponseCompleted = typeof WireResponseCompleted.Type
  * verbatim - preserves `encrypted_content`, item ids, and any field this
  * codec doesn't model.
  */
-const passthrough = (item: Item): Record<string, unknown> | undefined =>
+const passthrough = (item: HistoryItem): Record<string, unknown> | undefined =>
   item.providerData !== undefined &&
   typeof item.providerData === "object" &&
   item.providerData !== null
@@ -168,7 +168,7 @@ const contentBlockToInput = Match.type<ContentBlock>().pipe(
   }),
 )
 
-const itemToInput = (item: Item): Record<string, unknown> =>
+const itemToInput = (item: HistoryItem): Record<string, unknown> =>
   passthrough(item) ??
   Match.value(item).pipe(
     Match.discriminatorsExhaustive("type")({
@@ -199,9 +199,10 @@ const itemToInput = (item: Item): Record<string, unknown> =>
     }),
   )
 
-/** Convert our `Item[]` history into the Responses API `input` array. */
-export const itemsToInput = (items: ReadonlyArray<Item>): ReadonlyArray<Record<string, unknown>> =>
-  items.map(itemToInput)
+/** Convert our `HistoryItem[]` history into the Responses API `input` array. */
+export const itemsToInput = (
+  items: ReadonlyArray<HistoryItem>,
+): ReadonlyArray<Record<string, unknown>> => items.map(itemToInput)
 
 // ---------------------------------------------------------------------------
 // Wire output items → our Items
@@ -218,7 +219,7 @@ const wireMessageContentToBlock = Match.type<typeof WireMessageContent.Type>().p
   }),
 )
 
-export const wireItemToItem = (wire: WireOutputItem): Item =>
+export const wireItemToItem = (wire: WireOutputItem): HistoryItem =>
   Match.value(wire).pipe(
     Match.discriminatorsExhaustive("type")({
       message: (m) => ({

package/src/index.ts

@@ -3,3 +3,4 @@ export * as OpenAIEmbedding from "./OpenAIEmbedding.js"
 export * as codec from "./codec.js"
 export * as streamEvents from "./streamEvents.js"
 export * from "./models.js"
+export * from "./region.js"

package/src/region.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest"
+import { resolveHost } from "./region.js"
+
+describe("responses/region.resolveHost", () => {
+  it("returns default host when no region or baseUrl", () => {
+    expect(resolveHost({})).toBe("https://api.openai.com/v1")
+  })
+
+  it("returns default host for region 'default'", () => {
+    expect(resolveHost({ region: "default" })).toBe("https://api.openai.com/v1")
+  })
+
+  it("computes EU host for region 'eu'", () => {
+    expect(resolveHost({ region: "eu" })).toBe("https://eu.api.openai.com/v1")
+  })
+
+  it("passes unknown region through as host prefix", () => {
+    expect(resolveHost({ region: "apac" })).toBe("https://apac.api.openai.com/v1")
+  })
+
+  it("baseUrl wins over region", () => {
+    expect(resolveHost({ baseUrl: "http://localhost:8080/v1", region: "eu" })).toBe(
+      "http://localhost:8080/v1",
+    )
+  })
+})

package/src/region.ts

@@ -0,0 +1,29 @@
+/**
+ * OpenAI regional endpoints. `eu.api.openai.com` covers `/v1/responses`
+ * and `/v1/embeddings` (along with the rest of the REST surface) for
+ * projects with EU data residency enabled. Keys are project-scoped.
+ *
+ * Reference: https://developers.openai.com/api/docs/guides/your-data
+ *
+ * Defined locally in this package rather than imported from
+ * `@effect-uai/openai` to keep the packages decoupled.
+ */
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type OpenAiRegion = "default" | "eu" | (string & {})
+
+const DEFAULT_HOST = "https://api.openai.com/v1"
+
+/**
+ * Resolve the HTTP base URL from a Config. `baseUrl` wins when set;
+ * otherwise the host is computed from `region`. Unknown region strings
+ * pass through as `{region}.api.openai.com/v1` for forward compat.
+ */
+export const resolveHost = (cfg: {
+  readonly baseUrl?: string
+  readonly region?: OpenAiRegion
+}): string => {
+  if (cfg.baseUrl !== undefined) return cfg.baseUrl
+  if (cfg.region === undefined || cfg.region === "default") return DEFAULT_HOST
+  return `https://${cfg.region}.api.openai.com/v1`
+}