@batonfx/foldkit 0.4.0 → 0.4.1

package/dist/chat.js

@@ -0,0 +1,605 @@
+import { Cause, Equivalence, Effect, Option, Schema, Stream } from "effect";
+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 { AgentConnection, Incoming, SendFailed } from "./connection.js";
+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"]);
+const ToolEntryFields = {
+    callId: Schema.String,
+    name: Schema.String,
+    params: Schema.Unknown,
+    phase: ToolPendingPhase,
+    outcome: Schema.suspend(() => 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: Incoming };
+const ModelStreaming = Schema.Struct({
+    turn: Schema.Number,
+    text: Schema.String,
+    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 */
+export const UserEntry = m("UserEntry", UserEntryFields);
+/** @experimental */
+export const AssistantEntry = m("AssistantEntry", AssistantEntryFields);
+/** @experimental */
+export const ToolEntry = m("ToolEntry", ToolEntryFields);
+/** @experimental */
+export const ChatEntry = Schema.Union([UserEntry, AssistantEntry, ToolEntry]);
+/** @experimental */
+export const Idle = m("Idle");
+/** @experimental */
+export const Running = m("Running", RunningFields);
+/** @experimental */
+export const AwaitingApproval = m("AwaitingApproval", AwaitingApprovalFields);
+/** @experimental */
+export const Failed = m("Failed", {
+    message: Schema.String,
+});
+/** @experimental */
+export const RunState = Schema.Union([Idle, Running, AwaitingApproval, Failed]);
+/** @experimental */
+export const 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 = m("ReceivedAgent", ReceivedAgentFields);
+/** @experimental */
+export const OpenedSession = m("OpenedSession", OpenedSessionFields);
+/** @experimental */
+export const ChangedDraft = m("ChangedDraft", UserEntryFields);
+/** @experimental */
+export const SubmittedMessage = m("SubmittedMessage");
+/** @experimental */
+export const ClickedCancel = m("ClickedCancel");
+/** @experimental */
+export const ClickedApprove = m("ClickedApprove");
+/** @experimental */
+export const ClickedDeny = m("ClickedDeny", ClickedDenyFields);
+/** @experimental */
+export const SentUserMessage = m("SentUserMessage");
+/** @experimental */
+export const ResolvedApproval = m("ResolvedApproval");
+/** @experimental */
+export const CancelledRun = m("CancelledRun");
+/** @experimental */
+export const FailedAgentCommand = m("FailedAgentCommand", StringReasonFields);
+/** @experimental */
+export const Message = Schema.Union([
+    ReceivedAgent,
+    OpenedSession,
+    ChangedDraft,
+    SubmittedMessage,
+    ClickedCancel,
+    ClickedApprove,
+    ClickedDeny,
+    SentUserMessage,
+    ResolvedApproval,
+    CancelledRun,
+    FailedAgentCommand,
+]);
+/** @experimental */
+export const RunCompleted = m("RunCompleted", RunCompletedFields);
+/** @experimental */
+export const ApprovalRequired = m("ApprovalRequired");
+/** @experimental */
+export const RunFailed = m("RunFailed", {
+    message: Schema.String,
+});
+/** @experimental */
+export const OutMessage = Schema.Union([RunCompleted, ApprovalRequired, RunFailed]);
+/** @experimental */
+export const MessageAlign = Schema.Literals(["start", "end"]);
+/** @experimental */
+export const PromptInputStatus = Schema.Literals(["idle", "submitted", "streaming", "error"]);
+/** @experimental */
+export const ToolStatus = Schema.Literals(["input-streaming", "input-available", "output-available", "output-error"]);
+/** @experimental */
+export const UserConversationItem = m("UserConversationItem", { key: Schema.String, align: MessageAlign, entry: UserEntry });
+/** @experimental */
+export const AssistantConversationItem = m("AssistantConversationItem", { key: Schema.String, align: MessageAlign, entry: AssistantEntry });
+/** @experimental */
+export const ToolConversationItem = m("ToolConversationItem", {
+    key: Schema.String,
+    align: MessageAlign,
+    entry: ToolEntry,
+    status: ToolStatus,
+    input: Schema.String,
+});
+/** @experimental */
+export const StreamingConversationItem = m("StreamingConversationItem", {
+    key: Schema.String,
+    align: MessageAlign,
+    text: Schema.String,
+    reasoning: Schema.String,
+    isStreaming: Schema.Boolean,
+});
+/** @experimental */
+export const WaitingConversationItem = m("WaitingConversationItem", { key: Schema.String, align: MessageAlign });
+/** @experimental */
+export const ApprovalConversationItem = m("ApprovalConversationItem", {
+    key: Schema.String,
+    align: MessageAlign,
+    token: Schema.String,
+    toolName: Schema.String,
+    params: Schema.Unknown,
+});
+/** @experimental */
+export const FailureConversationItem = m("FailureConversationItem", { key: Schema.String, align: MessageAlign, message: Schema.String });
+/** @experimental */
+export const ConversationItem = Schema.Union([
+    UserConversationItem,
+    AssistantConversationItem,
+    ToolConversationItem,
+    StreamingConversationItem,
+    WaitingConversationItem,
+    ApprovalConversationItem,
+    FailureConversationItem,
+]);
+/** @experimental */
+export const initialModel = (sessionId = null) => ({
+    sessionId,
+    connection: "disconnected",
+    lastSeq: -1,
+    run: Idle(),
+    entries: [],
+    streaming: null,
+    draft: "",
+});
+const commandFailed = (error) => FailedAgentCommand({ reason: error instanceof SendFailed ? error.reason : String(error) });
+const catchCommandFailure = (effect) => effect.pipe(Effect.catchCause((cause) => Effect.succeed(commandFailed(Cause.squash(cause)))));
+/** @experimental */
+export const SendUserMessage = define("SendUserMessage", { sessionId: Schema.String, text: Schema.String }, SentUserMessage, FailedAgentCommand)(({ sessionId, text }) => AgentConnection.use((connection) => catchCommandFailure(connection.send({ _tag: "SendMessage", sessionId, prompt: text }).pipe(Effect.as(SentUserMessage())))));
+/** @experimental */
+export const ResolveApproval = define("ResolveApproval", {
+    sessionId: Schema.String,
+    token: Schema.String,
+    approved: Schema.Boolean,
+    reason: Schema.NullOr(Schema.String),
+}, ResolvedApproval, FailedAgentCommand)(({ sessionId, token, approved, reason }) => {
+    const decision = approved
+        ? { _tag: "Approved" }
+        : reason === null
+            ? { _tag: "Denied" }
+            : { _tag: "Denied", reason };
+    return AgentConnection.use((connection) => catchCommandFailure(connection.send({ _tag: "ResolveApproval", sessionId, token, decision }).pipe(Effect.as(ResolvedApproval()))));
+});
+/** @experimental */
+export const CancelRun = define("CancelRun", { sessionId: Schema.String }, CancelledRun, FailedAgentCommand)(({ sessionId }) => AgentConnection.use((connection) => catchCommandFailure(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/MiddlewareViolation":
+            return failure.detail;
+        case "@batonfx/core/TurnLimitExceeded":
+            return `Turn limit exceeded at turn ${failure.turn}`;
+    }
+};
+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.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 jsonText = (value) => {
+    try {
+        return JSON.stringify(value, null, 2) ?? "undefined";
+    }
+    catch {
+        return String(value);
+    }
+};
+/** @experimental */
+export const promptInputStatusOf = (run) => {
+    switch (run._tag) {
+        case "Idle":
+            return "idle";
+        case "Running":
+            return "streaming";
+        case "AwaitingApproval":
+            return "submitted";
+        case "Failed":
+            return "error";
+    }
+};
+/** @experimental */
+export const toolStatusOf = (entry) => {
+    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, index) => {
+    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) => {
+    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._tag === "Event" ||
+    incoming._tag === "Suspended" ||
+    incoming._tag === "Failed" ||
+    incoming._tag === "Ended" ||
+    incoming._tag === "Snapshot" ||
+    incoming._tag === "SessionStatus";
+/** @experimental */
+export const update = (model, message) => {
+    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 "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": {
+            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 = make()((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(AgentConnection.use((connection) => {
+                const afterSeq = readDependencies().afterSeq;
+                return Effect.succeed(connection
+                    .frames(afterSeq < 0 ? { sessionId } : { sessionId, afterSeq })
+                    .pipe(Stream.map((incoming) => ReceivedAgent({ incoming }))));
+            }));
+        },
+    }),
+}));

package/dist/connection.d.ts

@@ -0,0 +1,41 @@
+import { Cause, Context, Effect, Layer, Schema, Stream } from "effect";
+import { Socket } from "effect/unstable/socket";
+import type { CallableTaggedStruct } from "foldkit/schema";
+import { Wire } from "@batonfx/transport";
+/** @experimental */
+export declare const ConnectionOpened: CallableTaggedStruct<"ConnectionOpened", {}>;
+/** @experimental */
+export declare const ConnectionLost: CallableTaggedStruct<"ConnectionLost", {}>;
+/** @experimental */
+export declare const ConnectionFailed: CallableTaggedStruct<"ConnectionFailed", {
+    reason: typeof Schema.String;
+}>;
+/** @experimental */
+export type Incoming = Wire.LooseServerFrameType | typeof ConnectionOpened.Type | typeof ConnectionLost.Type | typeof ConnectionFailed.Type;
+/** @experimental */
+export declare const Incoming: Schema.Schema<Incoming>;
+declare const SendFailed_base: Schema.Class<SendFailed, Schema.TaggedStruct<"@batonfx/foldkit/SendFailed", {
+    readonly reason: Schema.String;
+}>, Cause.YieldableError>;
+/** @experimental */
+export declare class SendFailed extends SendFailed_base {
+}
+/** @experimental */
+export interface Interface {
+    readonly frames: (options: {
+        readonly sessionId: string;
+        readonly afterSeq?: number;
+    }) => Stream.Stream<Incoming, never>;
+    readonly send: (frame: Wire.ClientFrameType) => Effect.Effect<void, SendFailed>;
+}
+declare const AgentConnection_base: Context.ServiceClass<AgentConnection, "@batonfx/foldkit/AgentConnection", Interface>;
+/** @experimental */
+export declare class AgentConnection extends AgentConnection_base {
+}
+/** @experimental */
+export declare const testLayer: (implementation: Interface) => Layer.Layer<AgentConnection>;
+/** @experimental */
+export declare const layerWebSocket: (options: {
+    readonly url: string;
+}) => Layer.Layer<AgentConnection, never, Socket.WebSocketConstructor>;
+export {};