@alexkroman1/aai-ui 0.12.2 → 0.13.0

package/dist/inbox-protocol.d.ts

@@ -0,0 +1,128 @@
+/**
+ * The browser half of the `WS /inbox` wire, without the socket: frames in, what
+ * to play and what to answer out.
+ *
+ * The server half is `aai-runtime`'s `aai-runtime/src/inbox/inbox.ts`, and the frames are
+ * declared once, as `InboxServerFrame` / `InboxClientFrame` on
+ * `@alexkroman1/aai/protocol`, which both ends are typed against: a notice
+ * header followed by `bytes` of audio in binary frames, answered with an ack or
+ * a busy. What this module adds are the
+ * CLIENT's rules, which the wire cannot state and which a firmware client
+ * (`inbox.c` on an ESP32 speaker) worked out first:
+ *
+ * - **A repeat is acked, never replayed.** Delivery is at-least-once — an ack
+ *   lost on the way back is the same notice again, by id — so the last
+ *   {@link RECENT_NOTICE_IDS} acked ids are remembered and a repeat of one is
+ *   acked without being played.
+ * - **A repeat is acked EVEN WHILE BUSY.** Busy means "try again later", and for
+ *   a notice already played there is no later: answering busy would have the
+ *   run resend it until its attempts run out. And since the server settles a
+ *   notice as busy if ANY holder was busy, a busy repeat also re-offers it to
+ *   every other holder of the client.
+ * - **A header mid-notice cuts the last one short, UNACKED.** The server sends
+ *   one notice per client at a time, so a new header means the old one's socket
+ *   write was abandoned; it will be resent, and acking what arrived would lose
+ *   the rest.
+ * - **Audio past `bytes` is dropped; bytes with no header are dropped.** A
+ *   header that is not one this can take is left UNANSWERED (the server's ack
+ *   timeout settles it) — the same as the device, which cannot answer an id it
+ *   could not parse.
+ *
+ * The live-conversation frames a holder asked for with `?events=1`
+ * (`aai-runtime/src/inbox/event-feed.ts` server-side) share the text channel and are told apart
+ * by {@link parseInboxEvent}.
+ */
+import { type InboxClientFrame, type InboxServerFrame } from "@alexkroman1/aai/protocol";
+/**
+ * One notice from the agent — what a workflow step sent with
+ * `stepNotifyClient`, e.g. a reminder coming due.
+ *
+ * @public
+ */
+export type InboxNotice = {
+    /** Identifies the DELIVERY (usually the run id); a repeat carries the same one. */
+    readonly id: string;
+    /** What the notice is, as the step named it — `"reminder"`, say. */
+    readonly event: string;
+    /** The step's `data`, when it sent an object. */
+    readonly data?: Readonly<Record<string, unknown>>;
+    /**
+     * The notice's audio as sent: `stepSpeak`'s PCM16LE mono, which `useInbox`'s
+     * built-in playback plays at 16 kHz. Empty for a notice with no audio.
+     */
+    readonly pcm: Uint8Array;
+};
+/**
+ * One frame of the client's live conversation, sent to a holder that asked
+ * for events: every session bound to the client, this tab's own included —
+ * filter on `sessionId` (`useSessionId()`) to show only the OTHER ones.
+ *
+ * @public
+ */
+export type InboxEvent = {
+    readonly type: "session_event";
+    readonly sessionId: string;
+    /** The session event as the session socket would carry it (`type`, then its fields). */
+    readonly event: {
+        readonly type: string;
+    } & Readonly<Record<string, unknown>>;
+} | {
+    readonly type: "session_ended";
+    readonly sessionId: string;
+};
+/**
+ * The largest notice taken: 60 s of 16 kHz PCM16, the firmware's
+ * `PROTO_NOTICE_MAX_BYTES`. A header claiming more is refused rather than
+ * buffered — a page holds the whole notice in memory before it plays.
+ */
+export declare const MAX_NOTICE_BYTES: number;
+/** How many acked ids are remembered to drop a repeat — the firmware's `RECENT_IDS`. */
+export declare const RECENT_NOTICE_IDS = 8;
+/** The wire's notice header, as the server sends it. */
+type NoticeFrame = Extract<InboxServerFrame, {
+    type: "notice";
+}>;
+/**
+ * A notice header this client can take: the wire's, minus its `type`, with
+ * `data` kept only when it is an object.
+ */
+export type NoticeHeader = Omit<NoticeFrame, "type" | "data"> & {
+    data?: Record<string, unknown>;
+};
+/** What the client answers — the wire's client→server frame. */
+export type NoticeReply = InboxClientFrame;
+/** What one frame produced: a notice to play (not for a repeat), and the reply. */
+export type AssemblerOutput = {
+    notice?: InboxNotice;
+    reply: NoticeReply;
+};
+/**
+ * A notice header this client can take, or undefined — for anything that is
+ * not one, and for a header it must refuse (odd byte count: not PCM16; more
+ * than {@link MAX_NOTICE_BYTES}).
+ */
+export declare function parseNoticeHeader(json: string): NoticeHeader | undefined;
+/**
+ * A live-event frame, or undefined for anything else (a notice header, say).
+ * The wire's live frames are returned as the published {@link InboxEvent}, so
+ * that view cannot drift from what the server sends without this failing to
+ * compile.
+ */
+export declare function parseInboxEvent(json: string): InboxEvent | undefined;
+/**
+ * The receiving state machine of one socket — see the module doc for its four
+ * rules. `busy()` is asked when a NEW notice's header arrives, never for a
+ * repeat.
+ */
+export declare function createNoticeAssembler(busy: () => boolean): {
+    /** A text frame that is not a live event. A header mid-notice drops the last one, unacked. */
+    text(json: string): AssemblerOutput | undefined;
+    /**
+     * Forget a notice half-received (its socket closed), keeping the repeat
+     * memory — the redelivery after a lost ack comes on the NEXT socket.
+     */
+    reset(): void;
+    /** A binary frame of the pending notice's audio. */
+    bytes(chunk: Uint8Array): AssemblerOutput | undefined;
+};
+export {};

package/dist/inbox.d.ts

@@ -0,0 +1,132 @@
+/**
+ * `createInbox()` — hold this client's `WS /inbox?client=` socket open, so a
+ * workflow run can reach the page after the voice session that started it has
+ * closed: a reminder coming due, a research job finishing.
+ *
+ * The framework-agnostic core `useInbox()` wraps; the receiving rules (acks,
+ * repeats, busy, a notice cut short) are `inbox-protocol.ts`, and the server
+ * half is `aai-runtime`'s `aai-runtime/src/inbox/inbox.ts`.
+ *
+ * - **Held from creation, reconnected until `close()`**, on a jittered backoff
+ *   from 1 s doubling to 30 s (`jitteredBackoff`), reset by every open. The
+ *   jitter matters here more than for most loops: an agent restart drops every
+ *   open inbox at once, and every tab of every user comes back together.
+ * - **Its own socket, not partysocket.** The session's reconnecting socket
+ *   re-brokers and resumes; the inbox has nothing to resume — a notice in
+ *   flight when the socket drops settles `"disconnected"` server-side and the
+ *   step resends it — so a plain `WebSocket` and a timer are the whole job.
+ * - **The client id is asked per ATTEMPT**, like the session's `?client=`, so a
+ *   page that changes it (joining a speaker) is heard on the next reconnect. No
+ *   valid id means no socket this attempt — the loop keeps asking on its
+ *   backoff, so a getter that answers later is picked up.
+ * - **`?holder=` names this TAB** (`session.identity.holderId()`), so the page
+ *   coexists with the device and the other tabs holding the same client rather
+ *   than replacing their sockets.
+ * - **A gated server checks a ticket here exactly as on `/websocket`**, so the
+ *   inbox presents one the same way (`token`, asked per attempt, carried by
+ *   `session/ticket.ts`). `useInbox()` passes the session's
+ *   (`session.identity.ticket()`). A token answered synchronously (or none)
+ *   dials at once; a Promise dials when it settles.
+ * - **The URL is the agent's base URL + `inbox`**, like the session's
+ *   `websocket`. On the managed platform the route is DIRECT-DIAL (served on the
+ *   sandbox URL, not proxied at `/:slug/inbox`), so today this reaches an agent
+ *   under `aai dev`, `aai start` or a self-hosted server.
+ *
+ * @module
+ */
+import { type InboxEvent, type InboxNotice } from "./inbox-protocol.ts";
+import type { VoiceSessionOptions, WebSocketConstructor } from "./types.ts";
+/** The first reconnect window; each failure doubles it. */
+export declare const INBOX_RECONNECT_BASE_MS = 1000;
+/** The largest reconnect window. */
+export declare const INBOX_RECONNECT_MAX_MS = 30000;
+/**
+ * Options for {@link createInbox}.
+ *
+ * @public
+ */
+export type CreateInboxOptions = {
+    /** The agent's base URL — the socket is `<platformUrl>/inbox`. */
+    platformUrl: string;
+    /**
+     * This client's id, as the session sends it: a string, or a getter asked on
+     * every connection attempt. An answer that is not a valid client id (letters,
+     * digits, `-`, `_`, at most 64) opens no socket that attempt.
+     */
+    client: string | (() => string | undefined);
+    /**
+     * This page's holder id among the client's holders — per TAB (see
+     * `session.identity.holderId()`). Same rule as a client id.
+     */
+    holder: string;
+    /**
+     * Asked when a new notice arrives: `true` answers `busy` and the step sends it
+     * again later. Default: never busy. Not asked for a repeat, which is acked.
+     */
+    busy?: (() => boolean) | undefined;
+    /** A notice arrived whole — once per delivery id; a repeat is acked, not delivered. */
+    onNotice?: ((notice: InboxNotice) => void) | undefined;
+    /** A frame of the client's live conversation — only with `events`. */
+    onEvent?: ((event: InboxEvent) => void) | undefined;
+    /**
+     * Ask for the client's live conversation (`?events=1`). Default: whether an
+     * `onEvent` was given.
+     */
+    events?: boolean | undefined;
+    /**
+     * The session ticket to present, for a server that requires one — the same
+     * option, with the same rules, as `VoiceSessionOptions.token`: a string, or a
+     * getter asked on EVERY connection attempt (told `sessionId: undefined`; the
+     * inbox resumes no session). A getter that throws or rejects presents none.
+     * `useInbox()` fills it in from the session.
+     */
+    token?: VoiceSessionOptions["token"];
+    /** WebSocket constructor override, for tests. Default: the page's `WebSocket`. */
+    WebSocket?: WebSocketConstructor | undefined;
+};
+/**
+ * A held inbox socket — see {@link createInbox}.
+ *
+ * @sealed Only `createInbox` produces one.
+ *
+ * @public
+ */
+export type Inbox = {
+    /** Whether the socket is open now. */
+    connected(): boolean;
+    /** Called whenever `connected()` changes. Returns the unsubscribe. */
+    subscribe(callback: () => void): () => void;
+    /** Close the socket for good and stop reconnecting. */
+    close(): void;
+};
+/**
+ * Hold `WS /inbox?client=&holder=` open, reconnecting with backoff, and answer
+ * every notice the way the protocol requires — `ack` once it has arrived whole,
+ * `busy` when `busy()` says so, a repeat acked without being delivered twice.
+ *
+ * Most clients call `useInbox()`, which fills in the client, holder and base URL
+ * from the session and plays each notice. This is the same thing for a page
+ * with no React, or for an inbox held under a different client than the
+ * session's.
+ *
+ * @example
+ * ```ts
+ * import { createInbox } from "@alexkroman1/aai-ui";
+ *
+ * const inbox = createInbox({
+ *   platformUrl: "https://speaker.example/",
+ *   client: "kitchen-speaker",
+ *   holder: "kitchen-speaker-tab1",
+ *   onNotice: (notice) => console.log(notice.event, notice.data),
+ * });
+ * // later
+ * inbox.close();
+ * ```
+ *
+ * @param options - Where to connect, as whom, and what to do with a notice.
+ * @returns The {@link Inbox} handle.
+ * @throws RangeError when `holder` is not a valid holder id.
+ *
+ * @public
+ */
+export declare function createInbox(options: CreateInboxOptions): Inbox;

package/dist/index.d.ts

@@ -1,37 +1,134 @@
 /**
- * Browser client library for AAI voice agents.
+ * The browser client for aai agents — React 19 hooks and components over a
+ * framework-agnostic session core (WebSocket + microphone + playback).
  *
- * Provides WebSocket session management, audio capture/playback,
- * and Preact UI components. For a narrower import without the Preact
- * dependency, use `@aai/ui/session`.
+ * ## Start with a mount
  *
- * @example
- * ```tsx
- * import { App, defineClient } from "@aai/ui";
+ * A client is one `client.tsx` calling one mount, and WHICH mount is the only
+ * structural decision on this surface — it follows the agent's front door:
  *
- * defineClient(App, { target: "#app" });
- * ```
+ * | The agent is | The page calls | It talks to |
+ * | --- | --- | --- |
+ * | a voice agent (the default) | {@link mountClient} | a live session: socket, microphone, playback |
+ * | a `workflowApp()` / `agent({ mode: "workflow-app" })` | {@link mountPage} | the workflow HTTP API — no session, no socket, no mic |
+ *
+ * There is no route to write and no glue file: the agent server already serves
+ * both, so a component talks to a live agent directly. {@link createBrowserSession}
+ * is the same session core with no React, for a page built on something else.
+ *
+ * ## Then the hook that answers your question
+ *
+ * The hooks are grouped by what they read, and within a group the narrow one
+ * exists so a component re-renders on its own slice rather than on every frame:
+ *
+ * | Reading | Hooks |
+ * | --- | --- |
+ * | the call itself | {@link useSession} (everything), {@link useSessionStatus}, {@link useSessionError}, {@link useSessionActions}, {@link useSessionSelector} |
+ * | who the client is | {@link useSessionId}, {@link useClientId}, {@link browserClientId}, {@link createLinkedClient} |
+ * | a run reaching the page later | {@link useInbox} (a reminder, a finished job — played when it lands) |
+ * | what was said | {@link useConversation}, {@link useUserTranscript}, {@link useConversationLog} (across sessions, persisted) |
+ * | the talk button | {@link useTapToTalk} (tap on, tap off), {@link usePushToTalk} (hold, for `turnTaking: { detection: "manual" }`) |
+ * | the agent's own `/api` routes | {@link useRoute}, {@link useRouteMutation}, {@link routeFetch}, {@link useClientRuns} (a `clientRunsRoutes()` pair) |
+ * | what this browser remembers | {@link useStoredValue} / {@link createStoredValue}, {@link phoneE164} |
+ * | what the agent projects | {@link useAgentState} — pass the `slot.projected` the agent declared in `syncState`, and it selects that slot, types it AND supplies the frame rendered before the first push; {@link selectAgentState} is the same slot as a `useSessionSelector` selector |
+ * | tools, as they run | {@link useToolCallStart}, {@link useToolResult}, {@link useEvent} |
+ * | a durable run | {@link useWorkflowSubmit} (start one), {@link useWorkflowRun} (watch one), {@link useWorkflowRuns} / {@link useWorkflows} (list), {@link useWorkflowProgress} / {@link useWorkflowStream} (its output as it arrives) |
+ * | page chrome | {@link useTheme}, {@link useCopy}, {@link useFlash}, {@link useDownloadUrl}, {@link useRunKey} |
+ *
+ * Everything else here is a COMPONENT — chat chrome ({@link MessageList},
+ * {@link ChatView}, {@link Controls}, {@link StartScreen}), workflow forms
+ * ({@link Form}, {@link WorkflowFields}, the `*Field` set), and the small
+ * primitives pages kept re-writing ({@link AutoScroll}, {@link Markdown},
+ * {@link Facts}, {@link ToolCallRow}). None is required: the hooks are the API
+ * and the components are one rendering of it.
+ *
+ * ## Two things worth knowing before the reference below
+ *
+ * **Several names are re-exported from `@alexkroman1/aai`** —
+ * {@link WorkflowInputOf}, {@link WorkflowOutputOf}, {@link WorkflowSummary} and
+ * {@link AgentClient}, plus {@link isTerminal} and {@link ClientConfigResponse}.
+ * They are one declaration with two reference pages, not two types; a page takes
+ * them from here, an `agent.ts` from there.
+ *
+ * **{@link createWorkflowApi} is the browser's client, and there is one other.**
+ * `createAgentClient` (`@alexkroman1/aai/workflow-api`) is the same
+ * {@link AgentClient} for a caller with no page to default its base URL from — a
+ * script, a cron job, a server. Reach for the one here whenever the code runs in
+ * a page the agent serves; it delegates to that factory, so there is one
+ * implementation of the routes and one `config()`. (It used to answer the
+ * narrower `WorkflowApi`, which made a page wanting the agent's own name build a
+ * second client for one read.)
+ *
+ * @module
  */
-export { App } from "./_components/app.tsx";
-export type { ButtonSize, ButtonVariant } from "./_components/button.tsx";
-export { Button } from "./_components/button.tsx";
-export { ChatView } from "./_components/chat-view.tsx";
-export { Controls } from "./_components/controls.tsx";
-export { ErrorBanner } from "./_components/error-banner.tsx";
-export { MessageBubble } from "./_components/message-bubble.tsx";
-export { MessageList } from "./_components/message-list.tsx";
-export { SidebarLayout } from "./_components/sidebar-layout.tsx";
-export { StartScreen } from "./_components/start-screen.tsx";
-export { StateIndicator } from "./_components/state-indicator.tsx";
-export { ThinkingIndicator } from "./_components/thinking-indicator.tsx";
-export { ToolCallBlock } from "./_components/tool-call-block.tsx";
-export { Transcript } from "./_components/transcript.tsx";
-export type { ClientConfig, ClientTheme } from "./client-context.ts";
-export { useClientConfig } from "./client-context.ts";
-export type { ClientHandle, ClientOptions } from "./define-client.tsx";
-export { defineClient } from "./define-client.tsx";
-export type { VoiceSession } from "./session.ts";
-export { createVoiceSession } from "./session.ts";
-export type { SessionSignals } from "./signals.ts";
-export { createSessionControls, SessionProvider, useAutoScroll, useSession, useToolCallStart, useToolResult, } from "./signals.ts";
-export type { AgentState, ChatMessage, Reactive, SessionError, SessionErrorCode, ToolCallInfo, VoiceSessionOptions, } from "./types.ts";
+export { type ClientRun, type ClientRunStatus, type ClientRunsResponse, errorMessage, } from "@alexkroman1/aai";
+export { AGENT_STATE_LABELS } from "./agent-state-labels.ts";
+export { type ClientConfigResponse, fetchClientConfig, } from "./client-config.ts";
+export { browserClientId, type SessionIdentity } from "./client-identity.ts";
+export { useClientTool } from "./client-tool.ts";
+export { AudioResult, type AudioResultCaptions, type AudioResultProps, } from "./components/audio-result.tsx";
+export { AutoScroll } from "./components/auto-scroll.tsx";
+export { BulletList, type BulletListProps } from "./components/bullet-list.tsx";
+export { Button, type ButtonSize, type ButtonVariant } from "./components/button.tsx";
+export { ChatView } from "./components/chat-view.tsx";
+export { ConsoleShell, type ConsoleShellProps } from "./components/console-shell.tsx";
+export { Controls, type ControlsProps } from "./components/controls.tsx";
+export { ConversationView, type ConversationViewProps, } from "./components/conversation-view.tsx";
+export { Facts, type FactsProps } from "./components/facts.tsx";
+export { CheckboxField, Field, type FieldShell, FileField, type FileReadMode, type FileValue, Form, type FormProps, type FormValues, NumberField, SelectField, SubmitButton, TextAreaField, TextField, } from "./components/form.tsx";
+export { Markdown, type MarkdownProps, type MarkdownVariant } from "./components/markdown.tsx";
+export { MessageList, type MessageListProps } from "./components/message-list.tsx";
+export { type SessionControlAction, type SessionControlButton, SessionControls, type SessionControlsLabels, type SessionControlsProps, } from "./components/session-controls.tsx";
+export { SessionErrorBanner, type SessionErrorBannerProps, } from "./components/session-error-banner.tsx";
+export { SessionStateDot, type SessionStateDotProps, } from "./components/session-state-dot.tsx";
+export { SidebarLayout } from "./components/sidebar-layout.tsx";
+export { StartScreen } from "./components/start-screen.tsx";
+export { ToolCallRow, type ToolCallRowProps, type ToolCallRowVariant, } from "./components/tool-call-row.tsx";
+export type { ToolDisplayConfig } from "./components/tool-config-context.ts";
+export { UploadProgressBar } from "./components/upload-progress.tsx";
+export { WorkflowFields } from "./components/workflow-fields.tsx";
+export { WorkflowPendingNote, type WorkflowPendingNoteProps, } from "./components/workflow-pending-note.tsx";
+export { WorkflowProgress } from "./components/workflow-progress.tsx";
+export { WorkflowRunError, type WorkflowRunErrorProps, } from "./components/workflow-run-error.tsx";
+export { WorkflowRunPanel, type WorkflowRunPanelProps, } from "./components/workflow-run-panel.tsx";
+export type { Session, SessionActions } from "./context.ts";
+export { useSession, useSessionActions, useSessionError, useSessionSelector, useSessionStatus, useTheme, } from "./context.ts";
+export { type ConversationLogEntry, inboxEventToItem } from "./conversation-log.ts";
+export type { ClientConfig, ClientHandle } from "./define-client.tsx";
+export { mountClient } from "./define-client.tsx";
+export { selectAgentState, useAgentState, useEvent, useToolCallStart, useToolResult, } from "./hooks.ts";
+export { type CreateInboxOptions, createInbox, type Inbox } from "./inbox.ts";
+export type { InboxEvent, InboxNotice } from "./inbox-protocol.ts";
+export { createLinkedClient, type LinkedClient, type LinkedClientOptions, } from "./linked-client.ts";
+export { mountPage, type PageConfig, type PageHandle } from "./page.tsx";
+export { type PhoneE164Options, phoneE164 } from "./phone.ts";
+export { type RouteFetchOptions, type RouteMethod, routeFetch } from "./route-fetch.ts";
+export type { AgentCustomEvent, AgentStateFrame, BrowserSession, browserSessionBrand, SendTextOptions, SessionSnapshot, ToolCallOutcome, UserTurnControls, } from "./session/index.ts";
+export { createBrowserSession } from "./session/index.ts";
+export { createStoredValue, type StoredValue, type StoredValueOptions, useStoredValue, } from "./stored-value.ts";
+export type { AgentState, ChatMessage, ClientTheme, SessionError, SessionErrorCode, ToolCallInfo, VoiceSessionOptions, WebSocketConstructor, } from "./types.ts";
+export { type UseClientRunsOptions, type UseClientRunsResult, useClientRuns, } from "./use-client-runs.ts";
+export { type ConversationItem, type UseConversationResult, useConversation, } from "./use-conversation.ts";
+export { type UseConversationLogOptions, type UseConversationLogResult, useConversationLog, } from "./use-conversation-log.ts";
+export { type UseCopyResult, useCopy } from "./use-copy.ts";
+export { type UseDownloadUrlOptions, type UseDownloadUrlResult, useDownloadUrl, } from "./use-download-url.ts";
+export { type UseFlashResult, useFlash } from "./use-flash.ts";
+export { type UseInboxOptions, type UseInboxResult, useInbox } from "./use-inbox.ts";
+export { type UsePushToTalkOptions, type UsePushToTalkResult, usePushToTalk, } from "./use-push-to-talk.ts";
+export { type UseRouteOptions, type UseRouteResult, useRoute } from "./use-route.ts";
+export { type RouteMutationRunOptions, type UseRouteMutationOptions, type UseRouteMutationResult, useRouteMutation, } from "./use-route-mutation.ts";
+export { useRunKey } from "./use-run-key.ts";
+export { type UseSessionControlsResult, useSessionControls } from "./use-session-controls.ts";
+export { useClientId, useSessionId } from "./use-session-id.ts";
+export { type UseTapToTalkOptions, type UseTapToTalkResult, useTapToTalk, } from "./use-tap-to-talk.ts";
+export { type UseUserTranscriptResult, useUserTranscript } from "./use-user-transcript.ts";
+export { type UploadStatus, type UseWorkflowSubmitOptions, useWorkflowSubmit, type WorkflowSubmission, } from "./use-workflow-form.ts";
+export { type UseWorkflowProgressResult, useWorkflowProgress, } from "./use-workflow-progress.ts";
+export { type UseWorkflowRunResult, useWorkflowRun } from "./use-workflow-run.ts";
+export { type UseWorkflowRunsOptions, type UseWorkflowRunsResult, useWorkflowRuns, } from "./use-workflow-runs.ts";
+export { type UseWorkflowStreamOptions, useWorkflowStream, type WorkflowStreamSubmission, } from "./use-workflow-stream.ts";
+export { type UseWorkflowsOptions, type UseWorkflowsResult, useWorkflows, } from "./use-workflows.ts";
+export { type AgentClient, createWorkflowApi, isTerminal, type WorkflowApi, type WorkflowApiOptions, type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRun, type WorkflowRunStatus, type WorkflowSummary, } from "./workflow-client.ts";
+export type { SubmitInputOf } from "./workflow-def-types.ts";
+export { fieldKindFor, type WorkflowFieldKind } from "./workflow-field-kind.ts";
+export { WORKFLOW_STATUS_LABELS } from "./workflow-status-labels.ts";