@batonfx/foldkit 0.1.0 → 0.2.0

package/src/chat.ts

@@ -1,21 +1,29 @@
 import { Cause, Equivalence, Effect, Option, Schema, Stream } from "effect"
-import * as Ai from "effect/unstable/ai"
-import * as Command from "foldkit/command"
+import { Prompt } from "effect/unstable/ai"
+import { define, type Command } from "foldkit/command"
 import { m } from "foldkit/message"
 import type { CallableTaggedStruct } from "foldkit/schema"
-import * as Subscription from "foldkit/subscription"
+import { make } from "foldkit/subscription"
 import { Wire } from "@batonfx/transport"
-import * as Connection from "./connection"
-
+import { AgentConnection, Incoming, SendFailed } from "./connection"
 const CompletedFields = { isFailure: Schema.Boolean, result: Schema.Unknown }
 const UserEntryFields = { text: Schema.String }
 const AssistantEntryFields = { text: Schema.String, reasoning: Schema.NullOr(Schema.String) }
 const RunCompletedFields = { text: Schema.String }
 const StringReasonFields = { reason: Schema.String }
+const OpenedSessionFields = { sessionId: Schema.String }
+
+/** @experimental */
+export const ToolPendingPhase = Schema.Literals(["called", "executing"])
+
+/** @experimental */
+export type ToolPendingPhase = typeof ToolPendingPhase.Type
+
 const ToolEntryFields = {
   callId: Schema.String,
   name: Schema.String,
   params: Schema.Unknown,
+  phase: ToolPendingPhase,
   outcome: Schema.suspend((): Schema.Schema<ToolOutcome> => ToolOutcome),
   progress: Schema.Array(Schema.String),
 }
@@ -26,7 +34,7 @@ const AwaitingApprovalFields = {
   params: Schema.Unknown,
 }
 const ClickedDenyFields = { reason: Schema.NullOr(Schema.String) }
-const ReceivedAgentFields = { incoming: Connection.Incoming }
+const ReceivedAgentFields = { incoming: Incoming }
 const ModelStreaming = Schema.Struct({
   turn: Schema.Number,
   text: Schema.String,
@@ -112,6 +120,12 @@ export const ReceivedAgent: CallableTaggedStruct<"ReceivedAgent", typeof Receive
   ReceivedAgentFields,
 )
 
+/** @experimental */
+export const OpenedSession: CallableTaggedStruct<"OpenedSession", typeof OpenedSessionFields> = m(
+  "OpenedSession",
+  OpenedSessionFields,
+)
+
 /** @experimental */
 export const ChangedDraft: CallableTaggedStruct<"ChangedDraft", typeof UserEntryFields> = m(
   "ChangedDraft",
@@ -151,6 +165,7 @@ export const FailedAgentCommand: CallableTaggedStruct<"FailedAgentCommand", type
 /** @experimental */
 export type Message =
   | typeof ReceivedAgent.Type
+  | typeof OpenedSession.Type
   | typeof ChangedDraft.Type
   | typeof SubmittedMessage.Type
   | typeof ClickedCancel.Type
@@ -164,6 +179,7 @@ export type Message =
 /** @experimental */
 export const Message: Schema.Schema<Message> = Schema.Union([
   ReceivedAgent,
+  OpenedSession,
   ChangedDraft,
   SubmittedMessage,
   ClickedCancel,
@@ -196,7 +212,124 @@ export type OutMessage = typeof RunCompleted.Type | typeof ApprovalRequired.Type
 export const OutMessage: Schema.Schema<OutMessage> = Schema.Union([RunCompleted, ApprovalRequired, RunFailed])
 
 /** @experimental */
-export type ChatCommand = Command.Command<Message, any, Connection.AgentConnection>
+export const MessageAlign = Schema.Literals(["start", "end"])
+
+/** @experimental */
+export type MessageAlign = typeof MessageAlign.Type
+
+/** @experimental */
+export const PromptInputStatus = Schema.Literals(["idle", "submitted", "streaming", "error"])
+
+/** @experimental */
+export type PromptInputStatus = typeof PromptInputStatus.Type
+
+/** @experimental */
+export const ToolStatus = Schema.Literals(["input-streaming", "input-available", "output-available", "output-error"])
+
+/** @experimental */
+export type ToolStatus = typeof ToolStatus.Type
+
+/** @experimental */
+export const UserConversationItem: CallableTaggedStruct<
+  "UserConversationItem",
+  { key: typeof Schema.String; align: typeof MessageAlign; entry: typeof UserEntry }
+> = m("UserConversationItem", { key: Schema.String, align: MessageAlign, entry: UserEntry })
+
+/** @experimental */
+export const AssistantConversationItem: CallableTaggedStruct<
+  "AssistantConversationItem",
+  { key: typeof Schema.String; align: typeof MessageAlign; entry: typeof AssistantEntry }
+> = m("AssistantConversationItem", { key: Schema.String, align: MessageAlign, entry: AssistantEntry })
+
+/** @experimental */
+export const ToolConversationItem: CallableTaggedStruct<
+  "ToolConversationItem",
+  {
+    key: typeof Schema.String
+    align: typeof MessageAlign
+    entry: typeof ToolEntry
+    status: typeof ToolStatus
+    input: typeof Schema.String
+  }
+> = m("ToolConversationItem", {
+  key: Schema.String,
+  align: MessageAlign,
+  entry: ToolEntry,
+  status: ToolStatus,
+  input: Schema.String,
+})
+
+/** @experimental */
+export const StreamingConversationItem: CallableTaggedStruct<
+  "StreamingConversationItem",
+  {
+    key: typeof Schema.String
+    align: typeof MessageAlign
+    text: typeof Schema.String
+    reasoning: typeof Schema.String
+    isStreaming: typeof Schema.Boolean
+  }
+> = m("StreamingConversationItem", {
+  key: Schema.String,
+  align: MessageAlign,
+  text: Schema.String,
+  reasoning: Schema.String,
+  isStreaming: Schema.Boolean,
+})
+
+/** @experimental */
+export const WaitingConversationItem: CallableTaggedStruct<
+  "WaitingConversationItem",
+  { key: typeof Schema.String; align: typeof MessageAlign }
+> = m("WaitingConversationItem", { key: Schema.String, align: MessageAlign })
+
+/** @experimental */
+export const ApprovalConversationItem: CallableTaggedStruct<
+  "ApprovalConversationItem",
+  {
+    key: typeof Schema.String
+    align: typeof MessageAlign
+    token: typeof Schema.String
+    toolName: typeof Schema.String
+    params: typeof Schema.Unknown
+  }
+> = m("ApprovalConversationItem", {
+  key: Schema.String,
+  align: MessageAlign,
+  token: Schema.String,
+  toolName: Schema.String,
+  params: Schema.Unknown,
+})
+
+/** @experimental */
+export const FailureConversationItem: CallableTaggedStruct<
+  "FailureConversationItem",
+  { key: typeof Schema.String; align: typeof MessageAlign; message: typeof Schema.String }
+> = m("FailureConversationItem", { key: Schema.String, align: MessageAlign, message: Schema.String })
+
+/** @experimental */
+export type ConversationItem =
+  | typeof UserConversationItem.Type
+  | typeof AssistantConversationItem.Type
+  | typeof ToolConversationItem.Type
+  | typeof StreamingConversationItem.Type
+  | typeof WaitingConversationItem.Type
+  | typeof ApprovalConversationItem.Type
+  | typeof FailureConversationItem.Type
+
+/** @experimental */
+export const ConversationItem: Schema.Schema<ConversationItem> = Schema.Union([
+  UserConversationItem,
+  AssistantConversationItem,
+  ToolConversationItem,
+  StreamingConversationItem,
+  WaitingConversationItem,
+  ApprovalConversationItem,
+  FailureConversationItem,
+])
+
+/** @experimental */
+export type ChatCommand = Command<Message, any, AgentConnection>
 
 /** @experimental */
 export const initialModel = (sessionId: string | null = null): Model => ({
@@ -212,19 +345,19 @@ export const initialModel = (sessionId: string | null = null): Model => ({
 type FailedAgentCommandMessage = typeof FailedAgentCommand.Type
 
 const commandFailed = (error: unknown): FailedAgentCommandMessage =>
-  FailedAgentCommand({ reason: error instanceof Connection.SendFailed ? error.reason : String(error) })
+  FailedAgentCommand({ reason: error instanceof SendFailed ? error.reason : String(error) })
 
-const catchCommandFailure = <A>(effect: Effect.Effect<A, Connection.SendFailed, Connection.AgentConnection>) =>
+const catchCommandFailure = <A>(effect: Effect.Effect<A, SendFailed, AgentConnection>) =>
   effect.pipe(Effect.catchCause((cause) => Effect.succeed(commandFailed(Cause.squash(cause)))))
 
 /** @experimental */
-export const SendUserMessage = Command.define(
+export const SendUserMessage = define(
   "SendUserMessage",
   { sessionId: Schema.String, text: Schema.String },
   SentUserMessage,
   FailedAgentCommand,
 )(({ sessionId, text }) =>
-  Connection.AgentConnection.use((connection) =>
+  AgentConnection.use((connection) =>
     catchCommandFailure(
       connection.send({ _tag: "SendMessage", sessionId, prompt: text }).pipe(Effect.as(SentUserMessage())),
     ),
@@ -232,7 +365,7 @@ export const SendUserMessage = Command.define(
 )
 
 /** @experimental */
-export const ResolveApproval = Command.define(
+export const ResolveApproval = define(
   "ResolveApproval",
   {
     sessionId: Schema.String,
@@ -248,7 +381,7 @@ export const ResolveApproval = Command.define(
     : reason === null
       ? { _tag: "Denied" }
       : { _tag: "Denied", reason }
-  return Connection.AgentConnection.use((connection) =>
+  return AgentConnection.use((connection) =>
     catchCommandFailure(
       connection.send({ _tag: "ResolveApproval", sessionId, token, decision }).pipe(Effect.as(ResolvedApproval())),
     ),
@@ -256,13 +389,13 @@ export const ResolveApproval = Command.define(
 })
 
 /** @experimental */
-export const CancelRun = Command.define(
+export const CancelRun = define(
   "CancelRun",
   { sessionId: Schema.String },
   CancelledRun,
   FailedAgentCommand,
 )(({ sessionId }) =>
-  Connection.AgentConnection.use((connection) =>
+  AgentConnection.use((connection) =>
     catchCommandFailure(connection.send({ _tag: "Cancel", sessionId }).pipe(Effect.as(CancelledRun()))),
   ),
 )
@@ -322,15 +455,22 @@ const flushStreaming = (model: Model): Model => {
   return { ...model, entries: [...model.entries, ...entry], streaming: null }
 }
 
-const upsertToolCall = (entries: ReadonlyArray<ChatEntry>, call: ToolCallLike): ReadonlyArray<ChatEntry> => {
+const upsertToolCall = (
+  entries: ReadonlyArray<ChatEntry>,
+  call: ToolCallLike,
+  phase: ToolPendingPhase = "called",
+): ReadonlyArray<ChatEntry> => {
   const index = entries.findIndex((entry) => entry._tag === "ToolEntry" && entry.callId === call.id)
   const previous = index >= 0 ? entries[index] : undefined
+  const previousToolEntry = previous?._tag === "ToolEntry" ? previous : undefined
+  const nextPhase = previousToolEntry?.phase === "executing" || phase === "executing" ? "executing" : "called"
   const next = ToolEntry({
     callId: call.id,
     name: call.name,
-    params: call.params,
-    outcome: previous?._tag === "ToolEntry" ? previous.outcome : Pending(),
-    progress: previous?._tag === "ToolEntry" ? previous.progress : [],
+    params: call.params === undefined ? previousToolEntry?.params : call.params,
+    phase: nextPhase,
+    outcome: previousToolEntry?.outcome ?? Pending(),
+    progress: previousToolEntry?.progress ?? [],
   })
   if (index < 0) return [...entries, next]
   return entries.map((entry, entryIndex) => (entryIndex === index ? next : entry))
@@ -344,6 +484,7 @@ const resolveTool = (entries: ReadonlyArray<ChatEntry>, result: ToolResultLike):
           callId: entry.callId,
           name: entry.name,
           params: entry.params,
+          phase: entry.phase,
           outcome: Completed({ isFailure: result.isFailure, result: result.result }),
           progress: entry.progress,
         })
@@ -358,6 +499,7 @@ const addProgress = (entries: ReadonlyArray<ChatEntry>, callId: string, message:
           callId: entry.callId,
           name: entry.name,
           params: entry.params,
+          phase: entry.phase,
           outcome: entry.outcome,
           progress: entry.progress.concat(message),
         })
@@ -436,6 +578,7 @@ const applyEvent = (model: Model, event: Wire.EventType): readonly [Model, Optio
     case "ModelPart":
       return [applyPart(model, event.turn, event.part), Option.none()]
     case "ToolExecutionStarted":
+      return [{ ...model, entries: upsertToolCall(model.entries, event.call, "executing") }, Option.none()]
     case "ApprovalRequested":
       return [{ ...model, entries: upsertToolCall(model.entries, event.call) }, Option.none()]
     case "ToolProgress":
@@ -444,7 +587,7 @@ const applyEvent = (model: Model, event: Wire.EventType): readonly [Model, Optio
         : [{ ...model, entries: addProgress(model.entries, event.toolCallId, event.message) }, Option.none()]
     case "ToolExecutionCompleted":
       return [
-        { ...model, entries: resolveTool(upsertToolCall(model.entries, event.call), event.result) },
+        { ...model, entries: resolveTool(upsertToolCall(model.entries, event.call, "executing"), event.result) },
         Option.none(),
       ]
     case "TurnCompleted":
@@ -472,7 +615,7 @@ const reasoningFromContent = (content: ReadonlyArray<unknown>): string | null =>
   return reasoning.length === 0 ? null : reasoning
 }
 
-const projectPrompt = (prompt: Ai.Prompt.Prompt): ReadonlyArray<ChatEntry> => {
+const projectPrompt = (prompt: Prompt.Prompt): ReadonlyArray<ChatEntry> => {
   let entries: ReadonlyArray<ChatEntry> = []
   for (const message of prompt.content) {
     if (message.role === "user") {
@@ -516,7 +659,94 @@ const applyFrame = (model: Model, frame: Wire.LooseServerFrameType): readonly [M
   }
 }
 
-const isServerFrame = (incoming: Connection.Incoming): incoming is Wire.LooseServerFrameType =>
+const jsonText = (value: unknown): string => {
+  try {
+    return JSON.stringify(value, null, 2) ?? "undefined"
+  } catch {
+    return String(value)
+  }
+}
+
+/** @experimental */
+export const promptInputStatusOf = (run: RunState): PromptInputStatus => {
+  switch (run._tag) {
+    case "Idle":
+      return "idle"
+    case "Running":
+      return "streaming"
+    case "AwaitingApproval":
+      return "submitted"
+    case "Failed":
+      return "error"
+  }
+}
+
+/** @experimental */
+export const toolStatusOf = (entry: typeof ToolEntry.Type): ToolStatus => {
+  switch (entry.outcome._tag) {
+    case "Pending":
+      return entry.phase === "executing" ? "input-available" : "input-streaming"
+    case "Completed":
+      return entry.outcome.isFailure ? "output-error" : "output-available"
+  }
+}
+
+const conversationItemFor = (entry: ChatEntry, index: number): ConversationItem => {
+  switch (entry._tag) {
+    case "UserEntry":
+      return UserConversationItem({ key: `entry-${index}-user`, align: "end", entry })
+    case "AssistantEntry":
+      return AssistantConversationItem({ key: `entry-${index}-assistant`, align: "start", entry })
+    case "ToolEntry":
+      return ToolConversationItem({
+        key: `tool-${entry.callId}`,
+        align: "start",
+        entry,
+        status: toolStatusOf(entry),
+        input: jsonText(entry.params),
+      })
+  }
+}
+
+/** @experimental */
+export const conversationItems = (model: Model): ReadonlyArray<ConversationItem> => {
+  const entries = model.entries.map(conversationItemFor)
+  const streaming =
+    model.streaming === null
+      ? []
+      : [
+          StreamingConversationItem({
+            key: "streaming-assistant",
+            align: "start",
+            text: model.streaming.text,
+            reasoning: model.streaming.reasoning,
+            isStreaming: true,
+          }),
+        ]
+  const waiting =
+    model.run._tag === "Running" && model.streaming === null
+      ? [WaitingConversationItem({ key: "waiting-assistant", align: "start" })]
+      : []
+  const approval =
+    model.run._tag === "AwaitingApproval"
+      ? [
+          ApprovalConversationItem({
+            key: `approval-${model.run.token}`,
+            align: "start",
+            token: model.run.token,
+            toolName: model.run.toolName,
+            params: model.run.params,
+          }),
+        ]
+      : []
+  const failure =
+    model.run._tag === "Failed"
+      ? [FailureConversationItem({ key: "run-failure", align: "start", message: model.run.message })]
+      : []
+  return [...entries, ...streaming, ...waiting, ...approval, ...failure]
+}
+
+const isServerFrame = (incoming: Incoming): incoming is Wire.LooseServerFrameType =>
   incoming._tag === "Event" ||
   incoming._tag === "Suspended" ||
   incoming._tag === "Failed" ||
@@ -551,6 +781,20 @@ export const update = (
             Option.some(RunFailed({ message: message.incoming.reason })),
           ]
       }
+    case "OpenedSession":
+      return [
+        {
+          ...model,
+          sessionId: message.sessionId,
+          connection: "connecting",
+          lastSeq: -1,
+          run: Idle(),
+          entries: [],
+          streaming: null,
+        },
+        [],
+        Option.none(),
+      ]
     case "ChangedDraft":
       return [{ ...model, draft: message.text }, [], Option.none()]
     case "SubmittedMessage": {
@@ -606,7 +850,7 @@ export const update = (
 }
 
 /** @experimental */
-export const subscriptions = Subscription.make<Model, Message, Connection.AgentConnection>()((entry) => ({
+export const subscriptions = make<Model, Message, AgentConnection>()((entry) => ({
   agentFrames: entry(
     { sessionId: Schema.NullOr(Schema.String), afterSeq: Schema.Number },
     {
@@ -615,7 +859,7 @@ export const subscriptions = Subscription.make<Model, Message, Connection.AgentC
       dependenciesToStream: ({ sessionId }, readDependencies) => {
         if (sessionId === null) return Stream.empty
         return Stream.unwrap(
-          Connection.AgentConnection.use((connection) => {
+          AgentConnection.use((connection) => {
             const afterSeq = readDependencies().afterSeq
             return Effect.succeed(
               connection

package/test/chat.scene.test.ts

@@ -0,0 +1,152 @@
+// @vitest-environment happy-dom
+
+import { Chat, Connection } from "../src/index"
+import { Wire } from "@batonfx/transport"
+import { Response } from "effect/unstable/ai"
+import type { Document, Html } from "foldkit/html"
+import { html } from "foldkit/html"
+import { Command, click, expect, placeholder, role, scene, type } from "foldkit/scene"
+import type { SceneSimulation } from "foldkit/scene"
+import { describe, test } from "vitest"
+
+const sessionId = "foldkit-scene-session"
+
+const eventFrame = (seq: number, event: Wire.EventType): Wire.LooseServerFrameType => ({ _tag: "Event", seq, event })
+
+const toolCall = Response.makePart("tool-call", {
+  id: "lookup-1",
+  name: "lookup",
+  params: { query: "baton foldkit" },
+  providerExecuted: false,
+})
+
+const toolResult = Response.makePart("tool-result", {
+  id: "lookup-1",
+  name: "lookup",
+  result: { answer: "transport binding" },
+  encodedResult: { answer: "transport binding" },
+  isFailure: false,
+  providerExecuted: false,
+  preliminary: false,
+})
+
+const frames: ReadonlyArray<Wire.LooseServerFrameType> = [
+  eventFrame(0, { _tag: "TurnStarted", turn: 0 }),
+  eventFrame(1, { _tag: "ModelPart", turn: 0, part: toolCall }),
+  eventFrame(2, { _tag: "ToolExecutionStarted", turn: 0, call: toolCall }),
+  eventFrame(3, { _tag: "ToolExecutionCompleted", turn: 0, call: toolCall, result: toolResult }),
+  eventFrame(4, { _tag: "TurnCompleted", turn: 0 }),
+  eventFrame(5, { _tag: "TurnStarted", turn: 1 }),
+  eventFrame(6, {
+    _tag: "ModelPart",
+    turn: 1,
+    part: Response.makePart("reasoning-delta", { id: "reasoning-1", delta: "Check the transport stream." }),
+  }),
+  eventFrame(7, {
+    _tag: "ModelPart",
+    turn: 1,
+    part: Response.makePart("text-delta", { id: "answer-1", delta: "Final answer" }),
+  }),
+  eventFrame(8, { _tag: "TurnCompleted", turn: 1 }),
+  eventFrame(9, { _tag: "Completed", turns: 2, text: "Final answer" }),
+]
+
+const reduceMessage = (model: Chat.Model, message: Chat.Message): Chat.Model => Chat.update(model, message)[0]
+
+const withModel = <Model>(initialModel: Model) =>
+  Object.assign(
+    <M, Message, OutMessage = undefined>(simulation: SceneSimulation<M, Message, OutMessage>) =>
+      ({ ...simulation, model: initialModel }) as unknown as SceneSimulation<M, Message, OutMessage>,
+    { _phantomModel: undefined },
+  )
+
+const scriptedModel = (): Chat.Model => {
+  let model = Chat.initialModel(null)
+  model = reduceMessage(model, Chat.OpenedSession({ sessionId }))
+  model = reduceMessage(model, Chat.ReceivedAgent({ incoming: Connection.ConnectionOpened() }))
+  model = reduceMessage(model, Chat.ChangedDraft({ text: "Render this run" }))
+  model = reduceMessage(model, Chat.SubmittedMessage())
+  for (const frame of frames) {
+    model = reduceMessage(model, Chat.ReceivedAgent({ incoming: frame }))
+  }
+  return model
+}
+
+const rowView = (item: Chat.ConversationItem): Html => {
+  const h = html<Chat.Message>()
+  switch (item._tag) {
+    case "UserConversationItem":
+      return h.section([h.Role("article"), h.AriaLabel("User message")], [item.entry.text])
+    case "AssistantConversationItem":
+      return h.section(
+        [h.Role("article"), h.AriaLabel("Assistant message")],
+        [item.entry.reasoning ?? "", item.entry.text],
+      )
+    case "ToolConversationItem":
+      return h.section(
+        [h.Role("article"), h.AriaLabel(`Tool ${item.entry.name}`), h.DataAttribute("status", item.status)],
+        [item.entry.name, item.status, item.input, JSON.stringify(item.entry.outcome)],
+      )
+    case "StreamingConversationItem":
+      return h.section([h.Role("article"), h.AriaLabel("Streaming assistant message")], [item.reasoning, item.text])
+    case "WaitingConversationItem":
+      return h.section([h.Role("status")], ["Thinking"])
+    case "ApprovalConversationItem":
+      return h.section([h.Role("article"), h.AriaLabel("Approval required")], [item.toolName])
+    case "FailureConversationItem":
+      return h.section([h.Role("alert")], [item.message])
+  }
+}
+
+const view = (model: Chat.Model): Document => {
+  const h = html<Chat.Message>()
+  return {
+    title: "Chat scene",
+    body: h.main(
+      [],
+      [
+        h.div([h.Role("log")], Chat.conversationItems(model).map(rowView)),
+        h.form(
+          [h.OnSubmit(Chat.SubmittedMessage())],
+          [
+            h.input([
+              h.AriaLabel("Message"),
+              h.Placeholder("Message"),
+              h.Value(model.draft),
+              h.OnInput((text) => Chat.ChangedDraft({ text })),
+            ]),
+            h.button([h.Type("submit")], ["Send"]),
+          ],
+        ),
+      ],
+    ),
+  }
+}
+
+describe("Chat Scene", () => {
+  test("renders scripted stream rows for user, tool execution, and assistant completion", () => {
+    scene(
+      { update: Chat.update, view },
+      withModel(scriptedModel()),
+      expect(role("article", { name: "User message" })).toContainText("Render this run"),
+      expect(role("article", { name: "Tool lookup" })).toContainText("lookup"),
+      expect(role("article", { name: "Tool lookup" })).toContainText("output-available"),
+      expect(role("article", { name: "Tool lookup" })).toContainText('"answer":"transport binding"'),
+      expect(role("article", { name: "Assistant message" })).toContainText("Check the transport stream."),
+      expect(role("article", { name: "Assistant message" })).toContainText("Final answer"),
+    )
+  })
+
+  test("send message dispatches the Baton send command", () => {
+    const model = reduceMessage(Chat.initialModel(null), Chat.OpenedSession({ sessionId }))
+    scene(
+      { update: Chat.update, view },
+      withModel(model),
+      type(placeholder("Message"), "hello baton"),
+      click(role("button", { name: "Send" })),
+      Command.expectExact(Chat.SendUserMessage({ sessionId, text: "hello baton" })),
+      Command.resolve(Chat.SendUserMessage({ sessionId, text: "hello baton" }), Chat.SentUserMessage()),
+      expect(role("article", { name: "User message" })).toContainText("hello baton"),
+    )
+  })
+})