@batonfx/foldkit 0.4.0 → 0.4.1

package/README.md

@@ -0,0 +1,5 @@
+# `@batonfx/foldkit`
+
+FoldKit adapter for Baton transport sessions and chat UI.
+
+See the [Baton documentation](https://github.com/In-Time-Tec/batonfx#readme) for installation, examples, and API guidance.

package/dist/chat.d.ts

@@ -0,0 +1,271 @@
+import { Equivalence, Effect, Option, Schema, Stream } from "effect";
+import { type Command } from "foldkit/command";
+import type { CallableTaggedStruct } from "foldkit/schema";
+import { AgentConnection, Incoming } from "./connection.js";
+declare const CompletedFields: {
+    isFailure: Schema.Boolean;
+    result: Schema.Unknown;
+};
+declare const UserEntryFields: {
+    text: Schema.String;
+};
+declare const AssistantEntryFields: {
+    text: Schema.String;
+    reasoning: Schema.NullOr<Schema.String>;
+};
+declare const RunCompletedFields: {
+    text: Schema.String;
+};
+declare const StringReasonFields: {
+    reason: Schema.String;
+};
+declare const OpenedSessionFields: {
+    sessionId: Schema.String;
+};
+/** @experimental */
+export declare const ToolPendingPhase: Schema.Literals<readonly ["called", "executing"]>;
+/** @experimental */
+export type ToolPendingPhase = typeof ToolPendingPhase.Type;
+declare const ToolEntryFields: {
+    callId: Schema.String;
+    name: Schema.String;
+    params: Schema.Unknown;
+    phase: Schema.Literals<readonly ["called", "executing"]>;
+    outcome: Schema.suspend<Schema.Schema<ToolOutcome>>;
+    progress: Schema.$Array<Schema.String>;
+};
+declare const RunningFields: {
+    turn: Schema.Number;
+};
+declare const AwaitingApprovalFields: {
+    token: Schema.String;
+    toolName: Schema.String;
+    params: Schema.Unknown;
+};
+declare const ClickedDenyFields: {
+    reason: Schema.NullOr<Schema.String>;
+};
+declare const ReceivedAgentFields: {
+    incoming: Schema.Schema<Incoming>;
+};
+declare const ModelStreaming: Schema.Struct<{
+    readonly turn: Schema.Number;
+    readonly text: Schema.String;
+    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 */
+export declare const ToolOutcome: Schema.Schema<ToolOutcome>;
+/** @experimental */
+export declare const UserEntry: CallableTaggedStruct<"UserEntry", typeof UserEntryFields>;
+/** @experimental */
+export declare const AssistantEntry: CallableTaggedStruct<"AssistantEntry", typeof AssistantEntryFields>;
+/** @experimental */
+export declare const ToolEntry: CallableTaggedStruct<"ToolEntry", typeof ToolEntryFields>;
+/** @experimental */
+export type ChatEntry = typeof UserEntry.Type | typeof AssistantEntry.Type | typeof ToolEntry.Type;
+/** @experimental */
+export declare const ChatEntry: Schema.Schema<ChatEntry>;
+/** @experimental */
+export declare const Idle: CallableTaggedStruct<"Idle", {}>;
+/** @experimental */
+export declare const Running: CallableTaggedStruct<"Running", typeof RunningFields>;
+/** @experimental */
+export declare const AwaitingApproval: CallableTaggedStruct<"AwaitingApproval", typeof AwaitingApprovalFields>;
+/** @experimental */
+export declare const Failed: CallableTaggedStruct<"Failed", {
+    message: typeof Schema.String;
+}>;
+/** @experimental */
+export type RunState = typeof Idle.Type | typeof Running.Type | typeof AwaitingApproval.Type | typeof Failed.Type;
+/** @experimental */
+export declare const RunState: Schema.Schema<RunState>;
+/** @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 declare const Model: Schema.Schema<Model>;
+/** @experimental */
+export declare const ReceivedAgent: CallableTaggedStruct<"ReceivedAgent", typeof ReceivedAgentFields>;
+/** @experimental */
+export declare const OpenedSession: CallableTaggedStruct<"OpenedSession", typeof OpenedSessionFields>;
+/** @experimental */
+export declare const ChangedDraft: CallableTaggedStruct<"ChangedDraft", typeof UserEntryFields>;
+/** @experimental */
+export declare const SubmittedMessage: CallableTaggedStruct<"SubmittedMessage", {}>;
+/** @experimental */
+export declare const ClickedCancel: CallableTaggedStruct<"ClickedCancel", {}>;
+/** @experimental */
+export declare const ClickedApprove: CallableTaggedStruct<"ClickedApprove", {}>;
+/** @experimental */
+export declare const ClickedDeny: CallableTaggedStruct<"ClickedDeny", typeof ClickedDenyFields>;
+/** @experimental */
+export declare const SentUserMessage: CallableTaggedStruct<"SentUserMessage", {}>;
+/** @experimental */
+export declare const ResolvedApproval: CallableTaggedStruct<"ResolvedApproval", {}>;
+/** @experimental */
+export declare const CancelledRun: CallableTaggedStruct<"CancelledRun", {}>;
+/** @experimental */
+export declare const FailedAgentCommand: CallableTaggedStruct<"FailedAgentCommand", typeof StringReasonFields>;
+/** @experimental */
+export type Message = typeof ReceivedAgent.Type | typeof OpenedSession.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 declare const Message: Schema.Schema<Message>;
+/** @experimental */
+export declare const RunCompleted: CallableTaggedStruct<"RunCompleted", typeof RunCompletedFields>;
+/** @experimental */
+export declare const ApprovalRequired: CallableTaggedStruct<"ApprovalRequired", {}>;
+/** @experimental */
+export declare const RunFailed: CallableTaggedStruct<"RunFailed", {
+    message: typeof Schema.String;
+}>;
+/** @experimental */
+export type OutMessage = typeof RunCompleted.Type | typeof ApprovalRequired.Type | typeof RunFailed.Type;
+/** @experimental */
+export declare const OutMessage: Schema.Schema<OutMessage>;
+/** @experimental */
+export declare const MessageAlign: Schema.Literals<readonly ["start", "end"]>;
+/** @experimental */
+export type MessageAlign = typeof MessageAlign.Type;
+/** @experimental */
+export declare const PromptInputStatus: Schema.Literals<readonly ["idle", "submitted", "streaming", "error"]>;
+/** @experimental */
+export type PromptInputStatus = typeof PromptInputStatus.Type;
+/** @experimental */
+export declare const ToolStatus: Schema.Literals<readonly ["input-streaming", "input-available", "output-available", "output-error"]>;
+/** @experimental */
+export type ToolStatus = typeof ToolStatus.Type;
+/** @experimental */
+export declare const UserConversationItem: CallableTaggedStruct<"UserConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+    entry: typeof UserEntry;
+}>;
+/** @experimental */
+export declare const AssistantConversationItem: CallableTaggedStruct<"AssistantConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+    entry: typeof AssistantEntry;
+}>;
+/** @experimental */
+export declare const ToolConversationItem: CallableTaggedStruct<"ToolConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+    entry: typeof ToolEntry;
+    status: typeof ToolStatus;
+    input: typeof Schema.String;
+}>;
+/** @experimental */
+export declare const StreamingConversationItem: CallableTaggedStruct<"StreamingConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+    text: typeof Schema.String;
+    reasoning: typeof Schema.String;
+    isStreaming: typeof Schema.Boolean;
+}>;
+/** @experimental */
+export declare const WaitingConversationItem: CallableTaggedStruct<"WaitingConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+}>;
+/** @experimental */
+export declare const ApprovalConversationItem: CallableTaggedStruct<"ApprovalConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+    token: typeof Schema.String;
+    toolName: typeof Schema.String;
+    params: typeof Schema.Unknown;
+}>;
+/** @experimental */
+export declare const FailureConversationItem: CallableTaggedStruct<"FailureConversationItem", {
+    key: typeof Schema.String;
+    align: typeof MessageAlign;
+    message: typeof 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 declare const ConversationItem: Schema.Schema<ConversationItem>;
+/** @experimental */
+export type ChatCommand = Command<Message, any, AgentConnection>;
+/** @experimental */
+export declare const initialModel: (sessionId?: string | null) => Model;
+/** @experimental */
+export declare const SendUserMessage: import("foldkit/command").CommandDefinitionWithArgs<"SendUserMessage", {
+    sessionId: Schema.String;
+    text: Schema.String;
+}, Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"FailedAgentCommand">;
+    reason: Schema.String;
+}, "Type"> | {
+    readonly _tag: "SentUserMessage";
+}, never, AgentConnection>>;
+/** @experimental */
+export declare const ResolveApproval: import("foldkit/command").CommandDefinitionWithArgs<"ResolveApproval", {
+    sessionId: Schema.String;
+    token: Schema.String;
+    approved: Schema.Boolean;
+    reason: Schema.NullOr<Schema.String>;
+}, Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"FailedAgentCommand">;
+    reason: Schema.String;
+}, "Type"> | {
+    readonly _tag: "ResolvedApproval";
+}, never, AgentConnection>>;
+/** @experimental */
+export declare const CancelRun: import("foldkit/command").CommandDefinitionWithArgs<"CancelRun", {
+    sessionId: Schema.String;
+}, Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"FailedAgentCommand">;
+    reason: Schema.String;
+}, "Type"> | {
+    readonly _tag: "CancelledRun";
+}, never, AgentConnection>>;
+/** @experimental */
+export declare const promptInputStatusOf: (run: RunState) => PromptInputStatus;
+/** @experimental */
+export declare const toolStatusOf: (entry: typeof ToolEntry.Type) => ToolStatus;
+/** @experimental */
+export declare const conversationItems: (model: Model) => ReadonlyArray<ConversationItem>;
+/** @experimental */
+export declare const update: (model: Model, message: Message) => readonly [Model, ReadonlyArray<ChatCommand>, Option.Option<OutMessage>];
+/** @experimental */
+export declare const subscriptions: {
+    readonly agentFrames: {
+        readonly dependenciesSchema: Schema.Schema<Schema.Struct.ReadonlySide<{
+            readonly sessionId: Schema.NullOr<Schema.String>;
+            readonly afterSeq: Schema.Number;
+        }, "Type">> & {
+            readonly fields: Schema.Struct.Fields;
+        };
+        readonly modelToDependencies: (model: Model) => Schema.Struct.ReadonlySide<{
+            readonly sessionId: Schema.NullOr<Schema.String>;
+            readonly afterSeq: Schema.Number;
+        }, "Type">;
+        readonly keepAliveEquivalence: Equivalence.Equivalence<Schema.Struct.ReadonlySide<{
+            readonly sessionId: Schema.NullOr<Schema.String>;
+            readonly afterSeq: Schema.Number;
+        }, "Type">>;
+        readonly dependenciesToStream: (dependencies: Schema.Struct.ReadonlySide<{
+            readonly sessionId: Schema.NullOr<Schema.String>;
+            readonly afterSeq: Schema.Number;
+        }, "Type">, readDependencies: () => Schema.Struct.ReadonlySide<{
+            readonly sessionId: Schema.NullOr<Schema.String>;
+            readonly afterSeq: Schema.Number;
+        }, "Type">) => Stream.Stream<Message, never, AgentConnection>;
+    } & {
+        readonly __subscription: never;
+    };
+};
+export {};