feat(routing): add organization routes to model selectors

packages/ai/src/protocols/open-responses.ts

@@ -86,6 +86,7 @@ export const OpenResponsesReasoningItem = Schema.Struct({
   id: Schema.optionalKey(Schema.String),
   summary: Schema.Array(OpenResponsesReasoningSummaryText),
   encrypted_content: optionalNull(Schema.String),
+  provider_metadata: Schema.optional(JsonObject),
 })
 
 const OpenResponsesWebSearchCall = Schema.StructWithRest(
@@ -182,6 +183,7 @@ export const InputItem = Schema.Union([
     content: Schema.Array(OpenResponsesOutputText),
     phase: Schema.optionalKey(MessagePhase),
     status: Schema.optional(Schema.String),
+    provider_metadata: Schema.optional(JsonObject),
   }),
   OpenResponsesReasoningItem,
   Schema.Struct({
@@ -191,6 +193,7 @@ export const InputItem = Schema.Union([
     name: Schema.String,
     namespace: Schema.optional(Schema.String),
     arguments: Schema.String,
+    provider_metadata: Schema.optional(JsonObject),
   }),
   Schema.Struct({
     type: Schema.tag("function_call_output"),
@@ -223,6 +226,7 @@ type OpenResponsesReasoningInput = {
   id?: string
   summary: Array<{ type: "summary_text"; text: string }>
   encrypted_content?: string | null
+  provider_metadata?: Record<string, unknown>
 }
 export const Tool = Schema.Struct({
   type: Schema.tag("function"),
@@ -436,6 +440,8 @@ export const decodeChannelEvent = (frame: string) =>
 export interface ProviderAdapter {
   readonly id: string
   readonly name: string
+  /** Replay opaque gateway continuation state only for adapters that own this extension. */
+  readonly preserveProviderMetadata?: boolean
   readonly nativeTool?: (
     native: NonNullable<ToolDefinition["native"]>,
   ) => Effect.Effect<{ readonly type: string }, AIError>
@@ -455,6 +461,7 @@ export interface ParserState {
   readonly id: string
   readonly name: string
   readonly providerMetadataKey: string
+  readonly preserveProviderMetadata: boolean
   readonly tools: ToolStream.State<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
@@ -514,7 +521,16 @@ const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadata
   return separator > 0 && separator < metadata.itemId.length - 1 ? metadata.itemId : undefined
 }
 
-const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
+const replayProviderMetadata = (metadata: ProviderMetadata | undefined, key: string, adapter: ProviderAdapter) => {
+  const value = metadata?.[key]?.providerMetadata
+  return adapter.preserveProviderMetadata && ProviderShared.isRecord(value) ? { provider_metadata: value } : {}
+}
+
+const lowerToolCall = (
+  part: ToolCallPart,
+  providerMetadataKey: string,
+  adapter: ProviderAdapter,
+): OpenResponsesInputItem => {
   const id = itemID(part.providerMetadata, providerMetadataKey)
   return {
     type: "function_call",
@@ -523,10 +539,15 @@ const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenRes
     name: part.name,
     namespace: part.namespace,
     arguments: ProviderShared.encodeJson(part.input),
+    ...replayProviderMetadata(part.providerMetadata, providerMetadataKey, adapter),
   }
 }
 
-const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
+const lowerReasoning = (
+  part: ReasoningPart,
+  providerMetadataKey: string,
+  adapter: ProviderAdapter,
+): OpenResponsesReasoningInput | undefined => {
   const metadata = part.providerMetadata?.[providerMetadataKey]
   if (!ProviderShared.isRecord(metadata)) return undefined
   const id = itemID(part.providerMetadata, providerMetadataKey)
@@ -539,6 +560,7 @@ const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenR
     ...(id === undefined ? {} : { id }),
     summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
     encrypted_content: encryptedContent,
+    ...replayProviderMetadata(part.providerMetadata, providerMetadataKey, adapter),
   }
 }
 
@@ -687,6 +709,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
             status: "completed",
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
+            ...replayProviderMetadata(group.parts.at(-1)?.providerMetadata, providerMetadataKey, adapter),
           })),
         )
         content.splice(0, content.length)
@@ -707,13 +730,14 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         }
         if (part.type === "reasoning") {
           flushText()
-          const reasoning = lowerReasoning(part, providerMetadataKey)
+          const reasoning = lowerReasoning(part, providerMetadataKey, adapter)
           if (!reasoning) continue
           const existing = reasoning.id === undefined ? undefined : reasoningItems[reasoning.id]
           if (existing) {
             existing.summary.push(...reasoning.summary)
             if (typeof reasoning.encrypted_content === "string")
               existing.encrypted_content = reasoning.encrypted_content
+            if (reasoning.provider_metadata !== undefined) existing.provider_metadata = reasoning.provider_metadata
             continue
           }
           if (reasoning.id !== undefined) reasoningItems[reasoning.id] = reasoning
@@ -723,7 +747,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         if (part.type === "tool-call") {
           flushText()
           if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part, providerMetadataKey))
+          input.push(lowerToolCall(part, providerMetadataKey, adapter))
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted === true) {
@@ -1062,8 +1086,17 @@ export const onReasoningDone = (state: ParserState, event: Event, itemID: string
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
 }
 
+const outputMetadata = (state: ParserState, item: OutputItem, extra?: Record<string, unknown>) =>
+  providerMetadata(state, {
+    itemId: item.id,
+    ...extra,
+    ...(state.preserveProviderMetadata && ProviderShared.isRecord(item.provider_metadata)
+      ? { providerMetadata: item.provider_metadata }
+      : {}),
+  })
+
 const reasoningMetadata = (state: ParserState, item: OutputItem) =>
-  providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
+  outputMetadata(state, item, { reasoningEncryptedContent: item.encrypted_content ?? null })
 
 // Responses APIs normally stream reasoning items in this order:
 //   `output_item.added` (reasoning) →
@@ -1126,7 +1159,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
   }
   if (item.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
   if (state.tools[item.id] !== undefined) return [state, NO_EVENTS]
-  const metadata = providerMetadata(state, { itemId: item.id })
+  const metadata = outputMetadata(state, item)
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
   return [
@@ -1249,7 +1282,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
       content.push(decoded.type === "output_text" ? decoded.text : decoded.refusal)
     }
     const text = content.length > 0 ? content.join("") : undefined
-    const metadata = providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })
+    const metadata = outputMetadata(state, item, phase === undefined ? undefined : { phase })
     const events: LLMEvent[] = []
     const lifecycle = text ? Lifecycle.textStart(state.lifecycle, events, item.id, metadata) : state.lifecycle
     return [
@@ -1264,10 +1297,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const metadata = providerMetadata(state, { itemId: item.id })
-    const registered = state.tools[item.id] !== undefined
-    const tools = registered
-      ? state.tools
+    const metadata = outputMetadata(state, item)
+    const pending = state.tools[item.id]
+    const registered = pending !== undefined
+    const tools = pending
+      ? ToolStream.start(state.tools, item.id, { ...pending, providerMetadata: metadata })
       : ToolStream.start(state.tools, item.id, {
           id: item.call_id,
           name: item.name,
@@ -1521,6 +1555,7 @@ export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADA
   id: adapter.id,
   name: adapter.name,
   providerMetadataKey: metadataKey(request.model),
+  preserveProviderMetadata: adapter.preserveProviderMetadata ?? false,
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
   lifecycle: Lifecycle.initial(),

packages/ai/src/protocols/organization-routes.ts

@@ -0,0 +1,72 @@
+import { Effect, Schema } from "effect"
+import { Route } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Protocol } from "../route/protocol.js"
+import { HttpTransport } from "../route/transport/index.js"
+import type { LLMRequest } from "../schema/index.js"
+import { OpenResponses } from "./open-responses.js"
+import { ProviderShared } from "./shared.js"
+
+const ADAPTER = "organization-routes"
+
+const adapter = {
+  id: ADAPTER,
+  name: "Organization routes",
+  preserveProviderMetadata: true,
+} satisfies OpenResponses.ProviderAdapter
+
+const Body = Schema.Struct({
+  ...OpenResponses.coreFields,
+  store: Schema.Literal(false),
+  provider_options: Schema.Struct({
+    "openai-responses": Schema.Struct({ include: Schema.Array(Schema.String) }),
+  }),
+  stream: Schema.Literal(true),
+})
+
+const fromRequest = Effect.fn("OrganizationRoutes.fromRequest")(function* (request: LLMRequest) {
+  const body = yield* OpenResponses.fromRequestWithAdapter(request, adapter)
+  // A route can select another provider on each call. Keep full history and only
+  // portable options; native caching and stored IDs would exclude translated
+  // targets. Scope encrypted reasoning to native Responses targets so their
+  // stateless continuations remain replayable without blocking other protocols.
+  return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+    model: body.model,
+    input: body.input,
+    instructions: body.instructions,
+    tools: body.tools,
+    tool_choice: body.tool_choice,
+    stream: true as const,
+    store: false as const,
+    provider_options: { "openai-responses": { include: ["reasoning.encrypted_content"] } },
+    max_output_tokens:
+      body.max_output_tokens !== undefined && body.max_output_tokens > 0 ? body.max_output_tokens : undefined,
+    temperature: body.temperature,
+    top_p: body.top_p,
+    parallel_tool_calls: body.parallel_tool_calls,
+    metadata: body.metadata,
+    reasoning: body.reasoning?.effort === undefined ? undefined : { effort: body.reasoning.effort },
+    text: body.text,
+  })
+})
+
+export const protocol = Protocol.make({
+  ...OpenResponses.protocol,
+  id: ADAPTER,
+  body: { schema: Body, from: fromRequest },
+  stream: {
+    ...OpenResponses.protocol.stream,
+    initial: (request: LLMRequest) => OpenResponses.initial(request, adapter),
+  },
+})
+
+export const route = Route.make({
+  id: ADAPTER,
+  providerMetadataKey: ADAPTER,
+  protocol,
+  endpoint: Endpoint.path(OpenResponses.PATH),
+  transport: HttpTransport.sseJson.with<typeof Body.Type>(),
+  defaults: { providerOptions: { store: false, include: [] } },
+})
+
+export * as OrganizationRoutes from "./organization-routes.js"

packages/ai/src/providers/organization-routes.ts

@@ -0,0 +1,57 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OrganizationRoutes } from "../protocols/organization-routes.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
+
+export type Options = Pick<
+  OpenResponsesProviderOptionsInput,
+  "reasoningEffort" | "textVerbosity" | "parallelToolCalls" | "metadata" | "allowedTools"
+>
+
+export const id = ProviderID.make("organization-routes")
+
+export type Config = RouteDefaultsInput &
+  ProviderAuthOption<"optional"> & {
+    readonly provider?: string
+    readonly baseURL: string
+    readonly providerOptions?: Options
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL: string
+  readonly provider?: string
+  readonly providerOptions?: Options
+}
+
+export const routes = [OrganizationRoutes.route]
+
+export const configure = (input: Config) => {
+  const provider = input.provider ?? "organization-routes"
+  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
+  const route = OrganizationRoutes.route.with({
+    ...rest,
+    provider,
+    endpoint: { baseURL },
+    auth: AuthOptions.bearer(input, []),
+  })
+  return {
+    id: ProviderID.make(provider),
+    model: (modelID: string | ModelID) => route.model<Options>({ id: modelID }),
+    configure,
+  }
+}
+
+export const provider = { id, configure }
+
+export const model: ProviderPackage.Definition<Settings, Options>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)