@effect-uai/core 0.5.2 → 0.6.0

package/src/tool/{Resolvers.test.ts → Approval.test.ts}

@@ -1,7 +1,7 @@
 /**
  * Tests for approval planners + history-reconciliation primitives. Exercises
  * the full HITL + streaming-tool stack end-to-end by composing approval plans
- * with `executeAll`, with the four wire-shaped scenarios:
+ * with `run`, with the four wire-shaped scenarios:
  *
  *   1. Approval        : gated calls approved → tools execute, structured Values
  *   2. Denial          : gated calls denied   → Failure(denied) results
@@ -14,16 +14,11 @@ import { Effect, Queue, Schema, Stream } from "effect"
 import { describe, expect, it } from "vitest"
 import * as Items from "../domain/Items.js"
 import { findUnansweredCalls, cancelAllPending, isReconciled } from "./HistoryCheck.js"
-import { type ToolResult, isFailure, isValue, toFunctionCallOutput } from "./Outcome.js"
-import {
-  type ApprovalMapEntry,
-  type ToolCallDecision,
-  fromApprovalMap,
-  fromVerdictQueue,
-} from "./Resolvers.js"
+import { type ToolResult, isFailure, isOk, toToolCallOutput } from "./ToolResult.js"
+import { type ApprovalMapEntry, type ApprovalDecision, fromMap, fromQueue } from "./Approval.js"
 import { fromEffectSchema, make as makeTool, streaming } from "./Tool.js"
-import { executeAll } from "./Toolkit.js"
-import { ToolEvent, isApprovalRequested, isIntermediate, isOutput } from "./ToolEvent.js"
+import { run } from "./Toolkit.js"
+import { ToolEvent, isApprovalRequested, isProgress, isOutput } from "./ToolEvent.js"
 
 // ---------------------------------------------------------------------------
 // Three demo tools covering the matrix:
@@ -71,9 +66,9 @@ const deleteDatabase = makeTool({
 
 const allTools = [webSearch, bulkEmail, deleteDatabase]
 const SENSITIVE = new Set(["bulk_email", "delete_database"])
-const isSensitive = (call: Items.FunctionCall) => SENSITIVE.has(call.name)
+const isSensitive = (call: Items.ToolCall) => SENSITIVE.has(call.name)
 
-const fc = (call_id: string, name: string, args: unknown): Items.FunctionCall => ({
+const fc = (call_id: string, name: string, args: unknown): Items.ToolCall => ({
   type: "function_call",
   call_id,
   name,
@@ -95,20 +90,20 @@ const rejectedStream = (rejected: ReadonlyArray<ToolResult>) =>
   Stream.fromIterable(rejected.map((result) => ToolEvent.Output({ result })))
 
 const eventsFromApprovalMap = (approvals: ReadonlyMap<string, ApprovalMapEntry>) => {
-  const plan = fromApprovalMap(isSensitive, approvals)(calls)
-  return Stream.merge(executeAll(allTools, plan.approved), rejectedStream(plan.rejected))
+  const plan = fromMap(isSensitive, approvals)(calls)
+  return Stream.merge(run(allTools, plan.approved), rejectedStream(plan.rejected))
 }
 
-const eventsFromDecision = (decision: ToolCallDecision): Stream.Stream<ToolEvent> =>
+const eventsFromDecision = (decision: ApprovalDecision): Stream.Stream<ToolEvent> =>
   decision._tag === "Approved"
-    ? executeAll(allTools, [decision.call])
+    ? run(allTools, [decision.call])
     : Stream.succeed(ToolEvent.Output({ result: decision.result }))
 
 // ---------------------------------------------------------------------------
-// fromApprovalMap: HTTP-style scenarios
+// fromMap: HTTP-style scenarios
 // ---------------------------------------------------------------------------
 
-describe("fromApprovalMap + executeAll", () => {
+describe("fromMap + run", () => {
   it("approval: all gated approved → tools execute, structured Values", async () => {
     const approvals = new Map<string, ApprovalMapEntry>([
       ["c2", { decision: "approve" }],
@@ -116,13 +111,13 @@ describe("fromApprovalMap + executeAll", () => {
     ])
     const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))
     const by = byCallId(resultsFrom(collected))
-    expect(by.get("c1")).toMatchObject({ _tag: "Value", value: { count: 3 } })
+    expect(by.get("c1")).toMatchObject({ _tag: "Ok", value: { count: 3 } })
     expect(by.get("c2")).toMatchObject({
-      _tag: "Value",
+      _tag: "Ok",
       value: { status: "sent", delivered: 2 },
     })
     expect(by.get("c3")).toMatchObject({
-      _tag: "Value",
+      _tag: "Ok",
       value: { status: "dropped", name: "prod" },
     })
 
@@ -138,7 +133,7 @@ describe("fromApprovalMap + executeAll", () => {
     const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))
 
     // bulk_email never ran.
-    expect(collected.filter(isIntermediate).filter((e) => e.tool === "bulk_email")).toHaveLength(0)
+    expect(collected.filter(isProgress).filter((e) => e.tool === "bulk_email")).toHaveLength(0)
 
     const by = byCallId(resultsFrom(collected))
     expect(by.get("c2")).toMatchObject({
@@ -156,7 +151,7 @@ describe("fromApprovalMap + executeAll", () => {
   it("cancellation: missing verdicts → Failure(cancelled)", async () => {
     const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(new Map())))
     const by = byCallId(resultsFrom(collected))
-    expect(by.get("c1")).toMatchObject({ _tag: "Value", value: { count: 3 } })
+    expect(by.get("c1")).toMatchObject({ _tag: "Ok", value: { count: 3 } })
     expect(by.get("c2")).toMatchObject({ _tag: "Failure", kind: "cancelled" })
     expect(by.get("c3")).toMatchObject({ _tag: "Failure", kind: "cancelled" })
   })
@@ -168,8 +163,8 @@ describe("fromApprovalMap + executeAll", () => {
     ])
     const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))
     const by = byCallId(resultsFrom(collected))
-    expect(by.get("c1")).toMatchObject({ _tag: "Value", value: { count: 3 } })
-    expect(by.get("c2")).toMatchObject({ _tag: "Value", value: { status: "sent" } })
+    expect(by.get("c1")).toMatchObject({ _tag: "Ok", value: { count: 3 } })
+    expect(by.get("c2")).toMatchObject({ _tag: "Ok", value: { status: "sent" } })
     expect(by.get("c3")).toMatchObject({ _tag: "Failure", kind: "cancelled" })
   })
 })
@@ -178,7 +173,7 @@ describe("fromApprovalMap + executeAll", () => {
 // Graceful degradation: hallucinated tool name doesn't kill the turn.
 // ---------------------------------------------------------------------------
 
-describe("executeAll: graceful degradation", () => {
+describe("run: graceful degradation", () => {
   it("unknown tool name → Failure(unknown_tool); other calls still execute", async () => {
     const callsWithBogus = [
       fc("c1", "web_search", { query: "x" }),
@@ -188,26 +183,26 @@ describe("executeAll: graceful degradation", () => {
     const collected = await Effect.runPromise(
       Stream.runCollect(
         (() => {
-          const plan = fromApprovalMap(
+          const plan = fromMap(
             isSensitive,
             new Map([["c3", { decision: "approve" }]]),
           )(callsWithBogus)
-          return Stream.merge(executeAll(allTools, plan.approved), rejectedStream(plan.rejected))
+          return Stream.merge(run(allTools, plan.approved), rejectedStream(plan.rejected))
         })(),
       ),
     )
     const by = byCallId(resultsFrom(collected))
-    expect(by.get("c1")).toMatchObject({ _tag: "Value" })
+    expect(by.get("c1")).toMatchObject({ _tag: "Ok" })
     expect(by.get("c2")).toMatchObject({ _tag: "Failure", kind: "unknown_tool" })
-    expect(by.get("c3")).toMatchObject({ _tag: "Value", value: { status: "dropped" } })
+    expect(by.get("c3")).toMatchObject({ _tag: "Ok", value: { status: "dropped" } })
   })
 })
 
 // ---------------------------------------------------------------------------
-// fromVerdictQueue: WebSocket-style scenarios
+// fromQueue: WebSocket-style scenarios
 // ---------------------------------------------------------------------------
 
-describe("fromVerdictQueue + executeAll", () => {
+describe("fromQueue + run", () => {
   it("queue-driven: approve + deny resolve correctly with ApprovalRequested events", async () => {
     const collected = await Effect.runPromise(
       Effect.gen(function* () {
@@ -223,17 +218,17 @@ describe("fromVerdictQueue + executeAll", () => {
           reason: "too risky",
         })
 
-        // Stream.unwrap supplies the Scope for fromVerdictQueue's router.
+        // Stream.unwrap supplies the Scope for fromQueue's router.
         const events = Stream.unwrap(
           Effect.gen(function* () {
-            const { approved, decisions, announce } = yield* fromVerdictQueue(
+            const { approved, decisions, approvalRequests } = yield* fromQueue(
               isSensitive,
               verdicts,
             )(calls)
             return Stream.merge(
-              announce,
+              approvalRequests,
               Stream.merge(
-                executeAll(allTools, approved),
+                run(allTools, approved),
                 decisions.pipe(Stream.flatMap(eventsFromDecision)),
               ),
             )
@@ -246,7 +241,7 @@ describe("fromVerdictQueue + executeAll", () => {
     expect(collected.filter(isApprovalRequested)).toHaveLength(2)
 
     const by = byCallId(resultsFrom(collected))
-    expect(by.get("c2")).toMatchObject({ _tag: "Value", value: { status: "sent" } })
+    expect(by.get("c2")).toMatchObject({ _tag: "Ok", value: { status: "sent" } })
     expect(by.get("c3")).toMatchObject({
       _tag: "Failure",
       kind: "denied",
@@ -262,7 +257,7 @@ describe("fromVerdictQueue + executeAll", () => {
 describe("findUnansweredCalls / cancelAllPending / isReconciled", () => {
   const orphan = fc("c99", "delete_database", { name: "prod" })
   const answered = fc("c98", "web_search", { query: "x" })
-  const answeredOutput = Items.functionCallOutput("c98", JSON.stringify({ count: 0 }))
+  const answeredOutput = Items.toolCallOutput("c98", JSON.stringify({ count: 0 }))
 
   it("findUnansweredCalls returns only orphans", () => {
     const history = [Items.userText("hi"), answered, orphan, answeredOutput]
@@ -274,7 +269,7 @@ describe("findUnansweredCalls / cancelAllPending / isReconciled", () => {
   it("isReconciled is false when orphans exist, true otherwise", () => {
     const stale = [Items.userText("hi"), orphan]
     expect(isReconciled(stale)).toBe(false)
-    const reconciled = [...stale, ...cancelAllPending(stale).map(toFunctionCallOutput)]
+    const reconciled = [...stale, ...cancelAllPending(stale).map(toToolCallOutput)]
     expect(isReconciled(reconciled)).toBe(true)
   })
 
@@ -292,14 +287,10 @@ describe("findUnansweredCalls / cancelAllPending / isReconciled", () => {
     })
   })
 
-  it("follow-up: map closures to FunctionCallOutput before appending new user message", () => {
+  it("follow-up: map closures to ToolCallOutput before appending new user message", () => {
     const stale = [Items.userText("first request"), orphan]
     const closures = cancelAllPending(stale, "user redirected")
-    const reconciled = [
-      ...stale,
-      ...closures.map(toFunctionCallOutput),
-      Items.userText("never mind"),
-    ]
+    const reconciled = [...stale, ...closures.map(toToolCallOutput), Items.userText("never mind")]
     expect(findUnansweredCalls(reconciled)).toHaveLength(0)
   })
 })
@@ -308,15 +299,15 @@ describe("findUnansweredCalls / cancelAllPending / isReconciled", () => {
 // Wire conversion
 // ---------------------------------------------------------------------------
 
-describe("toFunctionCallOutput", () => {
+describe("toToolCallOutput", () => {
   it("round-trips a Value result", () => {
     const r: ToolResult = {
-      _tag: "Value",
+      _tag: "Ok",
       call_id: "c1",
       tool: "web_search",
       value: { count: 3 },
     }
-    const out = toFunctionCallOutput(r)
+    const out = toToolCallOutput(r)
     expect(out.call_id).toBe("c1")
     expect(JSON.parse(out.output)).toEqual({ count: 3 })
   })
@@ -329,7 +320,7 @@ describe("toFunctionCallOutput", () => {
       kind: "denied",
       reason: "spam concern",
     }
-    const out = toFunctionCallOutput(r)
+    const out = toToolCallOutput(r)
     expect(JSON.parse(out.output)).toEqual({ kind: "denied", reason: "spam concern" })
   })
 
@@ -340,19 +331,19 @@ describe("toFunctionCallOutput", () => {
       tool: "delete_database",
       kind: "cancelled",
     }
-    const out = toFunctionCallOutput(r)
+    const out = toToolCallOutput(r)
     expect(JSON.parse(out.output)).toEqual({ kind: "cancelled" })
   })
 })
 
 // ---------------------------------------------------------------------------
-// executeAll
+// run
 // ---------------------------------------------------------------------------
 
-describe("executeAll", () => {
+describe("run", () => {
   it("runs all calls passed to it", async () => {
-    const collected = await Effect.runPromise(Stream.runCollect(executeAll(allTools, calls)))
+    const collected = await Effect.runPromise(Stream.runCollect(run(allTools, calls)))
     expect(collected.filter(isOutput)).toHaveLength(3)
-    expect(collected.filter(isOutput).every((e) => isValue(e.result))).toBe(true)
+    expect(collected.filter(isOutput).every((e) => isOk(e.result))).toBe(true)
   })
 })

package/src/tool/{Resolvers.ts → Approval.ts}

@@ -3,31 +3,31 @@
  *
  * These helpers only decide which calls are approved and which synthetic
  * results must be returned to the model. Tool execution stays explicit at
- * the recipe boundary via `Toolkit.executeAll`.
+ * the recipe boundary via `Toolkit.run`.
  */
 import { Data, Deferred, Effect, Queue, Scope, Stream } from "effect"
-import type { FunctionCall } from "../domain/Items.js"
-import { type ToolResult, cancelled, denied } from "./Outcome.js"
+import type { ToolCall } from "../domain/Items.js"
+import { type ToolResult, cancelled, denied } from "./ToolResult.js"
 import { ToolEvent } from "./ToolEvent.js"
 
 export type ToolCallPlan = {
-  readonly approved: ReadonlyArray<FunctionCall>
+  readonly approved: ReadonlyArray<ToolCall>
   readonly rejected: ReadonlyArray<ToolResult>
 }
 
-export type ToolCallDecision = Data.TaggedEnum<{
-  Approved: { readonly call: FunctionCall }
+export type ApprovalDecision = Data.TaggedEnum<{
+  Approved: { readonly call: ToolCall }
   Rejected: { readonly result: ToolResult }
 }>
 
-export const ToolCallDecision = Data.taggedEnum<ToolCallDecision>()
+export const ApprovalDecision = Data.taggedEnum<ApprovalDecision>()
 
-export const approve = (call: FunctionCall): ToolCallDecision => ToolCallDecision.Approved({ call })
+export const approve = (call: ToolCall): ApprovalDecision => ApprovalDecision.Approved({ call })
 
-export const reject = (result: ToolResult): ToolCallDecision =>
-  ToolCallDecision.Rejected({ result })
+export const reject = (result: ToolResult): ApprovalDecision =>
+  ApprovalDecision.Rejected({ result })
 
-export const splitToolCallDecisions = (decisions: ReadonlyArray<ToolCallDecision>): ToolCallPlan =>
+export const splitApprovalDecisions = (decisions: ReadonlyArray<ApprovalDecision>): ToolCallPlan =>
   decisions.reduce<ToolCallPlan>(
     (acc, decision) =>
       decision._tag === "Approved"
@@ -36,7 +36,7 @@ export const splitToolCallDecisions = (decisions: ReadonlyArray<ToolCallDecision
     { approved: [], rejected: [] },
   )
 
-export const approvalRequested = (call: FunctionCall): ToolEvent =>
+export const approvalRequested = (call: ToolCall): ToolEvent =>
   ToolEvent.ApprovalRequested({
     call_id: call.call_id,
     tool: call.name,
@@ -56,17 +56,17 @@ export type Verdict = {
 /**
  * Queue-backed approval planner. Safe calls are returned immediately in
  * `approved`; gated calls emit `ApprovalRequested` events and later produce
- * one `ToolCallDecision` when their matching verdict arrives.
+ * one `ApprovalDecision` when their matching verdict arrives.
  */
-export const fromVerdictQueue =
-  (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) =>
+export const fromQueue =
+  (predicate: (call: ToolCall) => boolean, verdicts: Queue.Dequeue<Verdict>) =>
   (
-    calls: ReadonlyArray<FunctionCall>,
+    calls: ReadonlyArray<ToolCall>,
   ): Effect.Effect<
     {
-      readonly approved: ReadonlyArray<FunctionCall>
-      readonly decisions: Stream.Stream<ToolCallDecision>
-      readonly announce: Stream.Stream<ToolEvent>
+      readonly approved: ReadonlyArray<ToolCall>
+      readonly decisions: Stream.Stream<ApprovalDecision>
+      readonly approvalRequests: Stream.Stream<ToolEvent>
     },
     never,
     Scope.Scope
@@ -109,9 +109,9 @@ export const fromVerdictQueue =
         ),
       )
 
-      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))
+      const approvalRequests = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))
 
-      return { approved, decisions, announce }
+      return { approved, decisions, approvalRequests }
     })
 
 // ---------------------------------------------------------------------------
@@ -123,10 +123,10 @@ export type ApprovalMapEntry =
   | { readonly decision: "approve" }
   | { readonly decision: "deny"; readonly reason?: string }
 
-export const fromApprovalMap =
-  (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>
-  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>
-    splitToolCallDecisions(
+export const fromMap =
+  (predicate: (call: ToolCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>
+  (calls: ReadonlyArray<ToolCall>): ToolCallPlan =>
+    splitApprovalDecisions(
       calls.map((call) => {
         if (!predicate(call)) return approve(call)
         const v = approvals.get(call.call_id)

package/src/tool/HistoryCheck.ts

@@ -10,37 +10,34 @@
  * Recipe author calls these at known transition points (right before the
  * next provider request). Not invoked from inside the loop.
  */
-import {
-  type FunctionCall,
-  type Item,
-  isFunctionCall,
-  isFunctionCallOutput,
-} from "../domain/Items.js"
-import { type ToolResult, cancelled } from "./Outcome.js"
+import { type ToolCall, type HistoryItem, isToolCall, isToolCallOutput } from "../domain/Items.js"
+import { type ToolResult, cancelled } from "./ToolResult.js"
 
 /**
  * Return every `function_call` in `history` that does not have a matching
  * `function_call_output` later in `history` (correlated by `call_id`).
  * Empty result = history is provider-submittable from this invariant.
  */
-export const findUnansweredCalls = (history: ReadonlyArray<Item>): ReadonlyArray<FunctionCall> => {
-  const answered = new Set(history.filter(isFunctionCallOutput).map((o) => o.call_id))
-  return history.filter(isFunctionCall).filter((c) => !answered.has(c.call_id))
+export const findUnansweredCalls = (
+  history: ReadonlyArray<HistoryItem>,
+): ReadonlyArray<ToolCall> => {
+  const answered = new Set(history.filter(isToolCallOutput).map((o) => o.call_id))
+  return history.filter(isToolCall).filter((c) => !answered.has(c.call_id))
 }
 
 /** Cheap predicate: is this history submittable to a provider? */
-export const isReconciled = (history: ReadonlyArray<Item>): boolean =>
+export const isReconciled = (history: ReadonlyArray<HistoryItem>): boolean =>
   findUnansweredCalls(history).length === 0
 
 /**
  * Synthesize cancellation results for every unanswered call. Caller maps
- * via `toFunctionCallOutput` and appends to history before submitting.
+ * via `toToolCallOutput` and appends to history before submitting.
  *
  * Use when: a new user message arrives mid-approval; an approval timer
  * fires; a persisted checkpoint contains orphans (crash recovery); a
  * stateless HTTP server reconstructed history from a stale checkpoint.
  */
 export const cancelAllPending = (
-  history: ReadonlyArray<Item>,
+  history: ReadonlyArray<HistoryItem>,
   reason?: string,
 ): ReadonlyArray<ToolResult> => findUnansweredCalls(history).map((call) => cancelled(call, reason))

package/src/tool/Tool.ts

@@ -1,7 +1,7 @@
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec"
 import { Effect, Schema, Stream } from "effect"
-import type { FunctionCall, FunctionCallOutput } from "../domain/Items.js"
-import { functionCallOutput } from "../domain/Items.js"
+import type { ToolCall, ToolCallOutput } from "../domain/Items.js"
+import { toolCallOutput } from "../domain/Items.js"
 
 export class ToolError extends Schema.TaggedErrorClass<ToolError>("@betalyra/effect-uai/ToolError")(
   "ToolError",
@@ -73,7 +73,7 @@ export type Tool<Name extends string, Input, Output, R = never> = {
 /**
  * Provider-agnostic tool descriptor. Each provider maps `inputSchema`
  * to its own wire field (OpenAI → `parameters`, Anthropic →
- * `input_schema`). Built from a `Tool` by `Toolkit.toDescriptors`.
+ * `input_schema`). Built from a `Tool` by `Tool.toDescriptors`.
  */
 export type ToolDescriptor = {
   readonly name: string
@@ -90,7 +90,7 @@ export const make = <Name extends string, Input, Output, R = never>(
 // Streaming tools
 //
 // `run` returns a `Stream<Event>` instead of an `Effect<Output>`. Events
-// flow through to the consumer as `ToolEvent.Intermediate`s in real time;
+// flow through to the consumer as `ToolEvent.Progress`s in real time;
 // at end-of-stream `finalize(events)` reduces them to the model-facing
 // `Output`. Sub-agents, slow downloads with progress, recipe streamers.
 // ---------------------------------------------------------------------------
@@ -111,19 +111,17 @@ export const streaming = <Name extends string, Input, Event, Output, R = never>(
 
 export type AnyStreamingTool<R = any> = StreamingTool<string, any, any, any, R>
 export type AnyPlainTool<R = any> = Tool<string, any, any, R>
-export type AnyKindTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>
+export type AnyTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>
 
-export const isStreamingTool = <R>(t: AnyKindTool<R>): t is AnyStreamingTool<R> =>
+export const isStreamingTool = <R>(t: AnyTool<R>): t is AnyStreamingTool<R> =>
   "_kind" in t && t._kind === "streaming"
 
 /**
  * Render any-kind tools (mixed plain and streaming) to provider-agnostic
- * descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type
- * so a single list can carry both kinds.
+ * descriptors. Accepts the union type so a single list can carry both
+ * plain and streaming tools.
  */
-export const toDescriptors = <R>(
-  tools: ReadonlyArray<AnyKindTool<R>>,
-): ReadonlyArray<ToolDescriptor> =>
+export const toDescriptors = <R>(tools: ReadonlyArray<AnyTool<R>>): ReadonlyArray<ToolDescriptor> =>
   tools.map((tool) => {
     const inputSchema = tool.inputSchema["~standard"].jsonSchema.input({
       target: "draft-2020-12",
@@ -133,7 +131,7 @@ export const toDescriptors = <R>(
       : { name: tool.name, description: tool.description, inputSchema }
   })
 
-const toToolError = (call: FunctionCall, toolName: string, message: string) => (cause: unknown) =>
+const toToolError = (call: ToolCall, toolName: string, message: string) => (cause: unknown) =>
   new ToolError({ call_id: call.call_id, tool: toolName, message, cause })
 
 /**
@@ -143,8 +141,8 @@ const toToolError = (call: FunctionCall, toolName: string, message: string) => (
  */
 export const execute = <Name extends string, Input, Output, R>(
   tool: Tool<Name, Input, Output, R>,
-  call: FunctionCall,
-): Effect.Effect<FunctionCallOutput, ToolError, R> =>
+  call: ToolCall,
+): Effect.Effect<ToolCallOutput, ToolError, R> =>
   Effect.gen(function* () {
     const parsed = yield* Effect.try({
       try: () => JSON.parse(call.arguments) as unknown,
@@ -166,5 +164,5 @@ export const execute = <Name extends string, Input, Output, R>(
     const output = yield* tool
       .run(result.value)
       .pipe(Effect.mapError(toToolError(call, tool.name, "Tool execution failed")))
-    return functionCallOutput(call.call_id, JSON.stringify(output))
+    return toolCallOutput(call.call_id, JSON.stringify(output))
   })

package/src/tool/ToolEvent.ts

@@ -2,14 +2,14 @@
  * The event type emitted while handling tool calls.
  *
  *   - ApprovalRequested : gated calls waiting for approval
- *   - Intermediate      : per-element passthrough from a streaming tool's run
+ *   - Progress          : per-element passthrough from a streaming tool's run
  *   - Output            : terminal result (carries a structured ToolResult)
  *
- * Recipes thread `ToolEvent.Output.result` through `continueWith` and apply
- * `toFunctionCallOutput` when appending to history.
+ * Recipes thread `ToolEvent.Output.result` through `continueWithResults` and
+ * apply `toToolCallOutput` when appending to history.
  */
 import { Data } from "effect"
-import type { ToolResult } from "./Outcome.js"
+import type { ToolResult } from "./ToolResult.js"
 
 export type ToolEvent = Data.TaggedEnum<{
   ApprovalRequested: {
@@ -17,7 +17,7 @@ export type ToolEvent = Data.TaggedEnum<{
     readonly tool: string
     readonly arguments: string
   }
-  Intermediate: {
+  Progress: {
     readonly call_id: string
     readonly tool: string
     readonly data: unknown
@@ -31,11 +31,11 @@ export type ToolEvent = Data.TaggedEnum<{
  * Namespace of constructors, type guards, and matchers for `ToolEvent`,
  * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
  * an event, `ToolEvent.$is("Output")` for type narrowing,
- * `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for
+ * `ToolEvent.$match({ ApprovalRequested, Progress, Output })` for
  * exhaustive pattern matching.
  */
 export const ToolEvent = Data.taggedEnum<ToolEvent>()
 
 export const isApprovalRequested = ToolEvent.$is("ApprovalRequested")
-export const isIntermediate = ToolEvent.$is("Intermediate")
+export const isProgress = ToolEvent.$is("Progress")
 export const isOutput = ToolEvent.$is("Output")

package/src/tool/{Outcome.ts → ToolResult.ts}

@@ -1,10 +1,10 @@
 /**
  * Post-execution and synthetic tool results.
  *
- *   - Executed tools emit ToolResult.Value.
+ *   - Executed tools emit ToolResult.Ok.
  *   - Approval/cancellation policy emits synthetic ToolResult.Failure.
  *
- * Wire conversion stays at the recipe boundary via `toFunctionCallOutput`
+ * Wire conversion stays at the recipe boundary via `toToolCallOutput`
  * so recipes can inspect, redact, or audit values before serialization.
  *
  * `output` and `reason` are `string`, not `unknown`: the wire wants strings,
@@ -12,15 +12,15 @@
  * fn). Recipes that want structured detail JSON.stringify themselves.
  */
 import { Data } from "effect"
-import type { FunctionCall, FunctionCallOutput } from "../domain/Items.js"
-import { functionCallOutput } from "../domain/Items.js"
+import type { ToolCall, ToolCallOutput } from "../domain/Items.js"
+import { toolCallOutput } from "../domain/Items.js"
 
 // ---------------------------------------------------------------------------
 // ToolResult
 // ---------------------------------------------------------------------------
 
 export type ToolResult = Data.TaggedEnum<{
-  Value: {
+  Ok: {
     readonly call_id: string
     readonly tool: string
     readonly value: unknown
@@ -35,22 +35,22 @@ export type ToolResult = Data.TaggedEnum<{
 
 /**
  * Namespace of constructors, type guards, and matchers for `ToolResult`,
- * provided by `Data.taggedEnum`. Use `ToolResult.$is("Value")` for type
- * narrowing and `ToolResult.$match({ Value, Failure })` for exhaustive
+ * provided by `Data.taggedEnum`. Use `ToolResult.$is("Ok")` for type
+ * narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive
  * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
- * `executionError`, `rejected`) below are kinder constructors than the
+ * `executionError`, `failed`) below are kinder constructors than the
  * raw `ToolResult.Failure(...)`.
  */
 export const ToolResult = Data.taggedEnum<ToolResult>()
 
-export const isValue = ToolResult.$is("Value")
+export const isOk = ToolResult.$is("Ok")
 export const isFailure = ToolResult.$is("Failure")
 
 // Synthesizers. `denied` and `cancelled` are operationally distinct;
-// anything else is just a recipe-chosen `kind` via `rejected`.
+// anything else is just a recipe-chosen `kind` via `failed`.
 // ---------------------------------------------------------------------------
 
-export const rejected = (call: FunctionCall, kind: string, reason?: string): ToolResult =>
+export const failed = (call: ToolCall, kind: string, reason?: string): ToolResult =>
   ToolResult.Failure({
     call_id: call.call_id,
     tool: call.name,
@@ -59,26 +59,26 @@ export const rejected = (call: FunctionCall, kind: string, reason?: string): Too
   })
 
 /** Explicit user/policy rejection. */
-export const denied = (call: FunctionCall, reason?: string): ToolResult =>
-  rejected(call, "denied", reason)
+export const denied = (call: ToolCall, reason?: string): ToolResult =>
+  failed(call, "denied", reason)
 
 /** Implicit non-answer (follow-up, inactivity, abort). */
-export const cancelled = (call: FunctionCall, reason?: string): ToolResult =>
-  rejected(call, "cancelled", reason)
+export const cancelled = (call: ToolCall, reason?: string): ToolResult =>
+  failed(call, "cancelled", reason)
 
 /** Tool's own execution failed (parse error, schema, runtime crash). */
-export const executionError = (call: FunctionCall, reason: string): ToolResult =>
-  rejected(call, "execution_error", reason)
+export const executionError = (call: ToolCall, reason: string): ToolResult =>
+  failed(call, "execution_error", reason)
 
 // ---------------------------------------------------------------------------
 // Wire conversion - the one place structured → string happens.
 // ---------------------------------------------------------------------------
 
-export const toFunctionCallOutput = (r: ToolResult): FunctionCallOutput =>
+export const toToolCallOutput = (r: ToolResult): ToolCallOutput =>
   ToolResult.$match(r, {
-    Value: (v) => functionCallOutput(v.call_id, JSON.stringify(v.value)),
+    Ok: (v) => toolCallOutput(v.call_id, JSON.stringify(v.value)),
     Failure: (f) =>
-      functionCallOutput(
+      toolCallOutput(
         f.call_id,
         JSON.stringify(
           f.reason !== undefined ? { kind: f.kind, reason: f.reason } : { kind: f.kind },