tardie 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "A durable agent harness. State is a pure function of the log.",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "tardigrade": {
-    "sourceTree": "08d69b6ce9e98f53871766428cc614668c943eec"
+    "sourceTree": "8db5a667a08511b951c0a6e341f585b76e77fb65"
   },
   "files": [
     "src",
@@ -71,19 +71,35 @@
     "./model/*": "./src/model/*.ts"
   },
   "dependencies": {
-    "@aws-sdk/client-bedrock-runtime": "^3.1079.0",
     "@cfworker/json-schema": "^4.1.1",
     "@effect/platform-bun": "4.0.0-rc.110",
     "@effect/platform-node-shared": "4.0.0-rc.110",
     "@effect/sql-sqlite-bun": "4.0.0-rc.110",
     "@effect/sql-sqlite-do": "4.0.0-rc.110",
-    "@smithy/fetch-http-handler": "^5.6.3",
-    "@smithy/node-http-handler": "^4.11.2",
     "@tanstack/ai": "0.46.0",
     "@tanstack/ai-anthropic": "0.16.6",
-    "@tanstack/ai-bedrock": "0.2.3",
     "@tanstack/ai-openai": "0.20.0",
     "effect": "4.0.0-rc.110",
     "jsonc-parser": "3.3.1"
+  },
+  "peerDependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.1079.0",
+    "@smithy/fetch-http-handler": "^5.6.3",
+    "@smithy/node-http-handler": "^4.11.2",
+    "@tanstack/ai-bedrock": "0.2.3"
+  },
+  "peerDependenciesMeta": {
+    "@aws-sdk/client-bedrock-runtime": {
+      "optional": true
+    },
+    "@smithy/fetch-http-handler": {
+      "optional": true
+    },
+    "@smithy/node-http-handler": {
+      "optional": true
+    },
+    "@tanstack/ai-bedrock": {
+      "optional": true
+    }
   }
 }

package/src/agent/components/compaction.ts

@@ -1,5 +1,5 @@
 import { Clock, Effect } from "effect"
-import { effect, type Reactor } from "tardie/core/reconciliation"
+import { effect, Self, type Reactor } from "tardie/core/reconciliation"
 import { compactionCompleted } from "../log/events"
 import type { Event } from "tardie/core/log/event"
 import { turnOf, turnView } from "tardie/code/execution/turns"
@@ -346,7 +346,7 @@ const firedUncovered = (log: ReadonlyArray<Event>): boolean => {
 //
 // The policy this takes must be the one the render takes, or the guard measures a request the
 // model never sees (ContextPolicy above).
-export const compactionReactor = (policy: Partial<CompactionPolicy> = {}): Reactor<Infer> => (log) => {
+export const compactionReactor = (policy: Partial<CompactionPolicy> = {}): Reactor<Infer | Self> => (log) => {
   const model = modelResolutionOf(log).model
   const resolved = contextPolicyFrom(log, policy)
   // The projection runs first, so the guard, the cut, and the brief all read the history the
@@ -371,6 +371,7 @@ export const compactionReactor = (policy: Partial<CompactionPolicy> = {}): React
       },
       act: (input) =>
         Effect.gen(function* () {
+          const self = yield* Self
           const at = yield* Clock.currentTimeMillis
           const lines = input.span.map((e) => lineOf(e, resolved)).filter((l): l is string => l !== null)
           if (lines.length === 0) {
@@ -392,6 +393,7 @@ export const compactionReactor = (policy: Partial<CompactionPolicy> = {}): React
           const action = yield* (yield* Infer).react(
             {
               trajectory: [{ type: "MessageReceived", id: `compact-${input.keepFrom}`, text: brief, at }],
+              identity: { ...self, turn: `compact-${input.keepFrom}` },
               ...(model === undefined ? {} : { model }),
               system: "",
               tools: []
@@ -414,7 +416,7 @@ export const compactionReactor = (policy: Partial<CompactionPolicy> = {}): React
 
 // compaction derives one resolved context contribution and the transitions governed by the same
 // model-relative policy.
-export const compaction = (policy: Partial<CompactionPolicy> = {}): AgentComponent<Infer> => {
+export const compaction = (policy: Partial<CompactionPolicy> = {}): AgentComponent<Infer | Self> => {
   const reactor = compactionReactor(policy)
   return {
     name: "compaction",

package/src/agent/index.ts

@@ -36,6 +36,13 @@ export {
   type Render
 } from "./inference/reactor"
 export { ModelRef, modelRefOf } from "./inference/reference"
+export {
+  DEFAULT_INFERENCE_OBSERVER_POLICY,
+  type InferDelta,
+  type InferenceIdentity,
+  type InferenceObserver,
+  type InferenceObserverPolicy
+} from "./inference/observer"
 export {
   applyModelPolicy,
   DEFAULT_MODEL_POLICY,

package/src/agent/inference/observer.ts

@@ -0,0 +1,37 @@
+import type { Effect } from "effect"
+import type { ModelRef } from "./reference"
+
+// InferenceIdentity identifies the actor turn that opened a logical model attempt (index.test.ts, "root and child inference requests carry their actor identity").
+export interface InferenceIdentity {
+  readonly actor: string
+  readonly thread: string
+  readonly turn: string
+}
+
+// InferDelta is ephemeral normalized text from one physical provider request. Sequence is zero-based within that request, so a consumer can detect a dropped delta (model.test.ts, "observes normalized text without changing the terminal action").
+export interface InferDelta extends InferenceIdentity {
+  readonly logicalAttempt: string
+  readonly physicalAttempt: string
+  readonly model: ModelRef
+  readonly blockIndex: number
+  readonly sequence: number
+  readonly text: string
+}
+
+// InferenceObserver receives ephemeral output outside the durable log. Failure and timeout discard that delivery without changing inference (model.test.ts, "observer failure and saturation leave inference unchanged").
+export interface InferenceObserver {
+  readonly onDelta: (delta: InferDelta) => Effect.Effect<void, Error>
+  readonly policy?: Partial<InferenceObserverPolicy>
+}
+
+// InferenceObserverPolicy bounds pending deliveries and each observer call.
+export interface InferenceObserverPolicy {
+  readonly bufferCapacity: number
+  readonly deliveryTimeoutMs: number
+}
+
+// DEFAULT_INFERENCE_OBSERVER_POLICY bounds best-effort delivery while each observer may override both fields.
+export const DEFAULT_INFERENCE_OBSERVER_POLICY: InferenceObserverPolicy = {
+  bufferCapacity: 64,
+  deliveryTimeoutMs: 100
+}

package/src/agent/inference/reactor.ts

@@ -1,6 +1,6 @@
 import { Cause, Clock, Context, Effect } from "effect"
 import { EventLog } from "tardie/core/log"
-import { intent, effect, type Reactor } from "tardie/core/reconciliation"
+import { intent, effect, Self, type Reactor } from "tardie/core/reconciliation"
 import { modelCalled, modelResolved, outputRejected, textReturned, turnFailed } from "../log/events"
 import type { Event } from "tardie/core/log/event"
 import type { Action } from "../log/events"
@@ -28,6 +28,7 @@ import {
   type ModelPolicy,
   type ModelPolicyOverride
 } from "./access"
+import type { InferenceIdentity } from "./observer"
 
 // The infer reactor: the model loop, and nothing else. A think is owed when the current turn
 // has no unanswered tool call and no terminal; serving marks the attempt, does inference, then
@@ -51,6 +52,7 @@ export const DEFAULT_INFER_POLICY: InferPolicy = { giveUpAfter: 3, models: DEFAU
 // about tools; the actor is the render's one owner.
 export interface InferRequest {
   readonly trajectory: ReadonlyArray<Event>
+  readonly identity: InferenceIdentity
   readonly model?: ModelRef
   readonly system: string
   readonly tools: ReadonlyArray<import("./request").ToolSpec>
@@ -318,7 +320,7 @@ export type Render = (log: ReadonlyArray<Event>) => {
   readonly output?: { readonly fallback: OutputFallback; readonly system?: string }
 }
 
-export const inferReactorFor = (policy: Partial<InferPolicy>, render: Render): Reactor<Infer | EventLog> => (log) => {
+export const inferReactorFor = (policy: Partial<InferPolicy>, render: Render): Reactor<Infer | EventLog | Self> => (log) => {
   const giveUpAfter = policy.giveUpAfter ?? DEFAULT_INFER_POLICY.giveUpAfter
   const slice = turnView(log)
   if (slice.length === 0 || awaitingTool(slice) || terminated(slice)) return []
@@ -514,6 +516,7 @@ export const inferReactorFor = (policy: Partial<InferPolicy>, render: Render): R
       act: (input) =>
         Effect.gen(function* () {
           const events = yield* EventLog
+          const self = yield* Self
           const at = yield* Clock.currentTimeMillis
           // The mark records the attempt BEFORE the inference, appended by the act itself: a
           // died attempt leaves its mark, the next derivation counts it, the bound holds.
@@ -531,7 +534,12 @@ export const inferReactorFor = (policy: Partial<InferPolicy>, render: Render): R
             })
           ])
           const action = yield* (yield* Infer)
-            .react({ trajectory: input.trajectory, ...(input.model === undefined ? {} : { model: input.model }), ...input.render }, input.attempt)
+            .react({
+              trajectory: input.trajectory,
+              identity: { ...self, turn: input.turn },
+              ...(input.model === undefined ? {} : { model: input.model }),
+              ...input.render
+            }, input.attempt)
             .pipe(
               Effect.catchCause((cause) =>
                 Cause.hasInterruptsOnly(cause)

package/src/cli/commands.ts

@@ -415,7 +415,8 @@ export const initCommand = Command.make("init", {
     const initialized = yield* Effect.tryPromise({
       try: () => initActor(name, {
         cwd: cli.cwd,
-        ...(directory === undefined ? {} : { directory })
+        ...(directory === undefined ? {} : { directory }),
+        modelProtocol: answers.protocol
       }),
       catch: userErrorOf
     })

package/src/cli/init.ts

@@ -1,6 +1,7 @@
 import { mkdir, rm, writeFile } from "node:fs/promises"
 import { relative, resolve } from "node:path"
 import { DEFAULT_PROJECT_CONFIG_PATH } from "tardie/server/config"
+import type { ModelProtocol } from "tardie/model/directory"
 
 import { CELLD_PROJECT_CONFIG_PATH, celldConfigOf } from "./celld"
 import { actorTemplate } from "./template"
@@ -18,6 +19,7 @@ export interface InitActorOptions {
   readonly directory?: string
   readonly now?: Date
   readonly packageVersion?: string
+  readonly modelProtocol?: ModelProtocol
 }
 
 export interface InitializedActor {
@@ -57,12 +59,31 @@ const manifestTemplate = (name: string, now: Date): string => `${JSON.stringify(
   }
 }, undefined, 2)}\n`
 
-const workerTemplate = `import definition from "./actor"
+const adapterFor = (protocol: ModelProtocol): { readonly name: string; readonly source: string } => {
+  switch (protocol) {
+    case "anthropic-messages":
+      return { name: "anthropicAdapter", source: "tardie/model/anthropic" }
+    case "bedrock-converse":
+      return { name: "bedrockAdapter", source: "tardie/model/bedrock" }
+    case "openai-responses":
+    case "openai-chat-completions":
+      return { name: "openAICompatibleAdapter", source: "tardie/model/openai" }
+  }
+}
+
+const workerTemplate = (protocol: ModelProtocol): string => {
+  const adapter = adapterFor(protocol)
+  return `import definition from "./actor"
 import { ActorHost, cloudflareWorker } from "tardie/cloudflare"
+import { modelAdapters } from "tardie/model/adapter"
+import { ${adapter.name} } from "${adapter.source}"
 
 export { ActorHost }
-export default cloudflareWorker(definition)
+export default cloudflareWorker(definition, {
+  modelAdapters: modelAdapters(${adapter.name})
+})
 `
+}
 
 const packageTemplate = (version: string): string => `${JSON.stringify({
   private: true,
@@ -88,7 +109,7 @@ export const initActor = async (name: string, options: InitActorOptions): Promis
 
   try {
     await writeFile(entry, source, "utf8")
-    await writeFile(worker, workerTemplate, "utf8")
+    await writeFile(worker, workerTemplate(options.modelProtocol ?? "openai-chat-completions"), "utf8")
     await writeFile(manifest, manifestSource, "utf8")
     await writeFile(celldManifest, celldConfigOf(manifestSource, manifest).source, "utf8")
     await writeFile(packageManifest, packageTemplate(packageVersion), "utf8")

package/src/cloudflare/worker.ts

@@ -1,7 +1,7 @@
 import { DurableObject } from "cloudflare:workers"
 import { Clock, Context, Effect, Layer, Schema } from "effect"
 import { FetchHttpClient, HttpClient, HttpEffect, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import { actor, agentMethods, agentsPackage, applyModelPolicy, budget, codeMode, compaction, fetchPackage, Infer, infer as inferAgent, intersectModelPolicies, modelAllowedBy, outputValidateOnce, workspacePackage, type Actor, type ActorMethods, type ModelPolicy, type ModelRef } from "tardie"
+import { actor, agentMethods, agentsPackage, applyModelPolicy, budget, codeMode, compaction, fetchPackage, Infer, infer as inferAgent, intersectModelPolicies, modelAllowedBy, outputValidateOnce, workspacePackage, type Actor, type ActorMethods, type InferenceObserver, type ModelPolicy, type ModelRef } from "tardie"
 import type { Action } from "tardie/log/events"
 import {
   CATALOG_AVAILABILITY_FILTERS,
@@ -10,6 +10,10 @@ import {
   MODEL_CATALOG_UNPRICED_ORDERS
 } from "tardie/client/contract"
 import { infer } from "tardie/model/model"
+import {
+  modelAdapters,
+  type ModelAdapterRegistry
+} from "tardie/model/adapter"
 import { DEFAULT_MODEL_CATALOG_URL } from "tardie/model/metadata"
 import {
   loadModelCatalog,
@@ -79,6 +83,8 @@ interface MountedActor {
   readonly name: string
   readonly actor: DefaultAssembly
   readonly methods: ActorMethods
+  readonly modelAdapters: ModelAdapterRegistry
+  readonly inferenceObserverFor?: (context: CloudflareWorkerLayerContext<Env>) => InferenceObserver
   readonly layersFor?: (context: CloudflareWorkerLayerContext<Env>) => CloudflareLaneEnv<never>
 }
 
@@ -182,7 +188,12 @@ const selectedModelFrom = (
   return { reference: selected, provider, metadata: model.metadata, contextWindowTokens, catalogRevision: catalog.snapshot.revision }
 }
 
-const modelLayer = (models: CloudflareModels | undefined, catalog: ModelCatalogState) => {
+const modelLayer = (
+  models: CloudflareModels | undefined,
+  catalog: ModelCatalogState,
+  adapters: ModelAdapterRegistry,
+  observer?: InferenceObserver
+) => {
   if (models === undefined) {
     const failed: Action = { kind: "fail", error: "no model is configured", failure: { cause: "inference_error", attempts: 1 } }
     return Layer.succeed(Infer)({
@@ -226,7 +237,7 @@ const modelLayer = (models: CloudflareModels | undefined, catalog: ModelCatalogS
         contextWindowTokens: selectedModel.contextWindowTokens,
         ...(selectedModel.metadata.maxOutputTokens === undefined ? {} : { maxOutputTokens: selectedModel.metadata.maxOutputTokens }),
         ...(selectedModel.metadata.pricing === undefined ? {} : { pricing: selectedModel.metadata.pricing })
-      })
+      }, adapters, observer === undefined ? {} : { observer })
       return Effect.flatMap(Infer, (model) => model.react(request, key)).pipe(Effect.provide(selected))
     }
   })
@@ -396,6 +407,8 @@ export class ActorHost extends DurableObject<Env> {
 
   private async openHost(): Promise<CloudflareHost> {
     const models = modelsFrom(this.env)
+    const adapters = mountedActor?.modelAdapters ?? modelAdapters()
+    for (const provider of Object.values(models?.providers ?? {})) adapters.resolve(provider.protocol)
     const catalog: ModelCatalogState = models === undefined
       ? { refreshError: "no model is configured" }
       : await this.catalog()
@@ -462,7 +475,8 @@ export class ActorHost extends DurableObject<Env> {
       principal,
       actorFor: (lane) => threadOf(lane) === undefined ? undefined : selectedAssembly,
       layersFor: (lane) => {
-        const framework = Layer.mergeAll(modelLayer(models, catalog), FetchHttpClient.layer, sandboxLayer)
+        const observer = mountedActor?.inferenceObserverFor?.({ env: this.env, lane })
+        const framework = Layer.mergeAll(modelLayer(models, catalog, adapters, observer), FetchHttpClient.layer, sandboxLayer)
         const application = mountedActor?.layersFor?.({ env: this.env, lane })
         return application === undefined ? framework : Layer.mergeAll(framework, application)
       },
@@ -846,8 +860,16 @@ type CloudflareWorkerLayersFor<R, WorkerEnv extends Env> = (
 // CloudflareWorkerOptions supplies every actor requirement the Worker does not bind itself.
 export type CloudflareWorkerOptions<R, WorkerEnv extends Env = Env> =
   [CloudflareApplicationRequirements<R>] extends [never]
-    ? { readonly layersFor?: CloudflareWorkerLayersFor<R, WorkerEnv> }
-    : { readonly layersFor: CloudflareWorkerLayersFor<R, WorkerEnv> }
+    ? {
+        readonly layersFor?: CloudflareWorkerLayersFor<R, WorkerEnv>
+        readonly modelAdapters?: ModelAdapterRegistry
+        readonly inferenceObserverFor?: (context: CloudflareWorkerLayerContext<WorkerEnv>) => InferenceObserver
+      }
+    : {
+        readonly layersFor: CloudflareWorkerLayersFor<R, WorkerEnv>
+        readonly modelAdapters?: ModelAdapterRegistry
+        readonly inferenceObserverFor?: (context: CloudflareWorkerLayerContext<WorkerEnv>) => InferenceObserver
+      }
 
 type CloudflareWorkerArguments<R, WorkerEnv extends Env> =
   [CloudflareApplicationRequirements<R>] extends [never]
@@ -867,6 +889,10 @@ export const cloudflareWorker = <
     name: definition.name,
     actor: definition as unknown as DefaultAssembly,
     methods: definition.methods,
+    modelAdapters: options?.modelAdapters ?? modelAdapters(),
+    ...(options?.inferenceObserverFor === undefined ? {} : {
+      inferenceObserverFor: options.inferenceObserverFor as unknown as (context: CloudflareWorkerLayerContext<Env>) => InferenceObserver
+    }),
     ...(options?.layersFor === undefined ? {} : {
       layersFor: options.layersFor as unknown as (context: CloudflareWorkerLayerContext<Env>) => CloudflareLaneEnv<never>
     })

package/src/model/adapter.ts

@@ -0,0 +1,104 @@
+import type { ModelMessage, StreamChunk, Tool } from "@tanstack/ai"
+import type { ModelRequest } from "tardie/inference/request"
+import type { OutputMode } from "tardie/output/contract"
+import type { ModelPricing } from "tardie/inference/usage"
+import type { ModelProtocol } from "./directory"
+import type { OutputCapability } from "./output"
+
+export interface StreamBounds {
+  readonly firstChunkMs: number
+  readonly idleMs: number
+  readonly totalMs: number
+}
+
+export type ModelFetch = (
+  input: Parameters<typeof globalThis.fetch>[0],
+  init?: Parameters<typeof globalThis.fetch>[1]
+) => Promise<Response>
+
+export interface ModelConfig {
+  readonly baseUrl: string
+  readonly apiKey: string
+  readonly model: string
+  readonly protocol: ModelProtocol
+  readonly provider: string
+  // region selects the AWS region for a Bedrock Converse connection.
+  readonly region?: string
+  readonly contextWindowTokens: number
+  // maxOutputTokens caps every truncation-ladder rung; an omitted value uses the exported ladder.
+  readonly maxOutputTokens?: number
+  // maxTokensLadder replaces the exported truncation ladder before maxOutputTokens bounds it.
+  readonly maxTokensLadder?: ReadonlyArray<number>
+  // stream replaces any stated fields in DEFAULT_STREAM_BOUNDS.
+  readonly stream?: Partial<StreamBounds>
+  // output states the endpoint guarantee; an omitted value promises no native contract support.
+  readonly output?: OutputCapability
+  // pricing supplies the estimate used when the provider reports tokens without a billed cost.
+  readonly pricing?: ModelPricing
+  // throttleRetryDelaysMs sets the backoff bases and its length sets the retry count.
+  readonly throttleRetryDelaysMs?: ReadonlyArray<number>
+  // retryAfterJitterMs adds a random wait to a provider Retry-After value.
+  readonly retryAfterJitterMs?: number
+  // fetch replaces the transport for an embedding or test.
+  readonly fetch?: ModelFetch
+  // sleep replaces the retry wait for an embedding or test.
+  readonly sleep?: (ms: number) => Promise<void>
+}
+
+export type ModelStopClass = "refused" | "truncated" | "violation" | "ok"
+
+export interface ModelAdapterContext {
+  readonly config: ModelConfig
+  readonly request: ModelRequest
+  readonly mode: OutputMode
+  readonly maxTokens: number
+  readonly bounds: StreamBounds
+  readonly fetch: ModelFetch
+  readonly messages: ReadonlyArray<ModelMessage>
+  readonly tools: ReadonlyArray<Tool>
+  readonly systemPrompts: ReadonlyArray<string>
+}
+
+export interface ModelAdapterAttempt {
+  readonly stream: AsyncIterable<StreamChunk>
+  readonly reportedUsage?: () => unknown
+  readonly stopClass?: () => ModelStopClass
+  readonly finishReason?: () => string | undefined
+}
+
+export interface ModelAdapter {
+  readonly id: string
+  // ModelAdapter protocols select wire implementations independently of provider and model identity (adapter.test.ts, "resolves each protocol to its registered implementation").
+  readonly protocols: ReadonlyArray<ModelProtocol>
+  readonly start: (context: ModelAdapterContext) => ModelAdapterAttempt
+}
+
+export interface ModelAdapterRegistry {
+  readonly protocols: ReadonlyArray<ModelProtocol>
+  readonly resolve: (protocol: ModelProtocol) => ModelAdapter
+}
+
+// modelAdapters constructs an immutable protocol registry and rejects ambiguous implementations.
+export const modelAdapters = (...adapters: ReadonlyArray<ModelAdapter>): ModelAdapterRegistry => {
+  const byProtocol = new Map<ModelProtocol, ModelAdapter>()
+  for (const adapter of adapters) {
+    for (const protocol of adapter.protocols) {
+      const previous = byProtocol.get(protocol)
+      if (previous !== undefined) {
+        throw new Error(`model protocol ${JSON.stringify(protocol)} has adapters ${JSON.stringify(previous.id)} and ${JSON.stringify(adapter.id)}`)
+      }
+      byProtocol.set(protocol, adapter)
+    }
+  }
+  const protocols = Object.freeze([...byProtocol.keys()])
+  return Object.freeze({
+    protocols,
+    resolve: (protocol: ModelProtocol): ModelAdapter => {
+      const adapter = byProtocol.get(protocol)
+      if (adapter !== undefined) return adapter
+      throw new Error(
+        `model protocol ${JSON.stringify(protocol)} has no registered adapter; register one with modelAdapters(...) before starting the host`
+      )
+    }
+  })
+}

package/src/model/anthropic.ts

@@ -0,0 +1,29 @@
+import { createAnthropicChat } from "@tanstack/ai-anthropic"
+import { outputSchemaFor } from "./output"
+import type { ModelAdapter } from "./adapter"
+
+// anthropicAdapter binds the Anthropic Messages protocol through TanStack AI.
+export const anthropicAdapter: ModelAdapter = {
+  id: "tanstack/anthropic",
+  protocols: ["anthropic-messages"],
+  start: ({ config, request, mode, fetch, messages, tools, systemPrompts }) => {
+    const outputSchema = request.output?.kind === "contract" && mode.kind === "native"
+      ? outputSchemaFor(request.output, mode)
+      : undefined
+    const adapter = createAnthropicChat(config.model as never, config.apiKey, {
+      baseURL: config.baseUrl,
+      maxRetries: 0,
+      fetch
+    })
+    return {
+      stream: adapter.chatStream({
+        model: config.model,
+        messages: messages as never,
+        tools: tools as never,
+        systemPrompts,
+        ...(outputSchema === undefined ? {} : { outputSchema }),
+        logger: new Proxy({}, { get: () => () => {} }) as never
+      } as never)
+    }
+  }
+}

package/src/model/bedrock.ts

@@ -0,0 +1,158 @@
+import * as BedrockRuntime from "@aws-sdk/client-bedrock-runtime"
+import { FetchHttpHandler } from "@smithy/fetch-http-handler"
+import { BedrockConverseTextAdapter, type BEDROCK_CONVERSE_MODELS } from "@tanstack/ai-bedrock"
+import type { OutputRequest } from "tardie/inference/request"
+import { NATIVE_MODE, type OutputMode } from "tardie/output/contract"
+import { outputNameFor, outputSchemaFor } from "./output"
+import type { ModelAdapter, ModelConfig, ModelStopClass, StreamBounds } from "./adapter"
+
+type SmithyHandler = Pick<FetchHttpHandler, "handle" | "destroy">
+
+const bedrockHandler = (config: ModelConfig, bounds: StreamBounds): SmithyHandler => {
+  const transport: Promise<SmithyHandler> =
+    (globalThis as { Bun?: unknown }).Bun === undefined
+      ? Promise.resolve(new FetchHttpHandler({ requestTimeout: bounds.totalMs }))
+      : (() => {
+          const moduleName = "@smithy/node-http-handler"
+          return (import(/* @vite-ignore */ moduleName) as Promise<typeof import("@smithy/node-http-handler")>).then(
+            ({ NodeHttpHandler: Handler }) =>
+              new Handler({
+                connectionTimeout: bounds.firstChunkMs,
+                socketTimeout: bounds.idleMs,
+                requestTimeout: bounds.totalMs,
+                throwOnRequestTimeout: true
+              })
+          )
+        })()
+
+  return {
+    handle: async (request, handlerOptions) => {
+      request.headers = Object.fromEntries(
+        Object.entries(request.headers).filter(([key]) => key.toLowerCase() !== "authorization")
+      )
+      request.headers["cf-aig-authorization"] = `Bearer ${config.apiKey}`
+      return (await transport).handle(request, handlerOptions)
+    },
+    destroy: () => {
+      void transport.then((handler) => handler.destroy()).catch(() => undefined)
+    }
+  }
+}
+
+export const converseOutputConfig = (
+  output: OutputRequest,
+  mode: OutputMode
+): BedrockRuntime.OutputConfig | undefined => {
+  const schema = outputSchemaFor(output, mode)
+  const name = outputNameFor(output, mode)
+  if (schema === undefined || name === undefined) return undefined
+  return { textFormat: { type: "json_schema", structure: { jsonSchema: { name, schema: JSON.stringify(schema) } } } }
+}
+
+export const converseStopClass = (stopReason: string | undefined): ModelStopClass => {
+  switch (stopReason) {
+    case "guardrail_intervened":
+    case "content_filtered":
+      return "refused"
+    case "max_tokens":
+    case "model_context_window_exceeded":
+      return "truncated"
+    case "malformed_model_output":
+      return "violation"
+    default:
+      return "ok"
+  }
+}
+
+export const tapStopReason = <T>(
+  stream: AsyncIterable<T>,
+  into: { stopReason?: string }
+): AsyncIterable<T> => ({
+  async *[Symbol.asyncIterator]() {
+    for await (const event of stream) {
+      const stop = (event as { messageStop?: { stopReason?: unknown } }).messageStop?.stopReason
+      if (typeof stop === "string") into.stopReason = stop
+      yield event
+    }
+  }
+})
+
+export const tapConverseUsage = <T>(
+  stream: AsyncIterable<T>,
+  into: { usage?: unknown }
+): AsyncIterable<T> => ({
+  async *[Symbol.asyncIterator]() {
+    for await (const event of stream) {
+      const usage = (event as { metadata?: { usage?: unknown } }).metadata?.usage
+      if (usage !== undefined) into.usage = usage
+      yield event
+    }
+  }
+})
+
+export const bedrockConverseTextAdapter = (
+  config: ModelConfig,
+  maxTokens: number,
+  bounds: StreamBounds,
+  output?: OutputRequest,
+  mode: OutputMode = NATIVE_MODE,
+  stops: { stopReason?: string } = {},
+  reported: { usage?: unknown } = {}
+) => {
+  const handler = bedrockHandler(config, bounds)
+  const region = config.region ?? config.baseUrl.split("/").filter((s) => s !== "").at(-1)
+  if (region === undefined) throw new Error("a Bedrock connection must declare its AWS region")
+  return new (class extends BedrockConverseTextAdapter<(typeof BEDROCK_CONVERSE_MODELS)[number]> {
+    protected override importBedrockRuntime(): Promise<typeof BedrockRuntime> {
+      return Promise.resolve(BedrockRuntime)
+    }
+    protected override buildClientConfig(
+      resolved: Parameters<BedrockConverseTextAdapter<(typeof BEDROCK_CONVERSE_MODELS)[number]>["buildClientConfig"]>[0],
+      resolvedRegion: string,
+      endpoint: string | undefined
+    ) {
+      return { ...super.buildClientConfig(resolved, resolvedRegion, endpoint), requestHandler: handler, maxAttempts: 1 }
+    }
+    public override buildInput(options: Parameters<BedrockConverseTextAdapter<(typeof BEDROCK_CONVERSE_MODELS)[number]>["buildInput"]>[0]) {
+      const input = super.buildInput(options) as BedrockRuntime.ConverseStreamCommandInput
+      input.inferenceConfig = { ...input.inferenceConfig, maxTokens }
+      const outputConfig = output === undefined ? undefined : converseOutputConfig(output, mode)
+      if (outputConfig !== undefined) input.outputConfig = { ...input.outputConfig, ...outputConfig }
+      return input
+    }
+    protected override async sendStream(input: BedrockRuntime.ConverseStreamCommandInput) {
+      const stream = await super.sendStream(input)
+      return tapStopReason(tapConverseUsage(stream, reported), stops)
+    }
+  })({ apiKey: "byok", region, baseURL: config.baseUrl }, config.model as (typeof BEDROCK_CONVERSE_MODELS)[number])
+}
+
+// bedrockAdapter binds the Bedrock Converse protocol through the AWS and TanStack adapters.
+export const bedrockAdapter: ModelAdapter = {
+  id: "tanstack/bedrock-converse",
+  protocols: ["bedrock-converse"],
+  start: ({ config, request, mode, maxTokens, bounds, messages, tools, systemPrompts }) => {
+    const stops: { stopReason?: string } = {}
+    const reported: { usage?: unknown } = {}
+    const adapter = bedrockConverseTextAdapter(config, maxTokens, bounds, request.output, mode, stops, reported)
+    return {
+      stream: adapter.chatStream({
+        model: config.model,
+        messages: messages as never,
+        tools: tools as never,
+        systemPrompts,
+        modelOptions: { max_tokens: maxTokens } as never,
+        logger: new Proxy({}, { get: () => () => {} }) as never
+      } as never),
+      reportedUsage: () => reported.usage,
+      stopClass: () => converseStopClass(stops.stopReason),
+      finishReason: () => stops.stopReason
+    }
+  }
+}
+
+// bedrockAdapterForBun verifies the Bun transport dependency before the host accepts Bedrock configuration.
+export const bedrockAdapterForBun = async (): Promise<ModelAdapter> => {
+  await import("@smithy/node-http-handler")
+  return bedrockAdapter
+}