tardie 0.4.0 → 0.5.0-rc

package/README.md

@@ -15,9 +15,9 @@ A durable and modular agent harness built for self-improvement.
 ### A harness made for self-improvement
 As models get increasingly smart, they will be capable of writing their own harnesses to improve themselves ([Meta-Harness](https://arxiv.org/abs/2603.28052)). A harness that is too rigid and complex is a bottleneck to this. We need something more composable, and easy to author.
 
-We took inspiration from React. React derives the component tree as a function of state (`UI = f(state)`). Tardigrade derives information and state transitions from the event log, an idea with roots in [Harel's statecharts](https://www.sciencedirect.com/science/article/pii/0167642387900359).
+We took inspiration from React. React derives its component tree and declared effects from state (`{ UI, effects } = f(state)`). Tardigrade derives a view and state transitions from the event log, an idea with roots in [Harel's statecharts](https://www.sciencedirect.com/science/article/pii/0167642387900359).
 
-$$\lbrace\mathrm{information},\ \mathrm{transitions}\rbrace = f(\mathrm{log})$$
+$$\lbrace\mathrm{view},\ \mathrm{transitions}\rbrace = f(\mathrm{log})$$
 
 ## Why Tardigrade
 
@@ -29,17 +29,7 @@ $$\lbrace\mathrm{information},\ \mathrm{transitions}\rbrace = f(\mathrm{log})$$
 
 ## Quickstart
 
-### For agents
-
-Copy this prompt into your coding agent, or install the [Tardigrade skill](skills/tardigrade/SKILL.md):
-
-```text
-Use https://github.com/clavia-labs/tardigrade and follow skills/tardigrade/SKILL.md to create, author, build, push, and run a local actor. Share its Voyager trace URL.
-```
-
-### For developers
-
-Install Tardigrade and initialize an editable template actor. Use Bun 1.4 or later.
+Install Tardigrade and initialize an editable template actor. Use Bun 1.4 or later. If you are using a coding agent, the [Tardigrade skill](skills/tardigrade/SKILL.md) can help.
 
 ```bash
 bun add -g tardie
@@ -78,7 +68,7 @@ You can use `npm install tardie` instead. Install `tardie@next` to test a releas
 
 ### Create a component
 
-An agent is made of components. A component derives information and owed transitions from the log. Agent information includes system fragments, tool bindings, and context policy. This component gives the model one tool and owes no autonomous work:
+An agent is made of components. A component derives a view and owed transitions from the log. An agent view includes system fragments, tool bindings, and context policy. This component gives the model one tool and owes no autonomous work:
 
 ```ts
 import type { AgentComponent } from "tardie"
@@ -86,7 +76,7 @@ import type { AgentComponent } from "tardie"
 const deploys: AgentComponent = {
   name: "deploys",
   derive: () => ({
-    info: {
+    view: {
       system: ["Inspect recent deployments when a release may explain an incident."],
       tools: [{
         spec: {
@@ -98,7 +88,8 @@ const deploys: AgentComponent = {
           answer([{ service: "api", revision: "a17c", summary: "Add rate limiting" }])
         ]
       }],
-      context: []
+      context: [],
+      output: []
     },
     transitions: []
   })
@@ -109,9 +100,9 @@ const deploys: AgentComponent = {
 
 The call follows one route:
 
-1. The component adds `recent_deploys` to its derived information.
+1. The component adds `recent_deploys` to its derived view.
 2. The model selects it and returns a tool call. Tardigrade records `ToolCalled` in the log.
-3. The shared runtime finds the paired handler in the information that offered the call and asks it to serve against the current log.
+3. The shared runtime finds the paired handler in the view that offered the call and asks it to serve against the current log.
 4. Tardigrade records `ToolReturned`. The next model request includes the result.
 
 ### Compose an agent
@@ -119,21 +110,19 @@ The call follows one route:
 Mount the component beside the built-in parts that this task needs:
 
 ```ts
-import { actorOf, agentRuntime, budget, codeMode, compaction, reply } from "tardie"
-
-const releaseAnalyst = actorOf(
-  agentRuntime(),
-  [
-    deploys,     // recent_deploys and its paired handler
-    codeMode,    // durable JavaScript execution
-    budget,      // a per-turn code budget
-    compaction,  // bounded model context
-    reply        // results for parent agents
-  ]
-)
+import { agentOf, budget, codeMode, compaction, outputFailFast, reply } from "tardie"
+
+const releaseAnalyst = agentOf([
+  deploys,     // recent_deploys and its paired handler
+  codeMode,    // durable JavaScript execution
+  budget,      // a per-turn code budget
+  compaction,  // bounded model context
+  reply,       // results for parent agents
+  outputFailFast // structured results without a retry fallback
+])
 ```
 
-`actorOf` combines the components under `agentRuntime`. The runtime interprets their information as inference and tool routing, while the core actor reconciles their transitions. The model sees `recent_deploys` and `execute` in one request. Policy components derive work from the same log.
+`agentOf` combines the components and carries their service requirements into the host type. The runtime interprets their view as inference and tool routing, while the core actor reconciles their transitions. The model sees `recent_deploys` and `execute` in one request. Policy components derive work from the same log.
 
 This agent can inspect deployments, analyze results with JavaScript, compact a long investigation, and report to a parent agent. Change the list to create another harness.
 
@@ -202,6 +191,7 @@ Effects have at-least-once execution. Each keyed result is recorded once. Provid
 ## Learn more
 
 - [Quickstart](docs/quickstart.md): build the event loop and its agent components from first principles.
+- [Structured output](docs/output.md): declare a typed result and read its value.
 - [HTTP server](docs/how-to/server.md)
 - [CLI](docs/how-to/cli.md)
 - [Why Tardigrade](docs/explanations/why.md): learn what the log-as-state model makes possible.

package/examples/quickstart/actor.ts

@@ -1,6 +1,5 @@
 import {
-  actorOf,
-  agentRuntime,
+  agentOf,
   agentsPackage,
   budget,
   codeModeFor,
@@ -8,6 +7,7 @@ import {
   defineActor,
   fetchPackage,
   filesPackage,
+  outputFailFast,
   reply,
   workspacePackage
 } from "tardie"
@@ -28,29 +28,28 @@ Return a concise answer with concrete findings.
 const instructions = {
   name: "instructions",
   derive: () => ({
-    info: { system: [actorInstructions], tools: [], context: [] },
+    view: { system: [actorInstructions], tools: [], context: [], output: [] },
     transitions: []
   })
 }
 
 export default defineActor({
   name: actorName,
-  // actorOf composes components under the explicit agent information runtime.
-  actor: actorOf(
-    agentRuntime(),
-    [
-      instructions,
-      // codeModeFor gives the model one code tool over the packages listed here.
-      codeModeFor({
-        // packages grant access to local files, HTTP, child agents, and saved tool results.
-        packages: [filesPackage(), fetchPackage(), agentsPackage(), workspacePackage()]
-      }),
-      // reply returns a finished turn to the actor that delegated it.
-      reply,
-      // budget stops work tools when the turn reaches its tool-call limit.
-      budget,
-      // compaction summarizes older context when a long turn outgrows its context window.
-      compaction
-    ]
-  )
+  // agentOf carries component and output requirements into the host type.
+  actor: agentOf([
+    instructions,
+    // codeModeFor gives the model one code tool over the packages listed here.
+    codeModeFor({
+      // packages grant access to local files, HTTP, child agents, and saved tool results.
+      packages: [filesPackage(), fetchPackage(), agentsPackage(), workspacePackage()]
+    }),
+    // reply returns a finished turn to the actor that delegated it.
+    reply,
+    // budget stops work tools when the turn reaches its tool-call limit.
+    budget,
+    // compaction summarizes older context when a long turn outgrows its context window.
+    compaction,
+    // outputFailFast handles structured results on endpoints with no native guarantee without retrying.
+    outputFailFast
+  ])
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.4.0",
+  "version": "0.5.0-rc",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "A durable agent harness. State is a pure function of the log.",
@@ -34,6 +34,8 @@
     "./code": "./src/code/index.ts",
     "./code/*": "./src/code/*.ts",
     "./host/*": "./src/host/*.ts",
+    "./channels": "./src/channels/index.ts",
+    "./channels/*": "./src/channels/*.ts",
     "./client": "./src/client/index.ts",
     "./client/*": "./src/client/*.ts",
     "./bun/*": "./src/bun/*.ts",

package/src/agent/boundary.ts

@@ -1,5 +1,6 @@
 import type { Event } from "tardie/core/event"
 import { turnTerminalOf } from "tardie/code/turns"
+import { canonicalOf, declarationForTurn, type OutputContract } from "./output"
 
 // Boundary is where a settle left a turn: a terminal, or a park on a budget ask. The
 // platform's call and resume read it to answer the spawning code. Pure over the log, so a
@@ -32,3 +33,32 @@ export const boundaryOf = (log: ReadonlyArray<Event>, turn: string): Boundary |
   }
   return undefined
 }
+
+// outputOf reads a completed turn's result under the contract that turn declared. It returns undefined for a pending or failed turn and throws when the declaration or stored result cannot satisfy the supplied contract (boundary.test.ts, "a turn that declared nothing is never reinterpreted"; runtime/infer.ts, completionOf).
+export const outputOf = <T>(
+  contract: OutputContract<T>,
+  log: ReadonlyArray<Event>,
+  turn: string
+): T | undefined => {
+  const terminal = turnTerminalOf(log, turn)
+  if (terminal === undefined || terminal.type !== "TurnCompleted") return undefined
+  const declared = declarationForTurn(log, turn)
+  if (declared.kind !== "contract") {
+    throw new Error(
+      `turn ${turn} did not declare the contract "${contract.name}", so its result is not a value of that contract` +
+        (declared.kind === "invalid" ? `: ${declared.errors.join("; ")}` : "")
+    )
+  }
+  if (canonicalOf(declared.contract) !== canonicalOf(contract)) {
+    throw new Error(
+      `turn ${turn} declared the contract "${declared.contract.name}", which is not the contract "${contract.name}" this read holds`
+    )
+  }
+  const decoded = declared.contract.decode(JSON.parse(String((terminal as { output?: unknown }).output)))
+  if ("errors" in decoded) {
+    throw new Error(
+      `turn ${turn} completed with a result that misses the contract "${contract.name}":\n${decoded.errors.map((e) => `- ${e}`).join("\n")}`
+    )
+  }
+  return decoded.value as T
+}

package/src/agent/components/budget.ts

@@ -36,8 +36,9 @@ export const budgetOf = (view: ReadonlyArray<Event>, policy: Partial<BudgetPolic
   return base + granted
 }
 
-// usedOf counts the tool calls the turn has spent. Only `execute` spends: `answer` and
-// `request_budget` are the turn's exits, so they never draw the budget down.
+// usedOf counts the tool calls the turn has spent. Only `execute` spends: `request_budget` is
+// the turn's escalation, so it never draws the budget down, and the final response is no tool
+// call at all (src/output.ts).
 export const usedOf = (view: ReadonlyArray<Event>): number =>
   view.filter((e) => e.type === "ToolCalled" && String((e as { name?: unknown }).name) === "execute").length
 
@@ -63,7 +64,7 @@ export const worldOf = (view: ReadonlyArray<Event>): string | undefined => {
 }
 
 // BudgetPhase is the budget state of the current turn, read from the most recent lifecycle
-// marker scanning back. It is pure and scoped to the current turn like `outputSchemaOf`, so an
+// marker scanning back. It is pure and scoped to the current turn like `contractOf`, so an
 // earlier turn's wall does not leak. `exhausted`: the wall is up and the turn may still ask.
 // `denied`: the ask was refused, so the turn must answer. `spending`: a grant reopened the
 // budget, or none was ever spent.
@@ -131,13 +132,13 @@ export const budgetReactorFor = (policy: Partial<BudgetPolicy> = {}): Reactor<ne
 // budgetReactor is that reactor on the default ceiling.
 export const budgetReactor: Reactor<never> = budgetReactorFor()
 
-// budgetFor derives budget transitions and contributes no agent information.
+// budgetFor derives budget transitions and contributes an empty agent view.
 export const budgetFor = (policy: Partial<BudgetPolicy>): AgentComponent => {
   const reactor = budgetReactorFor(policy)
   return {
     name: "budget",
     derive: (log) => ({
-      info: { system: [], tools: [], context: [] },
+      view: { system: [], tools: [], context: [], output: [] },
       transitions: reactor(log)
     })
   }

package/src/agent/components/code.ts

@@ -80,10 +80,11 @@ export const codeModeFor = <
     name: "code",
     keys: codeKeys,
     derive: (log) => ({
-      info: {
+      view: {
         system: [typeof options.system === "function" ? options.system(log) : options.system ?? codeSystemFor(packages as ReadonlyArray<Package<unknown>>)],
         tools: [{ spec: EXECUTE_TOOL, serve: (call, current, answer) => serveCode(current, call, answer) }],
-        context: []
+        context: [],
+        output: []
       },
       transitions: reactor(log)
     })

package/src/agent/components/compaction.ts

@@ -3,6 +3,7 @@ import { transition, type Reactor } from "tardie/core/actor"
 import { compactionCompleted } from "../events"
 import type { Event } from "tardie/core/event"
 import { turnOf, turnView } from "tardie/code/turns"
+import { projectedOutput } from "../output"
 import { Infer } from "../runtime/infer"
 import type { AgentComponent } from "../runtime/agent"
 
@@ -78,6 +79,13 @@ const renderedChars = (e: Event, policy: ContextPolicy): number => {
       return JSON.stringify(v.arguments ?? {}).length
     case "ToolReturned":
       return Math.min(JSON.stringify(v.result ?? null).length, policy.resultRenderCap)
+    case "OutputRejected":
+      // A rejected response and its reasons render while the correction is owed. A projected one
+      // never reaches this function: the measure reads the same projection the render does
+      // (src/output.ts, projectedOutput).
+      return String(v.text ?? "").length + JSON.stringify(v.errors ?? []).length
+    case "OutputRetryRequested":
+      return String(v.feedback ?? "").length
     case "TurnCompleted":
       return String(v.output ?? "").length
     case "TurnFailed":
@@ -92,7 +100,7 @@ const renderedChars = (e: Event, policy: ContextPolicy): number => {
 // the estimate is a pure function of the recorded events (compaction.test.ts, "the measure").
 export const estimateTokens = (events: ReadonlyArray<Event>, policy: Partial<ContextPolicy> = {}): number => {
   const resolved = contextPolicyOf(policy)
-  return Math.ceil(events.reduce((n, e) => n + renderedChars(e, resolved), 0) / 4)
+  return Math.ceil(projectedOutput(events).reduce((n, e) => n + renderedChars(e, resolved), 0) / 4)
 }
 
 // checkpointOf returns the last checkpoint: the identity the next span starts from, and the
@@ -202,6 +210,10 @@ const lineOf = (e: Event, policy: ContextPolicy): string | null => {
       return `agent ran: ${clip(JSON.stringify(v.arguments ?? {}), policy.summaryLineCap)}`
     case "ToolReturned":
       return `result: ${clip(JSON.stringify(v.result ?? null), policy.summaryLineCap)}`
+    case "OutputRejected":
+      return `agent (refused, ${String(v.contract ?? "")}): ${clip(String(v.text ?? ""), policy.summaryLineCap)}`
+    case "OutputRetryRequested":
+      return `asked again: ${clip(String(v.feedback ?? ""), policy.summaryLineCap)}`
     case "TurnCompleted":
       return `agent: ${String(v.output ?? "")}`
     case "TurnFailed":
@@ -235,11 +247,15 @@ const firedUncovered = (log: ReadonlyArray<Event>): boolean => {
 // model never sees (ContextPolicy above).
 export const compactionReactorFor = (policy: Partial<ContextPolicy> = {}): Reactor<Infer> => (log) => {
   const resolved = contextPolicyOf(policy)
-  if (!(firedUncovered(log) || (overContext(log, resolved) && atRoundBoundary(log)))) return []
-  const cut = cutOf(log, resolved)
+  // The projection runs first, so the guard, the cut, and the brief all read the history the
+  // model reads. A corrected exchange the render hides can neither trigger a paid pass nor leak
+  // its rejected reply into a summary (src/output.ts, projectedOutput).
+  const view = projectedOutput(log)
+  if (!(firedUncovered(view) || (overContext(view, resolved) && atRoundBoundary(view)))) return []
+  const cut = cutOf(view, resolved)
   if (cut === undefined) return []
-  const prior = checkpointOf(log)
-  const span = log.slice(keepFromIndex(log, prior.keepFrom), cut.index)
+  const prior = checkpointOf(view)
+  const span = view.slice(keepFromIndex(view, prior.keepFrom), cut.index)
   return [
     transition({
       key: `cc:${cut.keepFrom}`,
@@ -282,7 +298,7 @@ export const compactionFor = (policy: Partial<ContextPolicy>): AgentComponent<In
   return {
     name: "compaction",
     derive: (log) => ({
-      info: { system: [], tools: [], context: [{ component: "compaction", policy }] },
+      view: { system: [], tools: [], context: [{ component: "compaction", policy }], output: [] },
       transitions: reactor(log)
     })
   }

package/src/agent/components/repair.ts

@@ -0,0 +1,86 @@
+import type { Event } from "tardie/core/event"
+import { turnView } from "tardie/code/turns"
+import { correctionAttemptsErrors, declaredOutputOf, type OutputFallback } from "../output"
+import { defineOutputFallback, type OutputFallbackComponent } from "../runtime/agent"
+
+// RepairPolicy sets the correction limit and completed-history projection. `attempts` counts correction requests after the initial request (src/output.ts, projectedOutput).
+export interface RepairPolicy {
+  readonly attempts: number
+  readonly projectHistory: boolean
+}
+
+export const DEFAULT_REPAIR_POLICY: RepairPolicy = { attempts: 2, projectHistory: true }
+
+// repairPolicyOf applies DEFAULT_REPAIR_POLICY and validates each override (turn.test.ts, "a bound that is not a whole count of asks is refused where it is stated").
+export const repairPolicyOf = (policy: Partial<RepairPolicy> = {}): RepairPolicy => {
+  const attempts = policy.attempts ?? DEFAULT_REPAIR_POLICY.attempts
+  const problems = correctionAttemptsErrors(attempts)
+  if (problems.length > 0) throw new Error(`the repair policy is not applicable: ${problems.join("; ")}`)
+  const projectHistory = policy.projectHistory ?? DEFAULT_REPAIR_POLICY.projectHistory
+  if (typeof projectHistory !== "boolean") {
+    throw new Error(
+      `the repair policy is not applicable: projectHistory must be true or false, got ${JSON.stringify(projectHistory)}`
+    )
+  }
+  return { attempts, projectHistory }
+}
+
+// repairFallback returns the validated fallback record interpreted by the infer reactor.
+export const repairFallback = (policy: Partial<RepairPolicy> = {}): OutputFallback => {
+  const resolved = repairPolicyOf(policy)
+  return {
+    kind: "repair",
+    name: "repair",
+    attempts: resolved.attempts,
+    projectHistory: resolved.projectHistory
+  }
+}
+
+// outputSystemFor returns the schema instruction used only in fallback mode (runtime/agent.ts, OutputFragment).
+export const outputSystemFor = (name: string, schema: unknown): string =>
+  `Your final reply for this turn must be JSON conforming to the schema "${name}":\n${JSON.stringify(schema)}\nReply with that JSON alone: no prose around it, no code fence.`
+
+// declaredSystem returns the fallback instruction for the current declared contract.
+const declaredSystem = (log: ReadonlyArray<Event>): { readonly system?: string } => {
+  const declared = declaredOutputOf(turnView(log))
+  return declared.kind === "contract"
+    ? { system: outputSystemFor(declared.contract.name, declared.contract.schema) }
+    : {}
+}
+
+// outputRepairFor derives the framework correction loop under a stated policy.
+export const outputRepairFor = (policy: Partial<RepairPolicy> = {}): OutputFallbackComponent => {
+  const fallback = repairFallback(policy)
+  return defineOutputFallback({
+    name: "output.repair",
+    derive: (log: ReadonlyArray<Event>) => ({
+      view: {
+        system: [],
+        tools: [],
+        context: [],
+        output: [{ component: "output.repair", fallback, ...declaredSystem(log) }]
+      },
+      transitions: []
+    })
+  })
+}
+
+// outputRepair is the component under the default policy.
+export const outputRepair: OutputFallbackComponent = outputRepairFor()
+
+// FAIL_FAST_FALLBACK validates one result and schedules no correction.
+export const FAIL_FAST_FALLBACK: OutputFallback = { kind: "local", name: "fail-fast" }
+
+// outputFailFast contributes the fail-fast fallback and its contract instruction (turn.test.ts, "the fail-fast implementation").
+export const outputFailFast: OutputFallbackComponent = defineOutputFallback({
+  name: "output.fail-fast",
+  derive: (log: ReadonlyArray<Event>) => ({
+    view: {
+      system: [],
+      tools: [],
+      context: [],
+      output: [{ component: "output.fail-fast", fallback: FAIL_FAST_FALLBACK, ...declaredSystem(log) }]
+    },
+    transitions: []
+  })
+})

package/src/agent/components/reply.ts

@@ -1,11 +1,20 @@
 import { Clock, Effect } from "effect"
-import { Router } from "tardie/core/router"
+import { Router } from "tardie/core/communication/router"
 import { Self, transition, type Reactor } from "tardie/core/actor"
 import { replyDelivered } from "../events"
 import type { Event } from "tardie/core/event"
-import { replyEvent } from "tardie/core/message"
+import { replyEvent } from "tardie/core/communication/message"
 import { turnTerminalOf, replyView } from "tardie/code/turns"
 import type { AgentComponent } from "../runtime/agent"
+import { linkOf, reverseLink, type Link } from "tardie/core/communication/link"
+import {
+  formatActorAddress,
+  isActorAddress,
+  isProviderAddress,
+  parseActorAddress,
+  type ActorAddress,
+  type ProviderAddress
+} from "tardie/core/communication/address"
 
 // The reply reactor: report the turn's terminal home. When the inbound named a `replyTo`, the
 // terminal goes back to that actor as a plain `MessageReceived`, and the caller folds it as a
@@ -19,9 +28,15 @@ import type { AgentComponent } from "../runtime/agent"
 // owedTurn returns the turn being reported: the view's head, and its stamped terminal.
 const owedTurn = (
   log: ReadonlyArray<Event>
-): { readonly id: string; readonly replyTo?: string; readonly text: string; readonly outcome: "completed" | "failed" } => {
+): {
+  readonly id: string
+  readonly link?: Link<unknown, ActorAddress>
+  readonly replyTo?: string
+  readonly text: string
+  readonly outcome: "completed" | "failed"
+} => {
   const view = replyView(log)
-  const inbound = view[0] as { id?: unknown; replyTo?: unknown } | undefined
+  const inbound = view[0] as { id?: unknown; link?: unknown; replyTo?: unknown } | undefined
   const id = String(inbound?.id)
   const terminal = turnTerminalOf(log, id) as
     | { output?: unknown; error?: unknown }
@@ -31,6 +46,9 @@ const owedTurn = (
   }
   return {
     id,
+    ...(typeof inbound.link === "object" && inbound.link !== null && "source" in inbound.link && "target" in inbound.link
+      ? { link: inbound.link as Link<unknown, ActorAddress> }
+      : {}),
     ...(inbound.replyTo === undefined ? {} : { replyTo: String(inbound.replyTo) }),
     text: terminal.error === undefined ? String(terminal.output) : `error: ${String(terminal.error)}`,
     // The outcome rides as a typed field, so a reader never sniffs the text for failure.
@@ -51,26 +69,43 @@ export const replyReactor: Reactor<Router | Self> = (log) => {
       act: (input) =>
         Effect.gen(function* () {
           const at = yield* Clock.currentTimeMillis
-          if (input.replyTo === undefined) {
-            return [replyDelivered({ turn: input.id, at })]
-          }
-          const router = yield* Router
           const self = yield* Self
-          yield* router.deliver(
-            input.replyTo,
-            replyEvent({ id: input.id, text: input.text, outcome: input.outcome, from: self, at })
-          )
-          return [replyDelivered({ to: input.replyTo, turn: input.id, at })]
+          const event = replyEvent({
+            id: input.id,
+            text: input.text,
+            outcome: input.outcome,
+            from: formatActorAddress(self),
+            at
+          })
+          if (input.link !== undefined && isProviderAddress(input.link.source)) {
+            const router = yield* Router
+            yield* router.deliver(
+              reverseLink(input.link as Link<ProviderAddress, ActorAddress>),
+              event
+            )
+            return [replyDelivered({ to: input.link.source.provider, turn: input.id, at })]
+          }
+          if (input.link !== undefined && isActorAddress(input.link.source)) {
+            const router = yield* Router
+            yield* router.deliver(reverseLink(input.link as Link<ActorAddress, ActorAddress>), event)
+            return [replyDelivered({ to: formatActorAddress(input.link.source), turn: input.id, at })]
+          }
+          if (input.replyTo !== undefined) {
+            const router = yield* Router
+            yield* router.deliver(linkOf(self, parseActorAddress(input.replyTo)), event)
+            return [replyDelivered({ to: input.replyTo, turn: input.id, at })]
+          }
+          return [replyDelivered({ turn: input.id, at })]
         })
     })
   ]
 }
 
-// reply derives parent-delivery transitions and contributes no agent information.
+// reply derives parent-delivery transitions and contributes an empty agent view.
 export const reply: AgentComponent<Router | Self> = {
   name: "reply",
   derive: (log) => ({
-    info: { system: [], tools: [], context: [] },
+    view: { system: [], tools: [], context: [], output: [] },
     transitions: replyReactor(log)
   })
 }

package/src/agent/components/tool-list.ts

@@ -18,7 +18,7 @@ export const toolList = <R = never>(
 ): AgentComponent<R> => ({
   name: "tools",
   derive: (log) => ({
-    info: {
+    view: {
       system: [
         (typeof system === "function" ? system(log) : system) ||
           `You act on the world by calling the tools available to you: ${tools.map((tool) => tool.spec.name).join(", ")}.`
@@ -41,7 +41,8 @@ export const toolList = <R = never>(
           ]
         }
       })) as ReadonlyArray<AgentTool<unknown>>,
-      context: []
+      context: [],
+      output: []
     },
     transitions: []
   })