tardie 0.26.0-rc.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.26.0-rc.0",
+  "version": "0.26.0",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "Actor, agent, client, and host APIs for Tardigrade.",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "tardigrade": {
-    "sourceTree": "bedab20bae90c0fc7522a8ed56b9303298828193"
+    "sourceTree": "055f74c19df551861b617c0df419d9496438966b"
   },
   "files": [
     "src",
@@ -97,8 +97,8 @@
     "./model/metadata": "./src/model/catalog/metadata.ts",
     "./model/directory": "./src/model/providers/directory.ts",
     "./model/reasoning": "./src/model/providers/options.ts",
-    "./model/request-policy": "./src/model/inference/policy.ts",
-    "./model/output": "./src/model/binding/output.ts",
+    "./model/request-policy": "./src/model/stream/policy.ts",
+    "./model/output": "./src/model/output.ts",
     "./model/*": "./src/model/*.ts"
   },
   "dependencies": {
@@ -108,16 +108,17 @@
     "@effect/sql-sqlite-bun": "4.0.0-rc.115",
     "@effect/sql-sqlite-do": "4.0.0-rc.115",
     "@tardie/ai": "0.0.2",
-    "@tardie/ai-anthropic": "4.0.0-rc.113-clavia.1",
-    "@tardie/ai-openai": "4.0.0-rc.113-clavia.2",
-    "@tardie/ai-openai-compat": "4.0.0-rc.113-clavia.1",
+    "@tardie/ai-anthropic": "4.0.0-rc.113-clavia.3",
+    "@tardie/ai-openai": "4.0.0-rc.113-clavia.4",
+    "@tardie/ai-openai-compat": "4.0.0-rc.113-clavia.4",
+    "@tardie/ai-openrouter": "4.0.0-rc.113-clavia.1",
     "effect": "4.0.0-rc.115",
     "jsonc-parser": "3.3.1"
   },
   "peerDependencies": {
     "@smithy/fetch-http-handler": "^5.6.3",
     "@smithy/node-http-handler": "^4.11.2",
-    "@tardie/ai-bedrock": "0.0.1"
+    "@tardie/ai-bedrock": "0.0.3"
   },
   "peerDependenciesMeta": {
     "@smithy/fetch-http-handler": {

package/src/agent/component/compaction/model.ts

@@ -0,0 +1,32 @@
+import { Effect, Option } from "effect"
+import { Toolkit, type Response } from "effect/unstable/ai"
+import { FetchHttpClient } from "effect/unstable/http"
+import { collectResponse } from "tardie/model/stream/collect"
+import { observeResponse } from "tardie/model/stream/delivery"
+import { BindingSettings, CurrentModel, ProviderRequestKey } from "tardie/model/settings"
+import type { InferenceIdentity } from "tardie/model/stream/observer"
+import type { ModelRef } from "tardie/model/reference"
+import { unknownModelError } from "tardie/model/error"
+
+// summarize accepts a nonempty completed summary without tool calls (component/compaction.test.ts).
+export const summarize = (prompt: string, identity: InferenceIdentity, model?: ModelRef) => Effect.gen(function* () {
+  const settings = yield* BindingSettings
+  const observer = yield* observeResponse(identity, model ?? { provider: settings.provider, model_id: settings.model }, identity.turn, settings.observer)
+  const transport = Option.getOrElse(yield* Effect.serviceOption(FetchHttpClient.RequestInit), () => ({}))
+  const fetchOptions = { ...transport, timeout: false }
+  const response = yield* collectResponse(prompt, Toolkit.make(), observer.onPart, undefined, settings.policy.timeout).pipe(
+    Effect.provideService(CurrentModel, model),
+    Effect.provideService(ProviderRequestKey, identity.turn),
+    Effect.provideService(FetchHttpClient.RequestInit, fetchOptions),
+    Effect.ensuring(observer.finish)
+  )
+  const parts: ReadonlyArray<Response.AnyPart> = response.parts
+  const error = parts.find(part => part.type === "error")
+  if (error?.type === "error") return yield* unknownModelError(error.error)
+  const finish = parts.findLast(part => part.type === "finish")
+  const text = parts.flatMap(part => part.type === "text-delta" ? [part.delta] : []).join("")
+  if ((finish?.reason !== "stop" && finish?.reason !== "tool-calls") || parts.some(part => part.type === "tool-call") || text.trim() === "") {
+    return yield* unknownModelError("Compaction requires a nonempty completed summary without tool calls")
+  }
+  return text
+})

package/src/agent/component/compaction.ts

@@ -1,6 +1,6 @@
 import { contextPolicyOf, resolvedContextPolicyOf, checkpointOf, keepFromIndex, type ContextPolicy, type CompactionPolicy } from "./context"
 export { contextPolicyOf, resolvedContextPolicyOf, checkpointOf, keepFromIndex, suffixOf, DEFAULT_COMPACTION_POLICY, type ContextPolicy, type ContextWindowTokens, type CompactionPolicy } from "./context"
-import { replayOf } from "../binding/continuation"
+import { replayOf } from "../inference/model/continuation"
 import { renderMessageEntries } from "../projection/messages"
 import { upcastError } from "../log/upcast"
 import { hasUnansweredToolCall, responsesOf } from "../log/response"
@@ -25,8 +25,8 @@ import {
   type TranscriptProjectionState
 } from "../projection/transcript"
 import { LanguageModel } from "effect/unstable/ai"
-import { react } from "../binding/index"
-import { BindingSettings, ModelSelection } from "../binding/settings"
+import { summarize } from "./compaction/model"
+import { BindingSettings, ModelSelection } from "tardie/model/settings"
 import { modelRefOf, type ModelRef } from "../inference/reference"
 import type { AgentComponent } from "../runtime/composition"
 
@@ -70,8 +70,8 @@ const renderedWeights = (events: ReadonlyArray<Event>, policy: ContextPolicy, mo
   for (const { event, message } of renderMessageEntries(events, policy)) {
     const continuation = message.continuation
     const replay = continuation === undefined ? undefined : replayOf(continuation, model === undefined ? continuation : { ...continuation, provider: model.provider, model: model.model_id })
-    const chars = replay?.messages === undefined
-      ? (message.content?.length ?? 0) + (message.toolCalls ?? []).reduce((sum, call) => sum + call.arguments.length, 0) + (replay?.reasoning ?? []).reduce((sum, text) => sum + text.length, 0)
+    const chars = replay === undefined
+      ? (message.content?.length ?? 0) + (message.toolCalls ?? []).reduce((sum, call) => sum + call.arguments.length, 0)
       : JSON.stringify(continuation!.payload).length
     weights.set(event, (weights.get(event) ?? 0) + chars)
   }
@@ -237,22 +237,13 @@ const compactionTransition = (
           const summaryModel = input.model === undefined
             ? undefined
             : selection.resolve?.(input.model).model ?? input.model
-          const action = yield* react(
-            {
-              trajectory: [{ type: "MessageReceived", id: `compact-${input.keepFrom}`, text: brief, at }],
-              identity: { ...self, turn: `compact-${input.keepFrom}` },
-              ...(summaryModel === undefined ? {} : { model: summaryModel }),
-              system: "",
-              tools: []
-            },
-            `compact-${input.keepFrom}`
-          ).pipe(Effect.provideService(BindingSettings, yield* (selection.settings?.(summaryModel) ?? BindingSettings)))
-          if (action.kind !== "complete" || action.output.trim() === "") {
-            return yield* Effect.die(action.kind === "fail" ? action.error : new Error("Compaction requires a nonempty summary"))
-          }
+          const summary = yield* summarize(brief, { ...self, turn: `compact-${input.keepFrom}` }, summaryModel).pipe(
+            Effect.provideService(BindingSettings, yield* (selection.settings?.(summaryModel) ?? BindingSettings)),
+            Effect.orDie
+          )
           return [compactionCompleted({
             keepFrom: input.keepFrom,
-            summary: action.output,
+            summary,
             contextWindowTokens: input.contextWindowTokens,
             fireTokens: input.fireTokens,
             keepTokens: input.keepTokens,

package/src/agent/inference/access.ts

@@ -1,184 +1 @@
-import { Schema } from "effect"
-import { ModelRef, modelRefOf, type ModelRef as ModelRefType } from "./reference"
-
-const PolicyName = Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty())
-
-export const ModelSelector = Schema.Struct({
-  provider: PolicyName,
-  model_ids: Schema.Union([Schema.Literal("*"), Schema.Array(PolicyName).check(Schema.isNonEmpty())])
-})
-
-export interface ModelSelector {
-  readonly provider: string
-  readonly model_ids: "*" | ReadonlyArray<string>
-}
-
-export const ModelAllow = Schema.Union([Schema.Literal("*"), Schema.Array(ModelSelector)])
-export type ModelAllow = "*" | ReadonlyArray<ModelSelector>
-
-// ModelPolicy carries resolved coordinate authority. Future rule languages lower into this selector form before composition, so intersection remains the authority boundary.
-export const ModelPolicy = Schema.Struct({
-  default: Schema.optional(ModelRef),
-  allow: ModelAllow
-})
-
-export interface ModelPolicy {
-  readonly default?: ModelRefType
-  readonly allow: ModelAllow
-}
-
-export const ModelPolicyOverride = Schema.Struct({
-  default: Schema.optional(ModelRef),
-  allow: Schema.optional(ModelAllow)
-})
-
-export interface ModelPolicyOverride {
-  readonly default?: ModelRefType
-  readonly allow?: ModelAllow
-}
-
-// DEFAULT_MODEL_POLICY leaves model authority unchanged and selects no default for an unconfigured host.
-export const DEFAULT_MODEL_POLICY: ModelPolicy = { allow: "*" }
-
-// DEFAULT_MODEL_POLICY_OVERRIDE inherits model authority and its default.
-export const DEFAULT_MODEL_POLICY_OVERRIDE: ModelPolicyOverride = {}
-
-const recordOf = (value: unknown): Record<string, unknown> | undefined =>
-  typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined
-
-const textOf = (value: unknown): string | undefined =>
-  typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
-
-const selectorOf = (value: unknown, index: number): ModelSelector => {
-  const selector = recordOf(value)
-  if (selector === undefined) throw new Error(`model selector ${index} must be an object`)
-  const unknown = Object.keys(selector).filter((field) => field !== "provider" && field !== "model_ids")
-  if (unknown.length > 0) throw new Error(`model selector ${index} contains unknown fields: ${unknown.join(", ")}`)
-  const provider = textOf(selector["provider"])
-  if (provider === undefined) throw new Error(`model selector ${index} must declare provider`)
-  const rawModels = selector["model_ids"]
-  if (rawModels === "*") return { provider, model_ids: "*" }
-  if (!Array.isArray(rawModels) || rawModels.length === 0) {
-    throw new Error(`model selector ${index} model_ids must be "*" or a non-empty array`)
-  }
-  const modelIds = rawModels.map((value, modelIndex) => {
-    const model = textOf(value)
-    if (model === undefined) throw new Error(`model selector ${index} model_ids[${modelIndex}] must be a non-empty string`)
-    return model
-  })
-  return { provider, model_ids: [...new Set(modelIds)].sort() }
-}
-
-type ProviderModels = "*" | Set<string>
-
-// selectorMapOf lowers the current selector language into the set representation consumed by policy intersection. Query resolvers add syntax before this boundary and persist the normalized result.
-const selectorMapOf = (selectors: ReadonlyArray<ModelSelector>): Map<string, ProviderModels> => {
-  const providers = new Map<string, ProviderModels>()
-  for (const selector of selectors) {
-    const current = providers.get(selector.provider)
-    if (current === "*" || selector.model_ids === "*") {
-      providers.set(selector.provider, "*")
-    } else {
-      providers.set(selector.provider, new Set([...(current ?? []), ...selector.model_ids]))
-    }
-  }
-  return providers
-}
-
-const selectorsOf = (providers: ReadonlyMap<string, ProviderModels>): ReadonlyArray<ModelSelector> =>
-  [...providers.entries()]
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([provider, models]) => ({ provider, model_ids: models === "*" ? "*" : [...models].sort() }))
-
-const allowOf = (rawAllow: unknown, required: boolean): ModelAllow | undefined => {
-  if (rawAllow === "*") return "*"
-  if (Array.isArray(rawAllow)) return selectorsOf(selectorMapOf(rawAllow.map(selectorOf)))
-  if (!required && rawAllow === undefined) return undefined
-  throw new Error(`model policy allow must be "*" or an array`)
-}
-
-// modelAllowedBy reports whether one reference belongs to a policy's selected set.
-export const modelAllowedBy = (policy: ModelPolicy, reference: ModelRefType): boolean =>
-  policy.allow === "*" || policy.allow.some((selector) =>
-    selector.provider === reference.provider &&
-    (selector.model_ids === "*" || selector.model_ids.includes(reference.model_id))
-  )
-
-// modelPolicyOf validates one policy and gives duplicate selectors a stable representation.
-export const modelPolicyOf = (value: unknown): ModelPolicy => {
-  if (value === undefined) return DEFAULT_MODEL_POLICY
-  const policy = recordOf(value)
-  if (policy === undefined) throw new Error("model policy must be an object")
-  const unknown = Object.keys(policy).filter((field) => field !== "default" && field !== "allow")
-  if (unknown.length > 0) throw new Error(`model policy contains unknown fields: ${unknown.join(", ")}`)
-  if (!("allow" in policy)) throw new Error('model policy must declare allow as "*" or an array')
-  const rawDefault = policy["default"]
-  const selected = modelRefOf(rawDefault)
-  if (rawDefault !== undefined && selected === undefined) throw new Error("model policy default must be { provider, model_id }")
-  const allow = allowOf(policy["allow"], true)!
-  const normalized: ModelPolicy = { ...(selected === undefined ? {} : { default: selected }), allow }
-  if (selected !== undefined && !modelAllowedBy(normalized, selected)) {
-    throw new Error(`model policy default ${selected.provider}/${selected.model_id} is excluded by allow`)
-  }
-  return normalized
-}
-
-// modelPolicyOverrideOf validates an optional downstream attenuation and default override.
-export const modelPolicyOverrideOf = (value: unknown): ModelPolicyOverride => {
-  if (value === undefined) return DEFAULT_MODEL_POLICY_OVERRIDE
-  const policy = recordOf(value)
-  if (policy === undefined) throw new Error("model policy override must be an object")
-  const unknown = Object.keys(policy).filter((field) => field !== "default" && field !== "allow")
-  if (unknown.length > 0) throw new Error(`model policy override contains unknown fields: ${unknown.join(", ")}`)
-  const rawDefault = policy["default"]
-  const selected = modelRefOf(rawDefault)
-  if (rawDefault !== undefined && selected === undefined) throw new Error("model policy override default must be { provider, model_id }")
-  const allow = allowOf(policy["allow"], false)
-  const normalized: ModelPolicyOverride = {
-    ...(selected === undefined ? {} : { default: selected }),
-    ...(allow === undefined ? {} : { allow })
-  }
-  if (selected !== undefined && allow !== undefined && !modelAllowedBy({ allow }, selected)) {
-    throw new Error(`model policy override default ${selected.provider}/${selected.model_id} is excluded by allow`)
-  }
-  return normalized
-}
-
-const intersectModels = (left: ProviderModels, right: ProviderModels): ProviderModels => {
-  if (left === "*") return right === "*" ? "*" : new Set(right)
-  if (right === "*") return new Set(left)
-  return new Set([...left].filter((model) => right.has(model)))
-}
-
-// intersectModelPolicies returns the authority shared by every layer (packages/core/tla/component/ModelPolicy.tla, ChildCannotWiden; HostCeiling).
-export const intersectModelPolicies = (policies: ReadonlyArray<ModelPolicy>): ModelPolicy => {
-  const explicit = policies.filter((policy) => policy.allow !== "*")
-  if (explicit.length === 0) return DEFAULT_MODEL_POLICY
-  let intersection = selectorMapOf(explicit[0]!.allow as ReadonlyArray<ModelSelector>)
-  for (const policy of explicit.slice(1)) {
-    const right = selectorMapOf(policy.allow as ReadonlyArray<ModelSelector>)
-    const next = new Map<string, ProviderModels>()
-    for (const [provider, models] of intersection) {
-      const other = right.get(provider)
-      if (other === undefined) continue
-      const shared = intersectModels(models, other)
-      if (shared === "*" || shared.size > 0) next.set(provider, shared)
-    }
-    intersection = next
-  }
-  return { allow: selectorsOf(intersection) }
-}
-
-// applyModelPolicy attenuates incoming authority and inherits or overrides its default (packages/core/tla/component/ModelPolicy.tla, ChildCannotWiden; DefaultAllowed).
-export const applyModelPolicy = (incoming: ModelPolicy, override: ModelPolicyOverride): ModelPolicy => {
-  const authority = intersectModelPolicies([incoming, { allow: override.allow ?? "*" }])
-  const selected = override.default ?? incoming.default
-  if (selected !== undefined && !modelAllowedBy(authority, selected)) {
-    throw new Error(`effective model policy excludes default ${selected.provider}/${selected.model_id}; supply an allowed default`)
-  }
-  return { ...authority, ...(selected === undefined ? {} : { default: selected }) }
-}
-
-// modelPolicyScopeOf returns a stable cursor scope for a policy intersection.
-export const modelPolicyScopeOf = (policies: ReadonlyArray<ModelPolicy>): string =>
-  JSON.stringify(intersectModelPolicies(policies).allow)
+export * from "tardie/model/access"

package/src/agent/inference/contract.ts

@@ -3,7 +3,7 @@ import type { Event } from "tardie/core/log/event"
 import type { ContextPolicy } from "../component/compaction"
 import type { OutputFallback } from "../output/contract"
 import type { ModelRef } from "./reference"
-import { DEFAULT_MODEL_POLICY_OVERRIDE, type ModelPolicy, type ModelPolicyOverride } from "./access"
+import { DEFAULT_MODEL_POLICY_OVERRIDE, type ModelPolicyOverride } from "./access"
 import type { InferenceIdentity } from "./observer"
 
 // InferPolicy states the process-crash ceiling and model authority applied by the inference machine. Output correction bounds belong to the mounted output component (component/repair.ts, RepairPolicy).
@@ -26,11 +26,7 @@ export interface InferRequest {
   readonly output?: { readonly fallback: OutputFallback; readonly system?: string }
 }
 
-export interface ModelResolution {
-  readonly model: ModelRef
-  // models is the interpreter's current authority for validating this call. It is not recorded.
-  readonly models?: ModelPolicy
-}
+export type { ModelResolution } from "tardie/model/reference"
 
 // NativeOutputSupport declares support for native structured output beside tools (component/native-output.ts).
 export class NativeOutputSupport extends Context.Service<

package/src/agent/inference/error.ts

@@ -1,36 +1 @@
-import { Schema } from "effect"
-import { AiError } from "effect/unstable/ai"
-
-export const ModelError = Schema.toCodecJson(AiError.AiError)
-export type ModelError = typeof ModelError.Type
-
-// encodeModelError preserves JSON duration encoding and native HTTP redaction (error.test.ts, packages/model/src/binding/errors.test.ts).
-export const encodeModelError = (error: AiError.AiError): Schema.Json => {
-  const object = Schema.Record(Schema.String, Schema.Json)
-  const encoded = Schema.decodeUnknownSync(object)(Schema.encodeSync(ModelError)(error))
-  const reason = encoded.reason
-  if ("http" in error.reason && error.reason.http !== undefined && Schema.is(object)(reason)) {
-    const http = Schema.decodeUnknownSync(Schema.Json)(
-      JSON.parse(Schema.encodeSync(Schema.fromJsonString(AiError.HttpContext))(error.reason.http))
-    )
-    return { ...encoded, reason: { ...Schema.decodeSync(object)(reason), http } }
-  }
-  return encoded
-}
-
-// unknownModelError preserves serializable evidence from unclassified failures.
-export const unknownModelError = (cause: unknown): AiError.AiError => {
-  if (AiError.isAiError(cause)) return cause
-  const description = cause instanceof Error ? cause.message || cause.name : typeof cause === "string" ? cause : typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string" ? cause.message : "Model inference failed"
-  const evidence = cause instanceof Error
-    ? { ...Object.fromEntries(Object.entries(cause).filter(([, value]) => Schema.is(Schema.Json)(value))), name: cause.name, message: cause.message, ...(cause.stack === undefined ? {} : { stack: cause.stack }) }
-    : Schema.is(Schema.Json)(cause) ? cause : String(cause)
-  return AiError.make({ module: "Tardigrade", method: "inference", reason: AiError.UnknownError.make({ description, metadata: { tardigrade: { evidence } } }) })
-}
-
-// modelErrorOf decodes persisted native evidence; historical envelopes remain historical.
-export const modelErrorOf = (error: unknown): AiError.AiError | undefined => {
-  if (AiError.isAiError(error)) return error
-  const decoded = Schema.decodeUnknownOption(ModelError)(error)
-  return decoded._tag === "Some" ? decoded.value : undefined
-}
+export * from "tardie/model/error"

package/src/agent/inference/machine.ts

@@ -4,9 +4,9 @@ import { bindTransitionContext } from "tardie/core/transition/transition"
 import { eventAt, eventPositionOf } from "tardie/core/event"
 import { RetrySchedule, retryDelayOf } from "./retry"
 import { LanguageModel } from "effect/unstable/ai"
-import { react } from "../binding/index"
+import { react } from "./model/index"
 import { unknownModelError } from "./error"
-import { BindingSettings, ModelSelection } from "../binding/settings"
+import { BindingSettings, ModelSelection } from "./model/settings"
 import { Cause, Clock, Effect, Random, Schema } from "effect"
 import { EventLog } from "tardie/core/log"
 import { HashMap, Option } from "effect"

package/src/agent/inference/model/continuation.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect"
+import { Prompt } from "effect/unstable/ai"
+import type { ProviderContinuation } from "../continuation"
+
+export interface ReplayIdentity {
+  readonly provider: string
+  readonly protocol: string
+  readonly model: string
+}
+
+export const replayOf = (continuation: ProviderContinuation | undefined, identity: ReplayIdentity): ReadonlyArray<Prompt.Message> | undefined => {
+  if (continuation === undefined || continuation.provider !== identity.provider || continuation.protocol !== identity.protocol || continuation.model !== identity.model) return undefined
+  return Schema.decodeSync(Prompt.Prompt)(continuation.payload).content
+}

package/src/agent/{binding → inference/model}/index.ts

@@ -1,19 +1,19 @@
 import { historyOf, importSchema } from "./prompt"
 import { actionOf, responseEvidence, errorOf } from "./response"
-import { observerPolicyOf, deltaDelivery } from "./observer"
-import type { InferDelta } from "../inference/observer"
-import type { InferRequest } from "../inference/contract"
+import { observeResponse } from "tardie/model/stream/delivery"
+import type { InferDelta } from "../observer"
+import type { InferRequest } from "../contract"
 import { FetchHttpClient } from "effect/unstable/http"
 import { Duration, Effect, Option } from "effect"
-import { AiError, IdGenerator, Prompt, Response, Tool, Toolkit } from "effect/unstable/ai"
-import { modelRequest } from "../inference/request"
-import type { Action } from "../log/events"
-import { collectResponse } from "./collect"
+import { AiError, Prompt, Response, Tool, Toolkit } from "effect/unstable/ai"
+import { modelRequest } from "../request"
+import type { Action } from "../../log/events"
+import { collectResponse } from "tardie/model/stream/collect"
 import { BindingSettings, BindingInvocation, CurrentModel, ProviderRequestKey } from "./settings"
 
 import { fallbackSystemFor, outputModeOf, outputSchemaFor, outputNameFor } from "./output"
 
-import { StreamIncomplete, StreamBoundExceeded, StreamTruncated } from "./request"
+import { StreamIncomplete, StreamBoundExceeded, StreamTruncated } from "tardie/model/stream/request"
 
 // react translates one Effect response into an action for the inference machine.
 export const react = (request: InferRequest, key?: string, signal?: AbortSignal, onDelta?: (delta: InferDelta) => void) => Effect.gen(function* () {
@@ -21,9 +21,8 @@ export const react = (request: InferRequest, key?: string, signal?: AbortSignal,
   const { provider: providerId, protocol, policy } = options
   const endpoint = { provider: providerId, model: request.model?.model_id ?? options.model }
   const outputPolicy = { ...endpoint, ...(options.output === undefined ? {} : { output: options.output }) }
-  const observerPolicy = options.observer === undefined ? undefined : observerPolicyOf(options.observer)
   if (signal?.aborted) return yield* Effect.interrupt
-  const delivery = options.observer === undefined || observerPolicy === undefined ? undefined : yield* deltaDelivery(options.observer, observerPolicy)
+  const delivery = yield* observeResponse(request.identity, { provider: providerId, model_id: endpoint.model }, key, options.observer, onDelta)
   return yield* Effect.suspend(() => {
     let reportedCostUsd: number | undefined
     let observed: Response.AnyPart[] = []
@@ -55,18 +54,10 @@ export const react = (request: InferRequest, key?: string, signal?: AbortSignal,
       const response = yield* Effect.gen(function* () {
         const maxOutputTokens = policy.maxOutputTokens
         observed = []
-        let sequence = 0
-        let blockIndex = -1
-        const physicalAttempt = yield* IdGenerator.defaultIdGenerator.generateId()
         const result = yield* collectResponse(Prompt.setSystem(Prompt.fromMessages(history), system), Toolkit.make(...tools), (part) => {
           observed.push(part)
           if (part.type === "finish") reportedCostUsd = options.reportedCostUsd?.(part)
-          if (part.type === "text-start" || part.type === "reasoning-start") blockIndex += 1
-          if (part.type === "text-delta" || part.type === "reasoning-delta") {
-            const delta: InferDelta = { ...request.identity, logicalAttempt: key ?? request.identity.turn, physicalAttempt, model: { provider: providerId, model_id: endpoint.model }, blockIndex: Math.max(0, blockIndex), sequence: sequence++, text: part.delta, ...(part.type === "reasoning-delta" ? { kind: "reasoning" as const } : {}) }
-            onDelta?.(delta)
-            return delivery?.offer(delta).pipe(Effect.asVoid)
-          }
+          return delivery.onPart(part)
         }, responseFormat, policy.timeout)
         if (result.parts.some((part) => part.type === "finish" && part.reason === "length")) return yield* new StreamTruncated({ maxOutputTokens })
         return result
@@ -108,5 +99,5 @@ export const react = (request: InferRequest, key?: string, signal?: AbortSignal,
         } satisfies Action
       })),
       Effect.map((action): Action => reportedCostUsd === undefined ? action : { ...action, reportedCostUsd }))
-  }).pipe(Effect.ensuring(delivery?.finish ?? Effect.void))
+  }).pipe(Effect.ensuring(delivery.finish))
 })

package/src/agent/{binding → inference/model}/output.ts

@@ -1,18 +1,13 @@
-import { NATIVE_MODE, outputNameErrors, outputProfileErrors, type OutputMode } from "../output/contract"
-import type { OutputRequest } from "../inference/request"
+import { NATIVE_MODE, outputNameErrors, outputProfileErrors, type OutputMode } from "../../output/contract"
+import type { OutputRequest } from "../request"
 
 // The binding's half of the output contract: what an endpoint promises about a declared schema,
 // what that promise costs a request, and how the schema reaches each wire. A turn that declares a
 // contract the configured endpoint cannot honour fails here, before a socket opens
 // (binding/index.test.ts).
 
-// OutputCapability is what one configured endpoint promises about a declared contract. It is a
-// union so a value cannot say two things at once: an endpoint that promises nothing has no
-// tool-combination question to answer, and one that promises a native strict schema must say
-// whether that schema may ride the same call as a tool list.
-export type OutputCapability =
-  | { readonly guarantee: "none" }
-  | { readonly guarantee: "native"; readonly withTools: boolean }
+import type { OutputCapability } from "tardie/model/output"
+export type { OutputCapability } from "tardie/model/output"
 
 // UNPROVEN is the message an endpoint that declared nothing earns. It names the two ways out, so
 // an operator reading a failed turn knows what to set rather than which source to read.

package/src/agent/{binding → inference/model}/prompt.ts

@@ -1,6 +1,6 @@
 import { JsonSchema, Schema, SchemaRepresentation } from "effect"
 import { Prompt } from "effect/unstable/ai"
-import type { AgentMessage } from "../projection/messages"
+import type { AgentMessage } from "../../projection/messages"
 import { replayOf, type ReplayIdentity } from "./continuation"
 
 export const DEFAULT_SCHEMA_IMPORT_OPTIONS = { patterns: "apply" } as const satisfies SchemaRepresentation.FromJsonSchemaOptions
@@ -11,18 +11,16 @@ export const historyOf = (messages: ReadonlyArray<AgentMessage>, identity: Repla
   const names = new Map<string, string>()
   return messages.flatMap((message) => {
     for (const call of message.toolCalls ?? []) names.set(call.id, call.name)
-    const replay = replayOf(message.continuation, identity)
-    return replay.messages ?? promptMessage(message, names, replay.reasoning)
+    return replayOf(message.continuation, identity) ?? promptMessage(message, names)
   })
 }
 
-const promptMessage = (message: AgentMessage, names: ReadonlyMap<string, string>, reasoning: ReadonlyArray<string> = []): ReadonlyArray<Prompt.Message> => {
+const promptMessage = (message: AgentMessage, names: ReadonlyMap<string, string>): ReadonlyArray<Prompt.Message> => {
   if (message.role === "user") return [Prompt.userMessage({ content: [Prompt.makePart("text", { text: message.content ?? "" })] })]
   if (message.role === "tool") return [Prompt.toolMessage({ content: [Prompt.makePart("tool-result", {
     id: message.toolCallId ?? "", name: names.get(message.toolCallId ?? "") ?? "", result: message.content ?? "", isFailure: message.isFailure ?? false, providerExecuted: false
   })] })]
   return [Prompt.assistantMessage({ content: [
-    ...reasoning.map((text) => Prompt.makePart("text", { text })),
     ...(message.content ? [Prompt.makePart("text", { text: message.content })] : []),
     ...(message.toolCalls ?? []).map((call) => Prompt.makePart("tool-call", { id: call.id, name: call.name, params: JSON.parse(call.arguments), providerExecuted: false }))
   ] })]

package/src/agent/{binding → inference/model}/response.ts

@@ -1,8 +1,8 @@
 import { Effect, Schema } from "effect"
 import { AiError, Response } from "effect/unstable/ai"
-import { type Action, type ToolCall } from "../log/events"
-import { ToolCallValidationError } from "./collect"
-import { unknownModelError } from "../inference/error"
+import { type Action, type ToolCall } from "../../log/events"
+import { ToolCallValidationError } from "tardie/model/stream/collect"
+import { unknownModelError } from "../error"
 
 /**
  * actionOf translates Effect response parts into the agent's Action contract.
@@ -40,7 +40,7 @@ export const actionOf = (parts: ReadonlyArray<Response.AnyPart>, served: Pick<Ac
     const calls: ToolCall[] = []
     const errors: AiError.AiError[] = []
     for (const part of parts) {
-      if (part.type === "tool-call") calls.push({ callId: part.id, name: part.name, arguments: part.params })
+      if (part.type === "tool-call" && !part.providerExecuted) calls.push({ callId: part.id, name: part.name, arguments: part.params })
       if (part.type === "error") {
         if (!Schema.is(ToolCallValidationError)(part.error)) {
           errors.push(yield* errorOf(part.error))

package/src/agent/inference/model/settings.ts

@@ -0,0 +1,11 @@
+import { Context } from "effect"
+import type { InferRequest } from "../contract"
+import type { InferDelta } from "../observer"
+export { BindingSettings, CurrentModel, ModelSelection, ProviderRequestKey, type BindingOptions } from "tardie/model/settings"
+
+export const BindingInvocation = Context.Reference<{
+  readonly request: InferRequest
+  readonly key?: string | undefined
+  readonly signal?: AbortSignal | undefined
+  readonly onDelta?: ((delta: InferDelta) => void) | undefined
+} | undefined>("tardie/BindingInvocation", { defaultValue: () => undefined })

package/src/agent/inference/observer.ts

@@ -1,39 +1 @@
-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"). instance names the actor instance, so two sessions of one actor name stay distinguishable at the model seam (index.test.ts, "two host instances of one actor name carry distinct instance identities").
-export interface InferenceIdentity {
-  readonly actor: string
-  readonly instance: string
-  readonly thread: string
-  readonly turn: string
-}
-
-// InferDelta is ephemeral answer or reasoning text from one physical provider request. Sequence is zero-based within that request, so a consumer can detect a dropped delta (packages/model/src/host.test.ts).
-export interface InferDelta extends InferenceIdentity {
-  readonly logicalAttempt: string
-  readonly physicalAttempt: string
-  readonly model: ModelRef
-  readonly blockIndex: number
-  readonly sequence: number
-  readonly kind?: "text" | "reasoning"
-  readonly text: string
-}
-
-// InferenceObserver receives ephemeral output outside the durable log. Failure and timeout discard that delivery without changing inference (packages/model/src/inference/observer.test.ts).
-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
-}
+export * from "tardie/model/stream/observer"

package/src/agent/inference/reference.ts

@@ -1,18 +1 @@
-import { Schema } from "effect"
-
-// ModelRef identifies the provider and model an actor requests. The host supplies the provider connection.
-export const ModelRef = Schema.Struct({
-  provider: Schema.NonEmptyString,
-  model_id: Schema.NonEmptyString
-})
-
-export type ModelRef = typeof ModelRef.Type
-
-// modelRefOf reads a complete model reference from an untyped message or tool argument.
-export const modelRefOf = (value: unknown): ModelRef | undefined => {
-  if (typeof value !== "object" || value === null) return undefined
-  const reference = value as { readonly provider?: unknown; readonly model_id?: unknown }
-  if (typeof reference.provider !== "string" || reference.provider.trim().length === 0) return undefined
-  if (typeof reference.model_id !== "string" || reference.model_id.trim().length === 0) return undefined
-  return { provider: reference.provider.trim(), model_id: reference.model_id.trim() }
-}
+export * from "tardie/model/reference"