@batonfx/foldkit 0.6.4 → 0.7.1

package/dist/chat-update.d.ts

@@ -0,0 +1,24 @@
+import { Effect, Option, Schema } from "effect";
+import type { CallableTaggedStruct } from "foldkit/schema";
+import { Wire } from "@batonfx/transport";
+import { AgentCommandError, type AgentConnection, type CommandOperation, type Incoming } from "./connection.js";
+import { type Model, type OutMessage } from "./chat.js";
+declare const catchCommandFailure: <A>(operation: CommandOperation, effect: Effect.Effect<A, AgentCommandError, AgentConnection>) => Effect.Effect<A | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"FailedAgentCommand">;
+    operation: typeof CommandOperation;
+    error: typeof AgentCommandError;
+    reason: typeof Schema.String;
+}, "Type">, never, AgentConnection>;
+declare const applyFrame: (model: Model, frame: Wire.LooseServerFrameType) => readonly [Model, Option.Option<OutMessage>];
+declare const isServerFrame: (incoming: Incoming) => incoming is Wire.LooseServerFrameType;
+export declare const chatUpdateRuntime: {
+    Pending: CallableTaggedStruct<"Pending", {}>;
+    Completed: CallableTaggedStruct<"Completed", {
+        isFailure: Schema.Boolean;
+        result: Schema.Unknown;
+    }>;
+    catchCommandFailure: typeof catchCommandFailure;
+    applyFrame: typeof applyFrame;
+    isServerFrame: typeof isServerFrame;
+};
+export {};

package/dist/chat-update.js

@@ -0,0 +1,269 @@
+import { Cause, Effect, Option, Result, Schema } from "effect";
+import { Prompt } from "effect/unstable/ai";
+import { m } from "foldkit/message";
+import { Wire } from "@batonfx/transport";
+import { AgentCommandError, SendFailed, } from "./connection.js";
+import { ApprovalRequired, AssistantEntry, AwaitingApproval, Failed, FailedAgentCommand, Idle, RunCompleted, RunFailed, Running, ToolEntry, UserEntry, } from "./chat.js";
+const CompletedFields = { isFailure: Schema.Boolean, result: Schema.Unknown };
+const Pending = m("Pending");
+const Completed = m("Completed", CompletedFields);
+const unexpectedCause = (cause) => {
+    const reasons = [];
+    for (const reason of cause.reasons) {
+        if (Cause.isDieReason(reason) || Cause.isInterruptReason(reason))
+            reasons.push(reason);
+    }
+    return reasons.length === 0 ? Option.none() : Option.some(Cause.fromReasons(reasons));
+};
+const commandFailed = (operation, error) => FailedAgentCommand({
+    operation,
+    error,
+    reason: Schema.is(SendFailed)(error) ? error.reason : error.message,
+});
+const catchCommandFailure = (operation, effect) => effect.pipe(Effect.catchCause((cause) => Option.match(unexpectedCause(cause), {
+    onNone: () => Result.match(Cause.findError(cause), {
+        onFailure: Effect.failCause,
+        onSuccess: (error) => Effect.succeed(commandFailed(operation, error)),
+    }),
+    onSome: Effect.failCause,
+})));
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isToolCall = (value) => isRecord(value) &&
+    value.type === "tool-call" &&
+    typeof value.id === "string" &&
+    typeof value.name === "string" &&
+    "params" in value;
+const isToolResult = (value) => isRecord(value) &&
+    value.type === "tool-result" &&
+    typeof value.id === "string" &&
+    typeof value.name === "string" &&
+    "result" in value &&
+    typeof value.isFailure === "boolean";
+const streamingFor = (model, turn) => model.streaming ?? { turn, text: "", reasoning: "" };
+const appendStreaming = (model, turn, field, delta) => {
+    const streaming = streamingFor(model, turn);
+    return { ...model, streaming: { ...streaming, [field]: streaming[field] + delta } };
+};
+const flushStreaming = (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, call, phase = "called") => {
+    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 === 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));
+};
+const resolveTool = (entries, result) => {
+    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,
+            phase: entry.phase,
+            outcome: Completed({ isFailure: result.isFailure, result: result.result }),
+            progress: entry.progress,
+        })
+        : entry);
+};
+const addProgress = (entries, callId, message) => entries.map((entry) => entry._tag === "ToolEntry" && entry.callId === callId
+    ? ToolEntry({
+        callId: entry.callId,
+        name: entry.name,
+        params: entry.params,
+        phase: entry.phase,
+        outcome: entry.outcome,
+        progress: entry.progress.concat(message),
+    })
+    : entry);
+const failureMessage = (failure) => {
+    switch (failure._tag) {
+        case "@batonfx/core/AgentError":
+            return failure.message;
+        case "@batonfx/core/TurnPolicyError":
+            return failure.message;
+        case "@batonfx/core/TurnPolicyStopped":
+            return failure.reason._tag === "Policy" ? failure.reason.detail : failure.reason._tag;
+        case "@batonfx/core/MiddlewareViolation":
+            return failure.detail;
+        case "@batonfx/core/TurnLimitExceeded":
+            return `Turn limit exceeded at turn ${failure.turn}`;
+        case "@batonfx/core/ResumeMismatch":
+            return failure.reason === "identity-mismatch"
+                ? "Resume suspension does not match the current checkpoint"
+                : "Resume checkpoint not found";
+        case "@batonfx/core/FrameworkFailure":
+            return `${failure.tool} ${failure.stage}: ${failure.message}`;
+    }
+};
+const applyPart = (model, turn, part) => {
+    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;
+    }
+};
+const applySuspension = (model, suspension) => {
+    if (suspension.reason === "approval") {
+        return [
+            {
+                ...model,
+                run: AwaitingApproval({
+                    token: suspension.token,
+                    toolName: suspension.tool_name,
+                    params: suspension.tool_params,
+                }),
+            },
+            Option.some(ApprovalRequired()),
+        ];
+    }
+    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 }))];
+};
+const applyStatus = (model, status) => {
+    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, event) => {
+    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":
+            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":
+            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, "executing"), event.result) },
+                Option.none(),
+            ];
+        case "SteeringDrained":
+            return [model, 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) => content
+    .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("");
+const reasoningFromContent = (content) => {
+    const reasoning = content
+        .filter((part) => isRecord(part) && part.type === "reasoning" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("");
+    return reasoning.length === 0 ? null : reasoning;
+};
+const projectPrompt = (prompt) => {
+    let entries = [];
+    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, frame) => {
+    if (frame._tag === "Snapshot") {
+        return [{ ...model, lastSeq: frame.seq, entries: projectPrompt(frame.transcript), streaming: null }, Option.none()];
+    }
+    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 "SessionStatus":
+            return applyStatus(withSeq, frame.status);
+    }
+};
+const isServerFrame = (incoming) => incoming._tag === "Event" ||
+    incoming._tag === "Suspended" ||
+    incoming._tag === "Failed" ||
+    incoming._tag === "Ended" ||
+    incoming._tag === "Snapshot" ||
+    incoming._tag === "SessionStatus";
+export const chatUpdateRuntime = {
+    Pending,
+    Completed,
+    catchCommandFailure,
+    applyFrame,
+    isServerFrame,
+};

package/dist/chat.d.ts

@@ -2,10 +2,10 @@ import { Equivalence, Effect, Option, Schema, Stream } from "effect";
 import { type Command } from "foldkit/command";
 import type { CallableTaggedStruct } from "foldkit/schema";
 import { AgentCommandError, AgentConnection, CommandOperation, Incoming } from "./connection.js";
-declare const CompletedFields: {
+declare const Completed: CallableTaggedStruct<"Completed", {
     isFailure: Schema.Boolean;
     result: Schema.Unknown;
-};
+}>, Pending: CallableTaggedStruct<"Pending", {}>;
 declare const UserEntryFields: {
     text: Schema.String;
 };
@@ -51,8 +51,6 @@ declare const ModelStreaming: Schema.Struct<{
     readonly reasoning: Schema.String;
 }>;
 declare const ModelConnection: Schema.Literals<readonly ["disconnected", "connecting", "open", "reconnecting"]>;
-declare const Pending: CallableTaggedStruct<"Pending", {}>;
-declare const Completed: CallableTaggedStruct<"Completed", typeof CompletedFields>;
 /** @experimental */
 export type ToolOutcome = typeof Pending.Type | typeof Completed.Type;
 /** @experimental */

package/dist/chat.js

@@ -1,12 +1,12 @@
-import { Cause, Equivalence, Effect, Option, Result, Schema, Stream } from "effect";
+import { Equivalence, Effect, Option, Schema, Stream } from "effect";
 import { dual } from "effect/Function";
-import { Prompt } from "effect/unstable/ai";
 import { define } from "foldkit/command";
 import { m } from "foldkit/message";
 import { make } from "foldkit/subscription";
 import { Wire } from "@batonfx/transport";
-import { AgentCommandError, AgentConnection, CommandOperation, Incoming, SendFailed } from "./connection.js";
-const CompletedFields = { isFailure: Schema.Boolean, result: Schema.Unknown };
+import { AgentCommandError, AgentConnection, CommandOperation, Incoming } from "./connection.js";
+import { chatUpdateRuntime } from "./chat-update.js";
+const { applyFrame, catchCommandFailure, Completed, isServerFrame, Pending } = chatUpdateRuntime;
 const UserEntryFields = { text: Schema.String };
 const AssistantEntryFields = { text: Schema.String, reasoning: Schema.NullOr(Schema.String) };
 const RunCompletedFields = { text: Schema.String };
@@ -35,8 +35,6 @@ const ModelStreaming = Schema.Struct({
     reasoning: Schema.String,
 });
 const ModelConnection = Schema.Literals(["disconnected", "connecting", "open", "reconnecting"]);
-const Pending = m("Pending");
-const Completed = m("Completed", CompletedFields);
 /** @experimental */
 export const ToolOutcome = Schema.Union([Pending, Completed]);
 /** @experimental */
@@ -177,26 +175,6 @@ export const initialModel = (sessionId = null) => ({
     streaming: null,
     draft: "",
 });
-const unexpectedCause = (cause) => {
-    const reasons = [];
-    for (const reason of cause.reasons) {
-        if (Cause.isDieReason(reason) || Cause.isInterruptReason(reason))
-            reasons.push(reason);
-    }
-    return reasons.length === 0 ? Option.none() : Option.some(Cause.fromReasons(reasons));
-};
-const commandFailed = (operation, error) => FailedAgentCommand({
-    operation,
-    error,
-    reason: Schema.is(SendFailed)(error) ? error.reason : error.message,
-});
-const catchCommandFailure = (operation, effect) => effect.pipe(Effect.catchCause((cause) => Option.match(unexpectedCause(cause), {
-    onNone: () => Result.match(Cause.findError(cause), {
-        onFailure: Effect.failCause,
-        onSuccess: (error) => Effect.succeed(commandFailed(operation, error)),
-    }),
-    onSome: Effect.failCause,
-})));
 /** @experimental */
 export const SendUserMessage = define("SendUserMessage", { sessionId: Schema.String, text: Schema.String }, SentUserMessage, FailedAgentCommand)(({ sessionId, text }) => AgentConnection.use((connection) => catchCommandFailure("send", connection.send({ _tag: "SendMessage", sessionId, prompt: text }).pipe(Effect.as(SentUserMessage())))));
 /** @experimental */
@@ -215,233 +193,6 @@ export const ResolveApproval = define("ResolveApproval", {
 });
 /** @experimental */
 export const CancelRun = define("CancelRun", { sessionId: Schema.String }, CancelledRun, FailedAgentCommand)(({ sessionId }) => AgentConnection.use((connection) => catchCommandFailure("cancel", connection.send({ _tag: "Cancel", sessionId }).pipe(Effect.as(CancelledRun())))));
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isToolCall = (value) => isRecord(value) &&
-    value.type === "tool-call" &&
-    typeof value.id === "string" &&
-    typeof value.name === "string" &&
-    "params" in value;
-const isToolResult = (value) => isRecord(value) &&
-    value.type === "tool-result" &&
-    typeof value.id === "string" &&
-    typeof value.name === "string" &&
-    "result" in value &&
-    typeof value.isFailure === "boolean";
-const streamingFor = (model, turn) => model.streaming ?? { turn, text: "", reasoning: "" };
-const appendStreaming = (model, turn, field, delta) => {
-    const streaming = streamingFor(model, turn);
-    return { ...model, streaming: { ...streaming, [field]: streaming[field] + delta } };
-};
-const flushStreaming = (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, call, phase = "called") => {
-    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 === 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));
-};
-const resolveTool = (entries, result) => {
-    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,
-            phase: entry.phase,
-            outcome: Completed({ isFailure: result.isFailure, result: result.result }),
-            progress: entry.progress,
-        })
-        : entry);
-};
-const addProgress = (entries, callId, message) => entries.map((entry) => entry._tag === "ToolEntry" && entry.callId === callId
-    ? ToolEntry({
-        callId: entry.callId,
-        name: entry.name,
-        params: entry.params,
-        phase: entry.phase,
-        outcome: entry.outcome,
-        progress: entry.progress.concat(message),
-    })
-    : entry);
-const failureMessage = (failure) => {
-    switch (failure._tag) {
-        case "@batonfx/core/AgentError":
-            return failure.message;
-        case "@batonfx/core/TurnPolicyError":
-            return failure.message;
-        case "@batonfx/core/TurnPolicyStopped":
-            return failure.reason._tag === "Policy" ? failure.reason.detail : failure.reason._tag;
-        case "@batonfx/core/MiddlewareViolation":
-            return failure.detail;
-        case "@batonfx/core/TurnLimitExceeded":
-            return `Turn limit exceeded at turn ${failure.turn}`;
-        case "@batonfx/core/ResumeMismatch":
-            return failure.reason === "identity-mismatch"
-                ? "Resume suspension does not match the current checkpoint"
-                : "Resume checkpoint not found";
-        case "@batonfx/core/FrameworkFailure":
-            return `${failure.tool} ${failure.stage}: ${failure.message}`;
-    }
-};
-const applyPart = (model, turn, part) => {
-    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;
-    }
-};
-const applySuspension = (model, suspension) => {
-    if (suspension.reason === "approval") {
-        return [
-            {
-                ...model,
-                run: AwaitingApproval({
-                    token: suspension.token,
-                    toolName: suspension.tool_name,
-                    params: suspension.tool_params,
-                }),
-            },
-            Option.some(ApprovalRequired()),
-        ];
-    }
-    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 }))];
-};
-const applyStatus = (model, status) => {
-    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, event) => {
-    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":
-            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":
-            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, "executing"), event.result) },
-                Option.none(),
-            ];
-        case "SteeringDrained":
-            return [model, 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) => content
-    .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
-    .map((part) => part.text)
-    .join("");
-const reasoningFromContent = (content) => {
-    const reasoning = content
-        .filter((part) => isRecord(part) && part.type === "reasoning" && typeof part.text === "string")
-        .map((part) => part.text)
-        .join("");
-    return reasoning.length === 0 ? null : reasoning;
-};
-const projectPrompt = (prompt) => {
-    let entries = [];
-    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, frame) => {
-    if (frame._tag === "Snapshot") {
-        return [{ ...model, lastSeq: frame.seq, entries: projectPrompt(frame.transcript), streaming: null }, Option.none()];
-    }
-    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 "SessionStatus":
-            return applyStatus(withSeq, frame.status);
-    }
-};
 const jsonText = (value) => {
     try {
         return JSON.stringify(value, null, 2) ?? "undefined";
@@ -521,12 +272,6 @@ export const conversationItems = (model) => {
         : [];
     return [...entries, ...streaming, ...waiting, ...approval, ...failure];
 };
-const isServerFrame = (incoming) => incoming._tag === "Event" ||
-    incoming._tag === "Suspended" ||
-    incoming._tag === "Failed" ||
-    incoming._tag === "Ended" ||
-    incoming._tag === "Snapshot" ||
-    incoming._tag === "SessionStatus";
 /** @experimental */
 export const update = dual(2, (model, message) => {
     switch (message._tag) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@batonfx/foldkit",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/transport": "0.6.4"
+    "@batonfx/transport": "0.7.1"
   },
   "peerDependencies": {
     "effect": ">=4.0.0-beta.88 <4.0.1",