@batonfx/foldkit 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@batonfx/foldkit",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir dist --target bun --format esm",
+    "lint": "bun --cwd ../.. oxlint packages/foldkit/src packages/foldkit/test",
+    "test": "bun --cwd ../.. vitest run packages/foldkit/test --passWithNoTests",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "@batonfx/transport": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": ">=4.0.0-beta.88 <4.0.1",
+    "foldkit": ">=0.122.0 <1"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.93",
+    "@types/bun": "1.3.13",
+    "effect": "4.0.0-beta.93",
+    "foldkit": "0.122.0",
+    "typescript": "5.8.2",
+    "vitest": "4.0.16"
+  }
+}

package/src/chat.ts

@@ -0,0 +1,630 @@
+import { Cause, Equivalence, Effect, Option, Schema, Stream } from "effect"
+import * as Ai from "effect/unstable/ai"
+import * as Command from "foldkit/command"
+import { m } from "foldkit/message"
+import type { CallableTaggedStruct } from "foldkit/schema"
+import * as Subscription from "foldkit/subscription"
+import { Wire } from "@batonfx/transport"
+import * as Connection 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 ToolEntryFields = {
+  callId: Schema.String,
+  name: Schema.String,
+  params: Schema.Unknown,
+  outcome: Schema.suspend((): Schema.Schema<ToolOutcome> => ToolOutcome),
+  progress: Schema.Array(Schema.String),
+}
+const RunningFields = { turn: Schema.Number }
+const AwaitingApprovalFields = {
+  token: Schema.String,
+  toolName: Schema.String,
+  params: Schema.Unknown,
+}
+const ClickedDenyFields = { reason: Schema.NullOr(Schema.String) }
+const ReceivedAgentFields = { incoming: Connection.Incoming }
+const ModelStreaming = Schema.Struct({
+  turn: Schema.Number,
+  text: Schema.String,
+  reasoning: Schema.String,
+})
+const ModelConnection = Schema.Literals(["disconnected", "connecting", "open", "reconnecting"])
+
+const Pending: CallableTaggedStruct<"Pending", {}> = m("Pending")
+const Completed: CallableTaggedStruct<"Completed", typeof CompletedFields> = m("Completed", CompletedFields)
+
+/** @experimental */
+export type ToolOutcome = typeof Pending.Type | typeof Completed.Type
+
+/** @experimental */
+export const ToolOutcome: Schema.Schema<ToolOutcome> = Schema.Union([Pending, Completed])
+
+/** @experimental */
+export const UserEntry: CallableTaggedStruct<"UserEntry", typeof UserEntryFields> = m("UserEntry", UserEntryFields)
+
+/** @experimental */
+export const AssistantEntry: CallableTaggedStruct<"AssistantEntry", typeof AssistantEntryFields> = m(
+  "AssistantEntry",
+  AssistantEntryFields,
+)
+
+/** @experimental */
+export const ToolEntry: CallableTaggedStruct<"ToolEntry", typeof ToolEntryFields> = m("ToolEntry", ToolEntryFields)
+
+/** @experimental */
+export type ChatEntry = typeof UserEntry.Type | typeof AssistantEntry.Type | typeof ToolEntry.Type
+
+/** @experimental */
+export const ChatEntry: Schema.Schema<ChatEntry> = Schema.Union([UserEntry, AssistantEntry, ToolEntry])
+
+/** @experimental */
+export const Idle: CallableTaggedStruct<"Idle", {}> = m("Idle")
+
+/** @experimental */
+export const Running: CallableTaggedStruct<"Running", typeof RunningFields> = m("Running", RunningFields)
+
+/** @experimental */
+export const AwaitingApproval: CallableTaggedStruct<"AwaitingApproval", typeof AwaitingApprovalFields> = m(
+  "AwaitingApproval",
+  AwaitingApprovalFields,
+)
+
+/** @experimental */
+export const Failed: CallableTaggedStruct<"Failed", { message: typeof Schema.String }> = m("Failed", {
+  message: Schema.String,
+})
+
+/** @experimental */
+export type RunState = typeof Idle.Type | typeof Running.Type | typeof AwaitingApproval.Type | typeof Failed.Type
+
+/** @experimental */
+export const RunState: Schema.Schema<RunState> = Schema.Union([Idle, Running, AwaitingApproval, Failed])
+
+/** @experimental */
+export interface Model {
+  readonly sessionId: string | null
+  readonly connection: typeof ModelConnection.Type
+  readonly lastSeq: number
+  readonly run: RunState
+  readonly entries: ReadonlyArray<ChatEntry>
+  readonly streaming: typeof ModelStreaming.Type | null
+  readonly draft: string
+}
+
+/** @experimental */
+export const Model: Schema.Schema<Model> = Schema.Struct({
+  sessionId: Schema.NullOr(Schema.String),
+  connection: ModelConnection,
+  lastSeq: Schema.Number,
+  run: RunState,
+  entries: Schema.Array(ChatEntry),
+  streaming: Schema.NullOr(ModelStreaming),
+  draft: Schema.String,
+})
+
+/** @experimental */
+export const ReceivedAgent: CallableTaggedStruct<"ReceivedAgent", typeof ReceivedAgentFields> = m(
+  "ReceivedAgent",
+  ReceivedAgentFields,
+)
+
+/** @experimental */
+export const ChangedDraft: CallableTaggedStruct<"ChangedDraft", typeof UserEntryFields> = m(
+  "ChangedDraft",
+  UserEntryFields,
+)
+
+/** @experimental */
+export const SubmittedMessage: CallableTaggedStruct<"SubmittedMessage", {}> = m("SubmittedMessage")
+
+/** @experimental */
+export const ClickedCancel: CallableTaggedStruct<"ClickedCancel", {}> = m("ClickedCancel")
+
+/** @experimental */
+export const ClickedApprove: CallableTaggedStruct<"ClickedApprove", {}> = m("ClickedApprove")
+
+/** @experimental */
+export const ClickedDeny: CallableTaggedStruct<"ClickedDeny", typeof ClickedDenyFields> = m(
+  "ClickedDeny",
+  ClickedDenyFields,
+)
+
+/** @experimental */
+export const SentUserMessage: CallableTaggedStruct<"SentUserMessage", {}> = m("SentUserMessage")
+
+/** @experimental */
+export const ResolvedApproval: CallableTaggedStruct<"ResolvedApproval", {}> = m("ResolvedApproval")
+
+/** @experimental */
+export const CancelledRun: CallableTaggedStruct<"CancelledRun", {}> = m("CancelledRun")
+
+/** @experimental */
+export const FailedAgentCommand: CallableTaggedStruct<"FailedAgentCommand", typeof StringReasonFields> = m(
+  "FailedAgentCommand",
+  StringReasonFields,
+)
+
+/** @experimental */
+export type Message =
+  | typeof ReceivedAgent.Type
+  | typeof ChangedDraft.Type
+  | typeof SubmittedMessage.Type
+  | typeof ClickedCancel.Type
+  | typeof ClickedApprove.Type
+  | typeof ClickedDeny.Type
+  | typeof SentUserMessage.Type
+  | typeof ResolvedApproval.Type
+  | typeof CancelledRun.Type
+  | typeof FailedAgentCommand.Type
+
+/** @experimental */
+export const Message: Schema.Schema<Message> = Schema.Union([
+  ReceivedAgent,
+  ChangedDraft,
+  SubmittedMessage,
+  ClickedCancel,
+  ClickedApprove,
+  ClickedDeny,
+  SentUserMessage,
+  ResolvedApproval,
+  CancelledRun,
+  FailedAgentCommand,
+])
+
+/** @experimental */
+export const RunCompleted: CallableTaggedStruct<"RunCompleted", typeof RunCompletedFields> = m(
+  "RunCompleted",
+  RunCompletedFields,
+)
+
+/** @experimental */
+export const ApprovalRequired: CallableTaggedStruct<"ApprovalRequired", {}> = m("ApprovalRequired")
+
+/** @experimental */
+export const RunFailed: CallableTaggedStruct<"RunFailed", { message: typeof Schema.String }> = m("RunFailed", {
+  message: Schema.String,
+})
+
+/** @experimental */
+export type OutMessage = typeof RunCompleted.Type | typeof ApprovalRequired.Type | typeof RunFailed.Type
+
+/** @experimental */
+export const OutMessage: Schema.Schema<OutMessage> = Schema.Union([RunCompleted, ApprovalRequired, RunFailed])
+
+/** @experimental */
+export type ChatCommand = Command.Command<Message, any, Connection.AgentConnection>
+
+/** @experimental */
+export const initialModel = (sessionId: string | null = null): Model => ({
+  sessionId,
+  connection: "disconnected",
+  lastSeq: -1,
+  run: Idle(),
+  entries: [],
+  streaming: null,
+  draft: "",
+})
+
+type FailedAgentCommandMessage = typeof FailedAgentCommand.Type
+
+const commandFailed = (error: unknown): FailedAgentCommandMessage =>
+  FailedAgentCommand({ reason: error instanceof Connection.SendFailed ? error.reason : String(error) })
+
+const catchCommandFailure = <A>(effect: Effect.Effect<A, Connection.SendFailed, Connection.AgentConnection>) =>
+  effect.pipe(Effect.catchCause((cause) => Effect.succeed(commandFailed(Cause.squash(cause)))))
+
+/** @experimental */
+export const SendUserMessage = Command.define(
+  "SendUserMessage",
+  { sessionId: Schema.String, text: Schema.String },
+  SentUserMessage,
+  FailedAgentCommand,
+)(({ sessionId, text }) =>
+  Connection.AgentConnection.use((connection) =>
+    catchCommandFailure(
+      connection.send({ _tag: "SendMessage", sessionId, prompt: text }).pipe(Effect.as(SentUserMessage())),
+    ),
+  ),
+)
+
+/** @experimental */
+export const ResolveApproval = Command.define(
+  "ResolveApproval",
+  {
+    sessionId: Schema.String,
+    token: Schema.String,
+    approved: Schema.Boolean,
+    reason: Schema.NullOr(Schema.String),
+  },
+  ResolvedApproval,
+  FailedAgentCommand,
+)(({ sessionId, token, approved, reason }) => {
+  const decision: Wire.ClientApproval = approved
+    ? { _tag: "Approved" }
+    : reason === null
+      ? { _tag: "Denied" }
+      : { _tag: "Denied", reason }
+  return Connection.AgentConnection.use((connection) =>
+    catchCommandFailure(
+      connection.send({ _tag: "ResolveApproval", sessionId, token, decision }).pipe(Effect.as(ResolvedApproval())),
+    ),
+  )
+})
+
+/** @experimental */
+export const CancelRun = Command.define(
+  "CancelRun",
+  { sessionId: Schema.String },
+  CancelledRun,
+  FailedAgentCommand,
+)(({ sessionId }) =>
+  Connection.AgentConnection.use((connection) =>
+    catchCommandFailure(connection.send({ _tag: "Cancel", sessionId }).pipe(Effect.as(CancelledRun()))),
+  ),
+)
+
+interface StreamingState {
+  readonly turn: number
+  readonly text: string
+  readonly reasoning: string
+}
+
+interface ToolCallLike {
+  readonly type: "tool-call"
+  readonly id: string
+  readonly name: string
+  readonly params: unknown
+}
+
+interface ToolResultLike {
+  readonly type: "tool-result"
+  readonly id: string
+  readonly name: string
+  readonly result: unknown
+  readonly isFailure: boolean
+}
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null
+
+const isToolCall = (value: unknown): value is ToolCallLike =>
+  isRecord(value) &&
+  value.type === "tool-call" &&
+  typeof value.id === "string" &&
+  typeof value.name === "string" &&
+  "params" in value
+
+const isToolResult = (value: unknown): value is ToolResultLike =>
+  isRecord(value) &&
+  value.type === "tool-result" &&
+  typeof value.id === "string" &&
+  typeof value.name === "string" &&
+  "result" in value &&
+  typeof value.isFailure === "boolean"
+
+const streamingFor = (model: Model, turn: number): StreamingState =>
+  model.streaming ?? { turn, text: "", reasoning: "" }
+
+const appendStreaming = (model: Model, turn: number, field: "text" | "reasoning", delta: string): Model => {
+  const streaming = streamingFor(model, turn)
+  return { ...model, streaming: { ...streaming, [field]: streaming[field] + delta } }
+}
+
+const flushStreaming = (model: Model): Model => {
+  if (model.streaming === null) return model
+  const { text, reasoning } = model.streaming
+  const entry =
+    text.length === 0 && reasoning.length === 0 ? [] : [AssistantEntry({ text, reasoning: reasoning || null })]
+  return { ...model, entries: [...model.entries, ...entry], streaming: null }
+}
+
+const upsertToolCall = (entries: ReadonlyArray<ChatEntry>, call: ToolCallLike): ReadonlyArray<ChatEntry> => {
+  const index = entries.findIndex((entry) => entry._tag === "ToolEntry" && entry.callId === call.id)
+  const previous = index >= 0 ? entries[index] : undefined
+  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 : [],
+  })
+  if (index < 0) return [...entries, next]
+  return entries.map((entry, entryIndex) => (entryIndex === index ? next : entry))
+}
+
+const resolveTool = (entries: ReadonlyArray<ChatEntry>, result: ToolResultLike): ReadonlyArray<ChatEntry> => {
+  const withCall = upsertToolCall(entries, { type: "tool-call", id: result.id, name: result.name, params: undefined })
+  return withCall.map((entry) =>
+    entry._tag === "ToolEntry" && entry.callId === result.id
+      ? ToolEntry({
+          callId: entry.callId,
+          name: entry.name,
+          params: entry.params,
+          outcome: Completed({ isFailure: result.isFailure, result: result.result }),
+          progress: entry.progress,
+        })
+      : entry,
+  )
+}
+
+const addProgress = (entries: ReadonlyArray<ChatEntry>, callId: string, message: string): ReadonlyArray<ChatEntry> =>
+  entries.map((entry) =>
+    entry._tag === "ToolEntry" && entry.callId === callId
+      ? ToolEntry({
+          callId: entry.callId,
+          name: entry.name,
+          params: entry.params,
+          outcome: entry.outcome,
+          progress: entry.progress.concat(message),
+        })
+      : entry,
+  )
+
+const failureMessage = (failure: Wire.RunFailure): string => {
+  switch (failure._tag) {
+    case "@batonfx/core/AgentError":
+      return failure.message
+    case "@batonfx/core/MiddlewareViolation":
+      return failure.detail
+    case "@batonfx/core/TurnLimitExceeded":
+      return `Turn limit exceeded at turn ${failure.turn}`
+  }
+}
+
+const applyPart = (model: Model, turn: number, part: unknown): Model => {
+  if (!isRecord(part) || typeof part.type !== "string") return model
+  switch (part.type) {
+    case "text-delta":
+      return typeof part.delta === "string" ? appendStreaming(model, turn, "text", part.delta) : model
+    case "reasoning-delta":
+      return typeof part.delta === "string" ? appendStreaming(model, turn, "reasoning", part.delta) : model
+    case "tool-call":
+      return isToolCall(part) ? { ...model, entries: upsertToolCall(model.entries, part) } : model
+    case "tool-result":
+      return isToolResult(part) ? { ...model, entries: resolveTool(model.entries, part) } : model
+    default:
+      return model
+  }
+}
+
+type Suspension = Extract<Wire.ServerFrameType, { readonly _tag: "Suspended" }>["suspension"]
+
+const applySuspension = (model: Model, suspension: Suspension) => {
+  if (suspension.reason === "approval") {
+    return [
+      {
+        ...model,
+        run: AwaitingApproval({
+          token: suspension.token,
+          toolName: suspension.tool_name,
+          params: suspension.tool_params,
+        }),
+      },
+      Option.some(ApprovalRequired()),
+    ] as const
+  }
+  const message = `Tool wait suspension for ${suspension.tool_name} is not resolvable by the FoldKit adapter`
+  return [{ ...model, run: Failed({ message }) }, Option.some(RunFailed({ message }))] as const
+}
+
+const applyStatus = (model: Model, status: Wire.SessionStatus): readonly [Model, Option.Option<OutMessage>] => {
+  switch (status._tag) {
+    case "Idle":
+      return [{ ...model, run: Idle() }, Option.none()]
+    case "Running":
+      return [{ ...model, run: Running({ turn: status.turn }) }, Option.none()]
+    case "Suspended":
+      return applySuspension(model, status.suspension)
+    case "Failed": {
+      const message = failureMessage(status.error)
+      return [{ ...model, run: Failed({ message }) }, Option.some(RunFailed({ message }))]
+    }
+  }
+}
+
+const applyEvent = (model: Model, event: Wire.EventType): readonly [Model, Option.Option<OutMessage>] => {
+  switch (event._tag) {
+    case "TurnStarted":
+      return [
+        { ...model, run: Running({ turn: event.turn }), streaming: { turn: event.turn, text: "", reasoning: "" } },
+        Option.none(),
+      ]
+    case "ModelPart":
+      return [applyPart(model, event.turn, event.part), Option.none()]
+    case "ToolExecutionStarted":
+    case "ApprovalRequested":
+      return [{ ...model, entries: upsertToolCall(model.entries, event.call) }, Option.none()]
+    case "ToolProgress":
+      return event.message === undefined
+        ? [model, Option.none()]
+        : [{ ...model, entries: addProgress(model.entries, event.toolCallId, event.message) }, Option.none()]
+    case "ToolExecutionCompleted":
+      return [
+        { ...model, entries: resolveTool(upsertToolCall(model.entries, event.call), event.result) },
+        Option.none(),
+      ]
+    case "TurnCompleted":
+      return [flushStreaming(model), Option.none()]
+    case "StructuredOutput":
+      return [model, Option.none()]
+    case "Completed": {
+      const flushed = flushStreaming(model)
+      return [{ ...flushed, run: Idle() }, Option.some(RunCompleted({ text: event.text }))]
+    }
+  }
+}
+
+const textFromContent = (content: ReadonlyArray<unknown>): string =>
+  content
+    .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
+    .map((part) => (part as { readonly text: string }).text)
+    .join("")
+
+const reasoningFromContent = (content: ReadonlyArray<unknown>): string | null => {
+  const reasoning = content
+    .filter((part) => isRecord(part) && part.type === "reasoning" && typeof part.text === "string")
+    .map((part) => (part as { readonly text: string }).text)
+    .join("")
+  return reasoning.length === 0 ? null : reasoning
+}
+
+const projectPrompt = (prompt: Ai.Prompt.Prompt): ReadonlyArray<ChatEntry> => {
+  let entries: ReadonlyArray<ChatEntry> = []
+  for (const message of prompt.content) {
+    if (message.role === "user") {
+      const text = textFromContent(message.content)
+      if (text.length > 0) entries = entries.concat(UserEntry({ text }))
+    } else if (message.role === "assistant") {
+      const text = textFromContent(message.content)
+      const reasoning = reasoningFromContent(message.content)
+      if (text.length > 0 || reasoning !== null) entries = entries.concat(AssistantEntry({ text, reasoning }))
+      for (const part of message.content) {
+        if (isToolCall(part)) entries = upsertToolCall(entries, part)
+        if (isToolResult(part)) entries = resolveTool(entries, part)
+      }
+    } else if (message.role === "tool") {
+      for (const part of message.content) {
+        if (isToolResult(part)) entries = resolveTool(entries, part)
+      }
+    }
+  }
+  return entries
+}
+
+const applyFrame = (model: Model, frame: Wire.LooseServerFrameType): readonly [Model, Option.Option<OutMessage>] => {
+  if (frame.seq <= model.lastSeq) return [model, Option.none()]
+  const withSeq = { ...model, lastSeq: frame.seq }
+  switch (frame._tag) {
+    case "Event":
+      return applyEvent(withSeq, frame.event)
+    case "Suspended":
+      return applySuspension(withSeq, frame.suspension)
+    case "Failed": {
+      const message = failureMessage(frame.error)
+      return [{ ...withSeq, run: Failed({ message }) }, Option.some(RunFailed({ message }))]
+    }
+    case "Ended":
+      return [withSeq, Option.none()]
+    case "Snapshot":
+      return [{ ...withSeq, entries: projectPrompt(frame.transcript), streaming: null }, Option.none()]
+    case "SessionStatus":
+      return applyStatus(withSeq, frame.status)
+  }
+}
+
+const isServerFrame = (incoming: Connection.Incoming): incoming is Wire.LooseServerFrameType =>
+  incoming._tag === "Event" ||
+  incoming._tag === "Suspended" ||
+  incoming._tag === "Failed" ||
+  incoming._tag === "Ended" ||
+  incoming._tag === "Snapshot" ||
+  incoming._tag === "SessionStatus"
+
+/** @experimental */
+export const update = (
+  model: Model,
+  message: Message,
+): readonly [Model, ReadonlyArray<ChatCommand>, Option.Option<OutMessage>] => {
+  switch (message._tag) {
+    case "ReceivedAgent":
+      if (isServerFrame(message.incoming)) {
+        const [next, out] = applyFrame(model, message.incoming)
+        return [next, [], out]
+      }
+      switch (message.incoming._tag) {
+        case "ConnectionOpened":
+          return [{ ...model, connection: "open" }, [], Option.none()]
+        case "ConnectionLost":
+          return [
+            { ...model, connection: model.sessionId === null ? "disconnected" : "reconnecting" },
+            [],
+            Option.none(),
+          ]
+        case "ConnectionFailed":
+          return [
+            { ...model, connection: "disconnected", run: Failed({ message: message.incoming.reason }) },
+            [],
+            Option.some(RunFailed({ message: message.incoming.reason })),
+          ]
+      }
+    case "ChangedDraft":
+      return [{ ...model, draft: message.text }, [], Option.none()]
+    case "SubmittedMessage": {
+      const text = model.draft.trim()
+      if (model.sessionId === null || text.length === 0) return [model, [], Option.none()]
+      return [
+        { ...model, draft: "", entries: [...model.entries, UserEntry({ text })] },
+        [SendUserMessage({ sessionId: model.sessionId, text })],
+        Option.none(),
+      ]
+    }
+    case "ClickedApprove":
+      return model.sessionId !== null && model.run._tag === "AwaitingApproval"
+        ? [
+            model,
+            [
+              ResolveApproval({
+                sessionId: model.sessionId,
+                token: model.run.token,
+                approved: true,
+                reason: null,
+              }),
+            ],
+            Option.none(),
+          ]
+        : [model, [], Option.none()]
+    case "ClickedDeny":
+      return model.sessionId !== null && model.run._tag === "AwaitingApproval"
+        ? [
+            model,
+            [
+              ResolveApproval({
+                sessionId: model.sessionId,
+                token: model.run.token,
+                approved: false,
+                reason: message.reason,
+              }),
+            ],
+            Option.none(),
+          ]
+        : [model, [], Option.none()]
+    case "ClickedCancel":
+      return model.sessionId === null
+        ? [model, [], Option.none()]
+        : [model, [CancelRun({ sessionId: model.sessionId })], Option.none()]
+    case "FailedAgentCommand":
+      return [{ ...model, run: Failed({ message: message.reason }) }, [], Option.none()]
+    case "SentUserMessage":
+    case "ResolvedApproval":
+    case "CancelledRun":
+      return [model, [], Option.none()]
+  }
+}
+
+/** @experimental */
+export const subscriptions = Subscription.make<Model, Message, Connection.AgentConnection>()((entry) => ({
+  agentFrames: entry(
+    { sessionId: Schema.NullOr(Schema.String), afterSeq: Schema.Number },
+    {
+      modelToDependencies: (model) => ({ sessionId: model.sessionId, afterSeq: model.lastSeq }),
+      keepAliveEquivalence: Equivalence.make((left, right) => left.sessionId === right.sessionId),
+      dependenciesToStream: ({ sessionId }, readDependencies) => {
+        if (sessionId === null) return Stream.empty
+        return Stream.unwrap(
+          Connection.AgentConnection.use((connection) => {
+            const afterSeq = readDependencies().afterSeq
+            return Effect.succeed(
+              connection
+                .frames(afterSeq < 0 ? { sessionId } : { sessionId, afterSeq })
+                .pipe(Stream.map((incoming) => ReceivedAgent({ incoming }))),
+            )
+          }),
+        )
+      },
+    },
+  ),
+}))