@usecontextlayer/pi-durable-assistant-ui 0.0.0-stage → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the pi-durable-assistant-ui authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,68 @@
-# Temporary Holding Version
+# Pi Durable for Assistant UI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Render native Pi Durable conversations through Assistant UI. Pi owns durable history, execution, submissions and configuration; Assistant UI owns thread navigation, drafts, initialization and directory pagination.
+
+## Build and consume
+
+From the repository root:
+
+```sh
+pnpm install --frozen-lockfile
+pnpm exec turbo run build --filter=@usecontextlayer/pi-durable-assistant-ui
+pnpm --dir packages/adapter pack
+```
+
+Install the resulting tarball into your application, together with React 19, `@assistant-ui/react` compatible with `^0.15.32`, and Pi Durable compatible with `^1.5.0`. Pi Durable is a peer because native branded identifiers cross the host boundary. The checkout pins its verification dependencies in pnpm-lock.yaml. The adapter builds as ESM with TypeScript declarations and does not depend on the demo's Node/SQLite host.
+
+```tsx
+import { AssistantRuntimeProvider } from "@assistant-ui/react";
+import {
+  createHttpPiDurableClient,
+  usePiDurableRuntime,
+} from "@usecontextlayer/pi-durable-assistant-ui";
+
+const client = createHttpPiDurableClient({ baseUrl: "/api" });
+
+export function PiChat({ children }: { children: React.ReactNode }) {
+  const runtime = usePiDurableRuntime({ client });
+  return <AssistantRuntimeProvider runtime={runtime}>{children}</AssistantRuntimeProvider>;
+}
+```
+
+Keep the client stable. `usePiDurableRuntime` returns the standard Assistant UI runtime, so thread selection and directory actions use Assistant UI's APIs and primitives. Pass a controlled native `threadId` and `onThreadIdChange` to connect navigation to a URL. New threads are framework drafts until their first send initializes a native conversation. Assistant UI's temporary local identifiers remain internal; the canonical remote ID is the string representation of the native Pi conversation ID. Forks select their own native conversation as another thread.
+
+The remote runtime retains visited thread runtimes until its lifecycle releases them. Each initialized thread owns a `PiDurableConversation`, its native `ConversationTranscript`, conversation observation and optional metadata observation. Closing an observation never cancels agent execution. Directory pages load on demand; the adapter reads metadata only for that page and does not rescan the entire directory after every answer.
+
+## Native state and actions
+
+Inside `AssistantRuntimeProvider`, `usePiDurable()` reads the current thread's `{ conversation, state }` extras. `conversation` is undefined for a draft; otherwise its ID and all its actions are bound to one native conversation. `state` contains the merged native view, metadata, transport connection/loading state and an error when one is reported. Native controls can use submission, continuation, steering, withdrawal, cancellation, configuration, forks, reset, compaction and earlier-history operations where the host supplies them.
+
+For direct non-React observation, construct `new PiDurableConversation(client, id, pageSize)`, subscribe with `subscribe`/`getSnapshot`, then call `start` and `stop`. It has no selection method or global directory. Edit and regeneration return a native fork and target both the context write and continuation explicitly at that fork; the React integration then asks Assistant UI to select it.
+
+## Host contract and observation
+
+Implement the structural `PiDurableClient` or use `createHttpPiDurableClient` with the demo protocol. Installing the adapter does not install server routes. Optional client methods describe host extensions; titles, feedback, suggestions, uploads and human input require the corresponding host implementation.
+
+`watch` returns Pi/Chord's standard asynchronous watch handle: current immutable `value`, `start`, `stop` and terminal `closed` outcome. HTTP carries an initial view, native Chord operations, recoverable source failures and terminal outcomes over one shared SSE connection per client. Logical subscriptions are tagged independently so retained thread runtimes do not exhaust browser HTTP connection limits. It reconstructs the same watch contract in the browser using Chord. Transport reconnection status remains separate from source termination. Native acquisition failures and terminal outcomes close the source rather than retrying indefinitely. Resume windows come from the thread's native transcript.
+
+`watchMetadata`, when supplied, observes the host's native metadata document. The demo uses a conversation document for title, feedback keyed by native entry ID and static suggestions, with checkpoints on updates. The native creation hook initializes the document for each conversation, including forks. Native conversation views do not include arbitrary custom documents. Metadata changes update mounted conversations live; an observed title change refreshes Assistant UI's directory through its reload API. Newly created conversations from another client appear on explicit directory refresh. The optional batch metadata operation accepts only the IDs in the requested directory page.
+
+`SerializedAgentChange` carries JSON tool, extension and model-tool names; the host resolves those names into registered native definitions. Omitted fields remain unchanged and null clears a field. Host-specific registry and execution-environment choices remain outside the adapter.
+
+## Message semantics
+
+The projection uses native entry IDs, joins tool results by native call ID and marks transient live messages optimistic so Assistant UI can evict them when committed entries arrive. Tool output is distinct from its UI-only artifact; native image output remains available as model content. The exported `PiDurableHumanInputDetails` artifact contract (native task ID, prompt, pending/answered status and answered response) becomes a text tool-approval request, and `onRespondToToolApproval` calls the host response operation for the native task. A response does not fabricate a browser-side tool result.
+
+Reset and compaction notices are named `pi-context` data parts. Consumers register their own data renderer; the demo supplies one. Native entry guards classify those notices. Committed-history projection is memoized separately from live execution so unchanged message objects survive streaming updates. The pure `projectConversation` export remains available for non-React consumers.
+
+## Queue and unsupported operations
+
+The standard composer can send during a run through a queue adapter backed by Pi's native inbox. Assistant UI's normal busy send steers; `aui.composer().send({ steer: false })` enqueues a follow-up. Queue items retain native submission IDs, and removing one withdraws that submission. Pi owns processing and cancellation behavior; the adapter does not drain a second queue.
+
+Pi Durable 1.5.0 has no native queue move/edit, permanent conversation deletion, archive or unarchive operation. Required delete, archive and queue move/edit methods reject explicitly; optional unarchive is omitted so Assistant UI reports that capability as unavailable. The demo exposes none of those controls. Archive is not simulated with a custom document. Withdrawal followed by another submission remains two distinct native operations with a new ID. Unsupported operations never report success.
+
+## Attachments, feedback and voice
+
+`createPiDurableAttachmentAdapter(client.uploadFile)` uses Assistant UI's attachment lifecycle and returns `CompleteAttachment`. The uploader supplies a name and native Pi input blocks; host storage paths, download URLs and content types remain host concerns. Removing a draft attachment does not delete an uploaded file from the host workspace.
+
+Pass Assistant UI's `speech`, `dictation`, `attachments` and optional `feedback` adapters directly to the runtime hook. Without a feedback override, the native host feedback extension is used when available. Browser speech and dictation use Assistant UI's official adapters and support checks; actual microphone capture and audible playback remain device-dependent and unverified in this project.

package/dist/attachments.d.ts

@@ -0,0 +1,5 @@
+import type { AttachmentAdapter } from "@assistant-ui/react";
+import type { PiDurableUploadResult } from "./client.js";
+/** Uploads at send time; the host decides which native Pi input represents the file. */
+export declare function createPiDurableAttachmentAdapter(upload: (file: File, signal?: AbortSignal) => Promise<PiDurableUploadResult>): AttachmentAdapter;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../src/attachments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,wFAAwF;AACxF,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,qBAAqB,CAAC,GAAG,iBAAiB,CAoBhJ"}

package/dist/attachments.js

@@ -0,0 +1,22 @@
+/** Uploads at send time; the host decides which native Pi input represents the file. */
+export function createPiDurableAttachmentAdapter(upload) {
+    return {
+        accept: "*",
+        async add({ file }) {
+            return { id: crypto.randomUUID(), type: file.type.startsWith("image/") ? "image" : "file", name: file.name, contentType: file.type, file, status: { type: "requires-action", reason: "composer-send" } };
+        },
+        async send(attachment, options) {
+            const uploadResult = await upload(attachment.file, options?.signal);
+            return {
+                ...attachment,
+                status: { type: "complete" },
+                content: uploadResult.content.map((part) => part.type === "text"
+                    ? { type: "text", text: part.text }
+                    : { type: "image", image: `data:${part.mimeType};base64,${part.data}`, filename: uploadResult.name }),
+            };
+        },
+        async remove() {
+            // Removing a draft attachment does not delete an ordinary file from the host's workspace.
+        },
+    };
+}

package/dist/client.d.ts

@@ -0,0 +1,88 @@
+import { type Op } from "@earendil-works/chord/delta";
+import { type WatchHandle, type WatchEnd } from "@earendil-works/chord";
+import type { ConversationCreateOptions, ConversationId, ConversationQuery, ConversationRecord, ConversationView, ConversationWindow, ConversationAbortOptions, ContextView, AgentState, CompactionResult, Cursor, EntryQuery, EntryRecord, EntryId, Page, SubmissionDraft, SubmissionId, SubmissionRecord, TaskId, UserInput, Harness, HarnessInspection } from "@earendil-works/pi-durable";
+import type { ConversationMetadata, ConversationMetadataPatch } from "./metadata.js";
+/** JSON form of Pi's stored configuration; the host resolves registry names. */
+export type SerializedAgentChange = {
+    [K in keyof AgentState]?: AgentState[K] | null;
+};
+export type SerializedConversationCreateOptions = Omit<ConversationCreateOptions, "agent" | "init"> & {
+    agent?: SerializedAgentChange;
+};
+export type HttpPiDurableWatchFrame<T = ConversationView> = {
+    type: "view";
+    view: T;
+} | {
+    type: "ops";
+    ops: readonly Op[];
+} | {
+    type: "failed";
+    error: string;
+} | {
+    type: "end";
+    kind: WatchEnd["kind"];
+    error?: string;
+};
+export type HttpPiDurableWatchSubscription = {
+    subscriptionId: number;
+    id: ConversationId;
+    kind: "conversation" | "metadata";
+    window?: ConversationWindow;
+};
+export type HttpPiDurableWatchEnvelope = {
+    subscriptionId: number;
+    frame: HttpPiDurableWatchFrame<unknown>;
+};
+export type PiDurableConnectionState = "idle" | "connecting" | "connected" | "reconnecting" | "closed";
+export interface PiDurableWatchOptions {
+    window?: () => ConversationWindow | undefined;
+    onConnection?: (state: PiDurableConnectionState) => void;
+    signal?: AbortSignal;
+}
+export type PiDurableHumanInputDetails = {
+    type: "human-input";
+    taskId: TaskId;
+    prompt: string;
+} & ({
+    status: "pending";
+} | {
+    status: "answered";
+    response: string;
+});
+export interface PiDurableUploadResult {
+    name: string;
+    content: Exclude<UserInput, string>;
+}
+/** The native operations a browser needs, with server execution context already bound. */
+export interface PiDurableClient {
+    listConversations(query?: ConversationQuery, limit?: number, cursor?: Cursor): Promise<Page<ConversationRecord, Cursor>>;
+    createConversation(options?: SerializedConversationCreateOptions): Promise<ConversationRecord>;
+    getConversationView(id: ConversationId): Promise<ConversationView>;
+    entries(id: ConversationId, query: Omit<EntryQuery, "conversationId">, limit: number, cursor?: Cursor, signal?: AbortSignal): Promise<Page<EntryRecord, Cursor>>;
+    submit(id: ConversationId, submission: SubmissionDraft): Promise<SubmissionRecord>;
+    getSubmission(id: SubmissionId): Promise<SubmissionRecord>;
+    watch(id: ConversationId, options?: PiDurableWatchOptions): Promise<WatchHandle<ConversationView>>;
+    watchMetadata?(id: ConversationId, signal?: AbortSignal): Promise<WatchHandle<ConversationMetadata>>;
+    configure?(id: ConversationId, change: SerializedAgentChange): Promise<void>;
+    abort?(id: ConversationId, options?: ConversationAbortOptions): Promise<void>;
+    abortSubmission?(id: SubmissionId): ReturnType<Harness["abortSubmission"]>;
+    reset?(id: ConversationId, handoff?: string): Promise<void>;
+    compact?(id: ConversationId, instructions?: string): Promise<TaskId<CompactionResult>>;
+    fork?(id: ConversationId, at: EntryId, options?: SerializedConversationCreateOptions): Promise<ConversationRecord>;
+    context?(id: ConversationId, at?: EntryId): Promise<ContextView>;
+    uploadFile?(file: File, signal?: AbortSignal): Promise<PiDurableUploadResult>;
+    respondToHumanInput?(taskId: TaskId, response: string): Promise<void>;
+    inspect?(): Promise<HarnessInspection>;
+    listMetadata?(ids: readonly ConversationId[]): Promise<Record<string, ConversationMetadata>>;
+    getMetadata?(id: ConversationId): Promise<ConversationMetadata>;
+    updateMetadata?(id: ConversationId, patch: ConversationMetadataPatch): Promise<ConversationMetadata>;
+    setFeedback?(id: ConversationId, entryId: EntryId, rating: "positive" | "negative" | null): Promise<ConversationMetadata>;
+}
+export interface HttpPiDurableClientOptions {
+    baseUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    eventSource?: (url: string) => EventSource;
+    reconnectDelayMs?: number;
+}
+export declare function createHttpPiDurableClient(options?: HttpPiDurableClientOptions): Required<PiDurableClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -0,0 +1,165 @@
+import { applyImmutable } from "@earendil-works/chord/delta";
+import { Watch } from "@earendil-works/chord";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+export function createHttpPiDurableClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? "/api").replace(/\/$/, "");
+    const fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+    const openEvents = options.eventSource ?? ((url) => new EventSource(url));
+    const subscriptions = new Map();
+    let nextSubscriptionId = 0;
+    let source;
+    let retry;
+    let connectQueued = false;
+    function scheduleConnect() {
+        clearTimeout(retry);
+        if (connectQueued)
+            return;
+        connectQueued = true;
+        queueMicrotask(() => { connectQueued = false; connect(); });
+    }
+    function connect() {
+        source?.close();
+        source = undefined;
+        if (subscriptions.size === 0)
+            return;
+        for (const subscription of subscriptions.values())
+            subscription.connection("connecting");
+        const connection = openEvents(url("/watch", { subscriptions: [...subscriptions.values()].map((subscription) => subscription.request()) }));
+        source = connection;
+        connection.onmessage = (event) => {
+            try {
+                const { subscriptionId, frame } = JSON.parse(event.data);
+                subscriptions.get(subscriptionId)?.receive(frame);
+            }
+            catch (error) {
+                connection.close();
+                for (const subscription of subscriptions.values())
+                    subscription.receive({ type: "end", kind: "failed", error: error instanceof Error ? error.message : String(error) });
+            }
+        };
+        connection.onerror = () => {
+            connection.close();
+            for (const subscription of subscriptions.values())
+                subscription.connection("reconnecting");
+            if (subscriptions.size > 0)
+                retry = setTimeout(connect, options.reconnectDelayMs ?? 500);
+        };
+    }
+    function url(path, query = {}) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined)
+                params.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+        }
+        const search = params.toString();
+        return `${baseUrl}${path}${search ? `?${search}` : ""}`;
+    }
+    async function request(path, init, query) {
+        const response = await fetcher(url(path, query), init);
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(body || `Pi request failed: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    function post(path, value) {
+        return request(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(value) });
+    }
+    return {
+        listConversations: (query = {}, limit = 100, cursor) => request("/conversations", undefined, { query, limit, cursor }),
+        createConversation: (creation = { ownership: { kind: "ownerless" } }) => post("/conversations", creation),
+        getConversationView: (id) => request(`/conversations/${id}`),
+        entries: (id, query, limit, cursor, signal) => request(`/conversations/${id}/entries`, { signal }, { ...query, limit, cursor }),
+        submit: (id, submission) => post(`/conversations/${id}/submit`, submission),
+        getSubmission: (id) => request(`/submissions/${id}`),
+        configure: async (id, change) => { await post(`/conversations/${id}/configure`, change); },
+        abort: async (id, abortOptions = {}) => { await post(`/conversations/${id}/abort`, abortOptions); },
+        abortSubmission: (id) => post(`/submissions/${id}/abort`, {}),
+        reset: async (id, handoff) => { await post(`/conversations/${id}/reset`, { handoff }); },
+        compact: async (id, instructions) => (await post(`/conversations/${id}/compact`, { instructions })).taskId,
+        fork: (id, at, forkOptions = { ownership: { kind: "ownerless" } }) => post(`/conversations/${id}/fork`, { at, ...forkOptions }),
+        context: (id, at) => request(`/conversations/${id}/context`, undefined, { at }),
+        uploadFile: (file, signal) => request("/files", { method: "POST", headers: { "content-type": file.type || "application/octet-stream" }, body: file, signal }, { name: file.name }),
+        respondToHumanInput: async (taskId, response) => { await post(`/human-input/${taskId}`, { response }); },
+        inspect: () => request("/inspect"),
+        listMetadata: (ids) => post("/conversations/metadata", { ids }),
+        getMetadata: (id) => request(`/conversations/${id}/metadata`),
+        updateMetadata: (id, patch) => request(`/conversations/${id}/metadata`, { method: "PATCH", headers: { "content-type": "application/json" }, body: JSON.stringify(patch) }),
+        setFeedback: (id, entryId, rating) => post(`/conversations/${id}/feedback`, { entryId, rating }),
+        watch: (id, watchOptions = {}) => openWatch(id, "conversation", watchOptions),
+        watchMetadata: (id, signal) => openWatch(id, "metadata", { signal }),
+    };
+    function openWatch(id, kind, watchOptions) {
+        return new Promise((resolve, reject) => {
+            const subscriptionId = ++nextSubscriptionId;
+            let observation;
+            let value;
+            function dispose() {
+                subscriptions.delete(subscriptionId);
+                watchOptions.signal?.removeEventListener("abort", abort);
+                scheduleConnect();
+            }
+            function abort() {
+                dispose();
+                if (observation)
+                    observation.abort();
+                else
+                    reject(watchOptions.signal?.reason ?? new DOMException("Observation aborted", "AbortError"));
+            }
+            subscriptions.set(subscriptionId, {
+                request: () => ({ subscriptionId, id, kind, window: watchOptions.window?.() }),
+                connection: (state) => watchOptions.onConnection?.(state === "connecting" && observation ? "reconnecting" : state),
+                receive(raw) {
+                    try {
+                        const frame = raw;
+                        if (frame.type === "end") {
+                            dispose();
+                            watchOptions.onConnection?.("closed");
+                            const error = new Error(frame.error ?? `Pi observation ended: ${frame.kind}`);
+                            if (!observation)
+                                reject(error);
+                            else
+                                observation.end(frame.kind === "failed" || frame.kind === "listener_error" ? { kind: frame.kind, error } : { kind: frame.kind });
+                            return;
+                        }
+                        if (frame.type === "failed") {
+                            if (!observation)
+                                throw new Error(frame.error);
+                            observation.fail(new Error(frame.error), BACKGROUND_CONTEXT);
+                            return;
+                        }
+                        if (frame.type === "view")
+                            value = frame.view;
+                        else {
+                            if (!observation)
+                                throw new Error("Pi watch sent changes before its initial view");
+                            value = applyImmutable(value, frame.ops);
+                        }
+                        if (!observation) {
+                            observation = new Watch(value, dispose, console.error);
+                            resolve(observation);
+                        }
+                        else {
+                            observation.advance({ kind: "value", value, ops: frame.type === "ops" ? frame.ops : [["r", value]], retired: false }, BACKGROUND_CONTEXT);
+                        }
+                        watchOptions.onConnection?.("connected");
+                    }
+                    catch (error) {
+                        dispose();
+                        watchOptions.onConnection?.("closed");
+                        if (observation)
+                            observation.end({ kind: "failed", error });
+                        else
+                            reject(error);
+                    }
+                },
+            });
+            if (watchOptions.signal?.aborted)
+                abort();
+            else {
+                watchOptions.signal?.addEventListener("abort", abort, { once: true });
+                scheduleConnect();
+            }
+        });
+    }
+}

package/dist/conversation.d.ts

@@ -0,0 +1,44 @@
+import { ConversationTranscript, type ConversationId, type EntryId, type SubmissionDraft, type TranscriptView } from "@earendil-works/pi-durable";
+import type { AppendMessage } from "@assistant-ui/react";
+import type { PiDurableClient, PiDurableConnectionState, SerializedAgentChange } from "./client.js";
+import { type ConversationMetadata } from "./metadata.js";
+export interface PiDurableConversationState {
+    readonly view: TranscriptView | undefined;
+    readonly metadata: ConversationMetadata;
+    readonly connection: PiDurableConnectionState;
+    readonly isLoading: boolean;
+    readonly error: Error | undefined;
+}
+/** Disposable observation and actions permanently bound to one native conversation. */
+export declare class PiDurableConversation {
+    #private;
+    readonly client: PiDurableClient;
+    readonly id: ConversationId;
+    readonly transcript: ConversationTranscript;
+    constructor(client: PiDurableClient, id: ConversationId, pageSize?: number);
+    getSnapshot: () => PiDurableConversationState;
+    subscribe: (listener: () => void) => (() => void);
+    reportError: (error: unknown) => void;
+    start: () => void;
+    stop: () => void;
+    reload: () => void;
+    submit: (draft: SubmissionDraft) => Promise<import("@earendil-works/pi-durable").SubmissionRecord>;
+    continue: () => Promise<import("@earendil-works/pi-durable").SubmissionRecord>;
+    steer: (content: Extract<SubmissionDraft, {
+        type: "input";
+    }>["content"]) => Promise<import("@earendil-works/pi-durable").SubmissionRecord>;
+    followUp: (content: Extract<SubmissionDraft, {
+        type: "input";
+    }>["content"]) => Promise<import("@earendil-works/pi-durable").SubmissionRecord>;
+    cancel: () => Promise<void>;
+    abortSubmission: (id: Parameters<NonNullable<PiDurableClient["abortSubmission"]>>[0]) => Promise<"aborted" | "already_placed" | "not_found" | "settled">;
+    configure: (change: SerializedAgentChange) => Promise<void>;
+    reset: (handoff?: string) => Promise<void>;
+    compact: (instructions?: string) => Promise<import("@earendil-works/pi-durable").TaskId<import("@earendil-works/pi-durable").CompactionResult>>;
+    forkAt: (at: EntryId) => Promise<import("@earendil-works/pi-durable").ConversationRecord>;
+    edit: (message: AppendMessage) => Promise<import("@earendil-works/pi-durable").ConversationRecord>;
+    regenerate: (parentId: string | null) => Promise<import("@earendil-works/pi-durable").ConversationRecord>;
+    loadEarlier: () => Promise<void>;
+    setFeedback: (messageId: string, rating: "positive" | "negative") => Promise<void>;
+}
+//# sourceMappingURL=conversation.d.ts.map

package/dist/conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../src/conversation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,KAAK,cAAc,EAAyB,KAAK,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACzK,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpG,OAAO,EAA+B,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAGvF,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,wBAAwB,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;CACnC;AAED,uFAAuF;AACvF,qBAAa,qBAAqB;;IAMpB,QAAQ,CAAC,MAAM,EAAE,eAAe;IAAE,QAAQ,CAAC,EAAE,EAAE,cAAc;IALzE,QAAQ,CAAC,UAAU,EAAE,sBAAsB,CAAC;IAK5C,YAAqB,MAAM,EAAE,eAAe,EAAW,EAAE,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,MAAM,EAE3F;IAED,WAAW,QAAO,0BAA0B,CAAgB;IAC5D,SAAS,aAAc,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAG9C;IAOF,WAAW,UAAW,OAAO,UAE3B;IAEF,KAAK,QAAO,IAAI,CAkCd;IAOF,IAAI,QAAO,IAAI,CAGb;IAEF,MAAM,QAAO,IAAI,CAAmC;IACpD,MAAM,UAAW,eAAe,oEAAwC;IACxE,QAAQ,uEAA2C;IACnD,KAAK,YAAa,OAAO,CAAC,eAAe,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC,SAAS,CAAC,oEAAgE;IACxI,QAAQ,YAAa,OAAO,CAAC,eAAe,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC,SAAS,CAAC,oEAAmE;IAE9I,MAAM,sBAGJ;IACF,eAAe,OAAQ,UAAU,CAAC,WAAW,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,qEAGnF;IACF,SAAS,WAAY,qBAAqB,mBAGxC;IACF,KAAK,aAAc,MAAM,mBAGvB;IACF,OAAO,kBAAmB,MAAM,iHAG9B;IACF,MAAM,OAAQ,OAAO,sEAGnB;IAEF,IAAI,YAAmB,aAAa,sEAOlC;IAEF,UAAU,aAAoB,MAAM,GAAG,IAAI,sEAUzC;IAEF,WAAW,sBAGT;IAEF,WAAW,cAAqB,MAAM,UAAU,UAAU,GAAG,UAAU,mBAGrE;CACH"}

package/dist/conversation.js

@@ -0,0 +1,149 @@
+import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
+import { ConversationTranscript } from "@earendil-works/pi-durable";
+import { EMPTY_CONVERSATION_METADATA } from "./metadata.js";
+import { entryIdFromMessageId, projectConversation, toPiUserInput } from "./projection.js";
+/** Disposable observation and actions permanently bound to one native conversation. */
+export class PiDurableConversation {
+    client;
+    id;
+    transcript;
+    #listeners = new Set();
+    #controller;
+    #state = { view: undefined, metadata: EMPTY_CONVERSATION_METADATA, connection: "idle", isLoading: true, error: undefined };
+    constructor(client, id, pageSize) {
+        this.client = client;
+        this.id = id;
+        this.transcript = new ConversationTranscript((query, limit, context) => client.entries(id, query, limit, undefined, context.abortSignal), { pageSize });
+    }
+    getSnapshot = () => this.#state;
+    subscribe = (listener) => {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    };
+    #set(patch) {
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener();
+    }
+    reportError = (error) => {
+        this.#set({ error: error instanceof Error ? error : new Error(String(error)), isLoading: false });
+    };
+    start = () => {
+        if (this.#controller)
+            return;
+        const controller = new AbortController();
+        this.#controller = controller;
+        this.#set({ isLoading: !this.#state.view, error: undefined });
+        const observe = async (acquire, accept) => {
+            const watch = await acquire();
+            await accept(watch.value);
+            watch.start(async (change) => {
+                if (change.kind === "value")
+                    await accept(change.value);
+                else
+                    this.reportError(change.error);
+            });
+            const end = await watch.closed;
+            if (!controller.signal.aborted)
+                this.#ended(end);
+        };
+        void observe(() => this.client.watch(this.id, {
+            signal: controller.signal,
+            window: () => this.transcript.resume,
+            onConnection: (connection) => { if (!controller.signal.aborted)
+                this.#set({ connection }); },
+        }), async (view) => {
+            if (controller.signal.aborted)
+                return;
+            this.#set({ view: this.transcript.merge(view), isLoading: false, error: undefined });
+            const context = withAbortSignal(controller.signal, BACKGROUND_CONTEXT);
+            let gap = this.#state.view?.items.find((item) => item.kind === "gap");
+            while (gap?.kind === "gap" && !controller.signal.aborted) {
+                this.#set({ view: await this.transcript.fillGap(gap, context) });
+                gap = this.#state.view?.items.find((item) => item.kind === "gap");
+            }
+        }).catch((error) => { if (!controller.signal.aborted)
+            this.reportError(error); });
+        if (this.client.watchMetadata) {
+            void observe(() => this.client.watchMetadata(this.id, controller.signal), (metadata) => {
+                if (!controller.signal.aborted)
+                    this.#set({ metadata });
+            }).catch((error) => { if (!controller.signal.aborted)
+                this.reportError(error); });
+        }
+    };
+    #ended(end) {
+        this.#set({ connection: "closed", isLoading: false });
+        if ("error" in end)
+            this.reportError(end.error);
+    }
+    stop = () => {
+        this.#controller?.abort();
+        this.#controller = undefined;
+    };
+    reload = () => { this.stop(); this.start(); };
+    submit = (draft) => this.client.submit(this.id, draft);
+    continue = () => this.submit({ type: "continue" });
+    steer = (content) => this.submit({ type: "input", content, whenBusy: "steer" });
+    followUp = (content) => this.submit({ type: "input", content, whenBusy: "followUp" });
+    cancel = () => {
+        if (!this.client.abort)
+            throw new Error("This Pi host does not expose cancellation");
+        return this.client.abort(this.id);
+    };
+    abortSubmission = (id) => {
+        if (!this.client.abortSubmission)
+            throw new Error("This Pi host does not expose submission withdrawal");
+        return this.client.abortSubmission(id);
+    };
+    configure = (change) => {
+        if (!this.client.configure)
+            throw new Error("This Pi host does not expose configuration");
+        return this.client.configure(this.id, change);
+    };
+    reset = (handoff) => {
+        if (!this.client.reset)
+            throw new Error("This Pi host does not expose reset");
+        return this.client.reset(this.id, handoff);
+    };
+    compact = (instructions) => {
+        if (!this.client.compact)
+            throw new Error("This Pi host does not expose compaction");
+        return this.client.compact(this.id, instructions);
+    };
+    forkAt = (at) => {
+        if (!this.client.fork)
+            throw new Error("This Pi host does not expose forks");
+        return this.client.fork(this.id, at);
+    };
+    edit = async (message) => {
+        if (!message.sourceId)
+            throw new Error("An edit must identify its original message");
+        const target = entryIdFromMessageId(message.sourceId);
+        const fork = await this.forkAt(target);
+        await this.client.submit(fork.id, { type: "write", entry: { kind: "assistant-ui.context-edit", edits: [{ target, action: "replace", messages: [{ role: "user", content: toPiUserInput(message), timestamp: Date.now() }] }] } });
+        await this.client.submit(fork.id, { type: "continue" });
+        return fork;
+    };
+    regenerate = async (parentId) => {
+        const messages = this.#state.view ? projectConversation(this.#state.view, this.#state.metadata) : [];
+        const index = parentId === null ? -1 : messages.findIndex((message) => message.id === parentId);
+        const answer = messages[index + 1];
+        if (!answer?.id || answer.role !== "assistant")
+            throw new Error("No committed assistant response follows this message");
+        const target = entryIdFromMessageId(answer.id);
+        const fork = await this.forkAt(target);
+        await this.client.submit(fork.id, { type: "write", entry: { kind: "assistant-ui.context-edit", edits: [{ target, action: "omit" }] } });
+        await this.client.submit(fork.id, { type: "continue" });
+        return fork;
+    };
+    loadEarlier = async () => {
+        const context = this.#controller ? withAbortSignal(this.#controller.signal, BACKGROUND_CONTEXT) : BACKGROUND_CONTEXT;
+        this.#set({ view: await this.transcript.loadEarlier(context) });
+    };
+    setFeedback = async (messageId, rating) => {
+        if (!this.client.setFeedback)
+            throw new Error("This Pi host does not expose feedback");
+        this.#set({ metadata: await this.client.setFeedback(this.id, entryIdFromMessageId(messageId), rating) });
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createHttpPiDurableClient } from "./client.js";
+export type { PiDurableClient, HttpPiDurableWatchFrame, HttpPiDurableWatchEnvelope, HttpPiDurableWatchSubscription, PiDurableWatchOptions, PiDurableConnectionState, PiDurableUploadResult, PiDurableHumanInputDetails, HttpPiDurableClientOptions, SerializedAgentChange, SerializedConversationCreateOptions } from "./client.js";
+export { createPiDurableAttachmentAdapter } from "./attachments.js";
+export type { ConversationMetadata, ConversationMetadataPatch } from "./metadata.js";
+export { conversationInbox, conversationLiveState, entryIdFromMessageId, isForegroundRunning, projectConversation, toPiUserInput } from "./projection.js";
+export { PiDurableConversation } from "./conversation.js";
+export type { PiDurableConversationState } from "./conversation.js";
+export { createPiDurableThreadListAdapter } from "./thread-list.js";
+export { usePiDurableRuntime, usePiDurable } from "./use-pi-durable-runtime.js";
+export type { UsePiDurableRuntimeOptions, PiDurableRuntimeExtras } from "./use-pi-durable-runtime.js";
+export type { ConversationId, ConversationRecord, ConversationView, TranscriptView, SubmissionDraft, SubmissionId, SubmissionRecord, EntryId, AgentChange, AgentState, InboxState, HarnessInspection } from "@earendil-works/pi-durable";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,mCAAmC,EAAE,MAAM,aAAa,CAAC;AACpU,OAAO,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1J,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,YAAY,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChF,YAAY,EAAE,0BAA0B,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACtG,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { createHttpPiDurableClient } from "./client.js";
+export { createPiDurableAttachmentAdapter } from "./attachments.js";
+export { conversationInbox, conversationLiveState, entryIdFromMessageId, isForegroundRunning, projectConversation, toPiUserInput } from "./projection.js";
+export { PiDurableConversation } from "./conversation.js";
+export { createPiDurableThreadListAdapter } from "./thread-list.js";
+export { usePiDurableRuntime, usePiDurable } from "./use-pi-durable-runtime.js";

package/dist/metadata.d.ts

@@ -0,0 +1,10 @@
+import type { EntryId } from "@earendil-works/pi-durable";
+/** Presentation data persisted by the host in a native conversation document. */
+export type ConversationMetadata = {
+    title: string | null;
+    feedback: Record<EntryId, "positive" | "negative">;
+    suggestions: string[];
+};
+export type ConversationMetadataPatch = Partial<Pick<ConversationMetadata, "title" | "suggestions">>;
+export declare const EMPTY_CONVERSATION_METADATA: ConversationMetadata;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAE1D,iFAAiF;AACjF,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC,CAAC;IACnD,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC;AAErG,eAAO,MAAM,2BAA2B,EAAE,oBAIzC,CAAC"}

package/dist/metadata.js

@@ -0,0 +1,5 @@
+export const EMPTY_CONVERSATION_METADATA = {
+    title: null,
+    feedback: {},
+    suggestions: [],
+};

package/dist/projection.d.ts

@@ -0,0 +1,27 @@
+import type { AppendMessage, ThreadMessageLike } from "@assistant-ui/react";
+import type { EntryId, InboxState, LiveState, TranscriptView, UserInput } from "@earendil-works/pi-durable";
+import type { ConversationMetadata } from "./metadata.js";
+type ContentPart = Exclude<ThreadMessageLike["content"], string>[number];
+type ToolPart = Extract<ContentPart, {
+    type: "tool-call";
+}>;
+type MutableMessage = Omit<ThreadMessageLike, "content" | "status"> & {
+    content: ContentPart[];
+    status?: ThreadMessageLike["status"];
+};
+export declare function conversationLiveState(view: Pick<TranscriptView, "docs">): LiveState;
+export declare function conversationInbox(view: Pick<TranscriptView, "docs">): InboxState;
+export declare function entryIdFromMessageId(id: string): EntryId;
+/** Foreground generation is distinct from a run's after-run/background work. */
+export declare function isForegroundRunning(view: Pick<TranscriptView, "docs">): boolean;
+export declare function projectConversationHistory(items: TranscriptView["items"], conversationMetadata?: ConversationMetadata): {
+    messages: MutableMessage[];
+    calls: Map<string, ToolPart>;
+};
+export declare function projectConversationLive(history: ReturnType<typeof projectConversationHistory>, live: LiveState, conversationId: TranscriptView["conversation"]["id"]): readonly ThreadMessageLike[];
+/** Pure projection of Pi history and current execution; Pi retains the durable originals. */
+export declare function projectConversation(view: TranscriptView, metadata?: ConversationMetadata): readonly ThreadMessageLike[];
+/** Convert only the user's new input; never send the rendered transcript back to Pi. */
+export declare function toPiUserInput(message: AppendMessage): UserInput;
+export {};
+//# sourceMappingURL=projection.d.ts.map

package/dist/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG5E,OAAO,KAAK,EAAe,OAAO,EAAe,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACtI,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,KAAK,WAAW,GAAG,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AACzE,KAAK,QAAQ,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAC;AAC5D,KAAK,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,SAAS,GAAG,QAAQ,CAAC,GAAG;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC;AAEvI,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,SAAS,CAEnF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,UAAU,CAEhF;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAIxD;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,OAAO,CAG/E;AAuCD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC,EAAE,oBAAoB;;;EA+CrH;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,SAAS,iBAAiB,EAAE,CAmCnM;AAED,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,oBAAoB,GAAG,SAAS,iBAAiB,EAAE,CAEvH;AASD,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAY/D"}

package/dist/projection.js

@@ -0,0 +1,174 @@
+import { CompactionEntry, ResetEntry, SystemEntry } from "@earendil-works/pi-durable";
+export function conversationLiveState(view) {
+    return (view.docs["pi.live"] ?? {});
+}
+export function conversationInbox(view) {
+    return (view.docs["pi.inbox"] ?? { items: [] });
+}
+export function entryIdFromMessageId(id) {
+    const match = /^entry:(\d+):(?:\d+|notice)$/.exec(id);
+    if (!match || !Number.isSafeInteger(Number(match[1])))
+        throw new Error(`Message ${id} is not a committed Pi entry`);
+    return Number(match[1]);
+}
+/** Foreground generation is distinct from a run's after-run/background work. */
+export function isForegroundRunning(view) {
+    const live = conversationLiveState(view);
+    return live.run !== undefined && live.run.afterRun === undefined;
+}
+function userContent(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return content.map((part) => part.type === "text"
+        ? { type: "text", text: part.text }
+        : { type: "image", image: `data:${part.mimeType};base64,${part.data}` });
+}
+function assistantContent(message, calls) {
+    return message.content.map((part) => {
+        if (part.type === "text")
+            return { type: "text", text: part.text };
+        if (part.type === "thinking")
+            return { type: "reasoning", text: part.thinking };
+        const tool = { type: "tool-call", toolCallId: part.id, toolName: part.name, args: part.arguments };
+        calls.set(part.id, tool);
+        return tool;
+    });
+}
+function applyToolResult(tool, message) {
+    Object.assign(tool, {
+        artifact: message.details,
+        result: message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n"),
+        isError: message.isError,
+        isPreliminary: false,
+        approval: humanInputApproval(message.details),
+        modelContent: message.content.map((part) => part.type === "text"
+            ? { type: "text", text: part.text }
+            : { type: "file", mediaType: part.mimeType, data: part.data }),
+    });
+}
+function messageStatus(message) {
+    if (message.stopReason === "error")
+        return { type: "incomplete", reason: "error", error: message.errorMessage ?? "Model request failed" };
+    if (message.stopReason === "aborted")
+        return { type: "incomplete", reason: "cancelled" };
+    if (message.stopReason === "length")
+        return { type: "incomplete", reason: "length" };
+    return { type: "complete", reason: "stop" };
+}
+export function projectConversationHistory(items, conversationMetadata) {
+    const messages = [];
+    const calls = new Map();
+    const edits = new Map();
+    for (const item of items) {
+        if (item.kind === "entry") {
+            for (const change of item.entry.edits ?? [])
+                edits.set(change.target, { change, by: item.entry.id });
+        }
+    }
+    function append(entry, message, index) {
+        const metadata = { custom: { conversationId: entry.conversationId, entryId: entry.id, entryKind: entry.kind, editEntryId: edits.get(entry.id)?.by } };
+        const id = `entry:${entry.id}:${index}`;
+        if (message.role === "user") {
+            messages.push({ id, role: "user", content: userContent(message.content), createdAt: new Date(message.timestamp), metadata });
+        }
+        else if (message.role === "assistant") {
+            const feedback = conversationMetadata?.feedback[entry.id];
+            messages.push({ id, role: "assistant", content: assistantContent(message, calls), status: messageStatus(message), createdAt: new Date(message.timestamp), metadata: { ...metadata, ...(feedback ? { submittedFeedback: { type: feedback } } : {}) } });
+        }
+        else if (message.role === "toolResult") {
+            let tool = calls.get(message.toolCallId);
+            if (!tool) {
+                tool = { type: "tool-call", toolCallId: message.toolCallId, toolName: message.toolName, args: {} };
+                calls.set(message.toolCallId, tool);
+                messages.push({ id, role: "assistant", content: [tool], metadata });
+            }
+            applyToolResult(tool, message);
+        }
+    }
+    for (const item of items) {
+        if (item.kind !== "entry")
+            continue;
+        const entry = item.entry;
+        if (SystemEntry.is(entry))
+            continue;
+        if (CompactionEntry.is(entry) || ResetEntry.is(entry)) {
+            messages.push({
+                id: `entry:${entry.id}:notice`,
+                role: "assistant",
+                content: [{ type: "data", name: "pi-context", data: { kind: entry.kind, data: entry.data } }],
+                metadata: { custom: { conversationId: entry.conversationId, entryId: entry.id, entryKind: entry.kind, entryData: entry.data } },
+            });
+        }
+        const edit = edits.get(entry.id)?.change;
+        const model = edit ? (edit.action === "replace" ? edit.messages : []) : (entry.model ?? []);
+        for (const [index, message] of model.entries())
+            append(entry, message, index);
+    }
+    return { messages, calls };
+}
+export function projectConversationLive(history, live, conversationId) {
+    const messages = [...history.messages];
+    const calls = new Map(history.calls);
+    if (live.generation?.message) {
+        const message = live.generation.message;
+        messages.push({
+            id: `generation:${live.run?.taskId ?? conversationId}`,
+            role: "assistant",
+            content: assistantContent(message, calls),
+            status: { type: "running" },
+            createdAt: new Date(message.timestamp),
+            metadata: { isOptimistic: true, custom: { conversationId, taskId: live.run?.taskId } },
+        });
+    }
+    for (const slot of live.tools ?? []) {
+        let tool = calls.get(slot.callId);
+        if (!tool) {
+            tool = { type: "tool-call", toolCallId: slot.callId, toolName: slot.name, args: {} };
+            calls.set(slot.callId, tool);
+            messages.push({ id: `tool:${slot.callId}`, role: "assistant", content: [tool], status: { type: "running" }, metadata: { isOptimistic: true } });
+        }
+        if (slot.status !== "done") {
+            const ownerIndex = messages.findIndex((message) => message.content.includes(tool));
+            const owner = messages[ownerIndex];
+            const updated = { ...tool, result: slot.output, artifact: slot.details, isPreliminary: true, approval: humanInputApproval(slot.details) };
+            calls.set(slot.callId, updated);
+            messages[ownerIndex] = { ...owner, content: owner.content.map((part) => part === tool ? updated : part), status: { type: "running" } };
+        }
+    }
+    const failure = live.runFailure;
+    const lastStatus = messages.at(-1)?.status;
+    if (failure && failure.reason !== "aborted" && failure.reason !== "reset" && failure.reason !== "nothing_to_answer" && !(lastStatus?.type === "incomplete" && lastStatus.reason === "error")) {
+        messages.push({ id: `failure:${failure.taskId}`, role: "assistant", content: [], status: { type: "incomplete", reason: "error", error: failure.detail ?? failure.reason }, metadata: { isOptimistic: true, custom: { conversationId, taskId: failure.taskId } } });
+    }
+    return messages;
+}
+/** Pure projection of Pi history and current execution; Pi retains the durable originals. */
+export function projectConversation(view, metadata) {
+    return projectConversationLive(projectConversationHistory(view.items, metadata), conversationLiveState(view), view.conversation.id);
+}
+function humanInputApproval(value) {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const details = value;
+    if (details.type !== "human-input" || typeof details.taskId !== "number" || typeof details.prompt !== "string" || (details.status !== "pending" && details.status !== "answered"))
+        return undefined;
+    return { id: String(details.taskId), prompt: details.prompt, display: "text", ...(details.status === "answered" ? { approved: true, text: details.response } : {}) };
+}
+/** Convert only the user's new input; never send the rendered transcript back to Pi. */
+export function toPiUserInput(message) {
+    const content = [];
+    const parts = [...message.content, ...(message.attachments ?? []).flatMap((attachment) => attachment.content)];
+    for (const part of parts) {
+        if (part.type === "text")
+            content.push({ type: "text", text: part.text });
+        else if (part.type === "image") {
+            const match = /^data:([^;,]+);base64,(.*)$/s.exec(part.image);
+            if (!match)
+                throw new Error("Image input must be a base64 data URL");
+            content.push({ type: "image", mimeType: match[1], data: match[2] });
+        }
+        else
+            throw new Error(`Unsupported Pi input part: ${part.type}`);
+    }
+    return content;
+}

package/dist/thread-list.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteThreadListAdapter } from "@assistant-ui/react";
+import type { ConversationId } from "@earendil-works/pi-durable";
+import type { PiDurableClient } from "./client.js";
+export declare function nativeConversationId(value: string): ConversationId;
+export declare function createPiDurableThreadListAdapter(client: PiDurableClient, pageSize?: number): RemoteThreadListAdapter;
+//# sourceMappingURL=thread-list.d.ts.map

package/dist/thread-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-list.d.ts","sourceRoot":"","sources":["../src/thread-list.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAU,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKnD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAIlE;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,eAAe,EAAE,QAAQ,SAAK,GAAG,uBAAuB,CA8BhH"}

package/dist/thread-list.js

@@ -0,0 +1,39 @@
+export function nativeConversationId(value) {
+    const id = Number(value);
+    if (!Number.isSafeInteger(id) || id <= 0)
+        throw new Error(`Invalid Pi conversation ID: ${value}`);
+    return id;
+}
+export function createPiDurableThreadListAdapter(client, pageSize = 50) {
+    const metadata = (id, details) => ({
+        remoteId: String(id), status: "regular", title: details?.title ?? `Conversation ${id}`,
+    });
+    return {
+        async list({ after } = {}) {
+            const page = await client.listConversations({}, pageSize, after ? JSON.parse(after) : undefined);
+            const details = client.listMetadata ? await client.listMetadata(page.items.map((item) => item.id)) : undefined;
+            const threads = await Promise.all(page.items.map(async ({ id }) => metadata(id, details?.[String(id)] ?? await client.getMetadata?.(id))));
+            return { threads, ...(page.next ? { nextCursor: JSON.stringify(page.next) } : {}) };
+        },
+        async initialize() {
+            return { remoteId: String((await client.createConversation()).id) };
+        },
+        async fetch(remoteId) {
+            const id = nativeConversationId(remoteId);
+            if (client.getMetadata)
+                return metadata(id, await client.getMetadata(id));
+            await client.getConversationView(id);
+            return metadata(id);
+        },
+        async rename(remoteId, title) {
+            if (!client.updateMetadata)
+                throw new Error("This Pi host does not expose conversation titles");
+            await client.updateMetadata(nativeConversationId(remoteId), { title });
+        },
+        async archive() { throw new Error("Pi Durable does not support archiving conversations."); },
+        async delete() { throw new Error("Pi Durable does not support deleting conversations."); },
+        async generateTitle() {
+            return new ReadableStream({ start(controller) { controller.close(); } });
+        },
+    };
+}

package/dist/use-pi-durable-runtime.d.ts

@@ -0,0 +1,22 @@
+import { type AssistantRuntime, type AttachmentAdapter, type DictationAdapter, type FeedbackAdapter, type SpeechSynthesisAdapter } from "@assistant-ui/react";
+import type { ConversationId } from "@earendil-works/pi-durable";
+import type { PiDurableClient } from "./client.js";
+import { PiDurableConversation, type PiDurableConversationState } from "./conversation.js";
+export interface UsePiDurableRuntimeOptions {
+    client: PiDurableClient;
+    threadId?: ConversationId;
+    onThreadIdChange?: (id: ConversationId | undefined) => void;
+    pageSize?: number;
+    attachments?: AttachmentAdapter;
+    speech?: SpeechSynthesisAdapter;
+    dictation?: DictationAdapter;
+    feedback?: FeedbackAdapter;
+}
+export interface PiDurableRuntimeExtras {
+    readonly conversation: PiDurableConversation | undefined;
+    readonly state: PiDurableConversationState;
+}
+/** Read Pi-specific state/actions from the current Assistant UI thread scope. */
+export declare function usePiDurable(): PiDurableRuntimeExtras;
+export declare function usePiDurableRuntime(options: UsePiDurableRuntimeOptions): AssistantRuntime;
+//# sourceMappingURL=use-pi-durable-runtime.d.ts.map

package/dist/use-pi-durable-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pi-durable-runtime.d.ts","sourceRoot":"","sources":["../src/use-pi-durable-runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAgG,KAAK,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAmC,KAAK,eAAe,EAAuB,KAAK,sBAAsB,EAA0B,MAAM,qBAAqB,CAAC;AAC1U,OAAO,KAAK,EAAE,cAAc,EAAU,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,KAAK,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAK3F,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,eAAe,CAAC;IACxB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,cAAc,GAAG,SAAS,KAAK,IAAI,CAAC;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,YAAY,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;CAC5C;AASD,iFAAiF;AACjF,wBAAgB,YAAY,IAAI,sBAAsB,CAErD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,gBAAgB,CASzF"}

package/dist/use-pi-durable-runtime.js

@@ -0,0 +1,95 @@
+import { useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import { useAui, useAuiState, useExternalStoreRuntime, useRemoteThreadListRuntime } from "@assistant-ui/react";
+import { PiDurableConversation } from "./conversation.js";
+import { EMPTY_CONVERSATION_METADATA } from "./metadata.js";
+import { conversationInbox, conversationLiveState, isForegroundRunning, projectConversationHistory, projectConversationLive, toPiUserInput } from "./projection.js";
+import { createPiDurableThreadListAdapter, nativeConversationId } from "./thread-list.js";
+const DRAFT_STATE = { view: undefined, metadata: EMPTY_CONVERSATION_METADATA, connection: "idle", isLoading: false, error: undefined };
+const EMPTY_SUBSCRIPTION = () => () => { };
+const DRAFT_SNAPSHOT = () => DRAFT_STATE;
+const DRAFT_EXTRAS = { conversation: undefined, state: DRAFT_STATE };
+const identity = (message) => message;
+const EMPTY_HISTORY = projectConversationHistory([]);
+/** Read Pi-specific state/actions from the current Assistant UI thread scope. */
+export function usePiDurable() {
+    return useAuiState((state) => state.thread.extras ?? DRAFT_EXTRAS);
+}
+export function usePiDurableRuntime(options) {
+    const { client, pageSize, threadId, onThreadIdChange } = options;
+    const adapter = useMemo(() => createPiDurableThreadListAdapter(client, pageSize), [client, pageSize]);
+    return useRemoteThreadListRuntime({
+        adapter,
+        threadId: threadId === undefined ? undefined : String(threadId),
+        onThreadIdChange: (id) => onThreadIdChange?.(id === undefined ? undefined : nativeConversationId(id)),
+        runtimeHook: () => usePiDurableThreadRuntime(options),
+    });
+}
+function usePiDurableThreadRuntime({ client, pageSize, attachments, speech, dictation, feedback }) {
+    const aui = useAui();
+    const remoteId = useAuiState((state) => state.threadListItem.remoteId);
+    const conversation = useMemo(() => remoteId === undefined ? undefined : new PiDurableConversation(client, nativeConversationId(remoteId), pageSize), [client, remoteId, pageSize]);
+    const state = useSyncExternalStore(conversation?.subscribe ?? EMPTY_SUBSCRIPTION, conversation?.getSnapshot ?? DRAFT_SNAPSHOT, conversation?.getSnapshot ?? DRAFT_SNAPSHOT);
+    const [sendError, setSendError] = useState();
+    useEffect(() => { conversation?.start(); return () => conversation?.stop(); }, [conversation]);
+    const history = useMemo(() => state.view ? projectConversationHistory(state.view.items, state.metadata) : EMPTY_HISTORY, [state.view?.items, state.metadata.feedback]);
+    const live = state.view ? conversationLiveState(state.view) : undefined;
+    const messages = useMemo(() => state.view && live ? projectConversationLive(history, live, state.view.conversation.id) : [], [history, live, state.view?.conversation.id]);
+    const isRunning = state.view ? isForegroundRunning(state.view) : false;
+    useEffect(() => {
+        if (!remoteId || state.metadata.title === null)
+            return;
+        if (aui.threadListItem().getState().title !== state.metadata.title) {
+            void aui.threads().reload().catch((error) => setSendError(error instanceof Error ? error : new Error(String(error))));
+        }
+    }, [aui, remoteId, state.metadata.title]);
+    const send = async (message, whenBusy) => {
+        setSendError(undefined);
+        const { remoteId: id } = await aui.threadListItem().initialize();
+        await client.submit(nativeConversationId(id), { type: "input", content: toPiUserInput(message), whenBusy });
+    };
+    const reportSendError = (error) => setSendError(error instanceof Error ? error : new Error(String(error)));
+    const queue = useMemo(() => {
+        if (!client.abortSubmission)
+            return undefined;
+        const items = state.view ? conversationInbox(state.view).items : [];
+        const convert = (mode) => items.flatMap((item) => {
+            if (item.mode !== mode || !("content" in item))
+                return [];
+            const content = typeof item.content === "string" ? [{ type: "text", text: item.content }] : item.content;
+            const parts = content.map((part) => part.type === "text" ? part : { type: "file", mimeType: part.mimeType, data: part.data });
+            return [{ id: String(item.id), prompt: content.filter((part) => part.type === "text").map((part) => part.text).join("\n"), parts }];
+        });
+        return {
+            items: convert("followUp"), steerItems: convert("steer"),
+            enqueue: (message) => { void send(message, "followUp").catch(reportSendError); },
+            steer: (message) => { void send(message, "steer").catch(reportSendError); },
+            remove: (id) => { void client.abortSubmission(Number(id)).catch(reportSendError); },
+            move: () => { throw new Error("Pi Durable does not support moving queued submissions."); },
+            edit: () => { throw new Error("Pi Durable does not support editing queued submissions."); },
+        };
+    }, [client, remoteId, state.view?.docs["pi.inbox"]]);
+    const nativeFeedback = useMemo(() => conversation && client.setFeedback ? { submit: ({ message, type }) => conversation.setFeedback(message.id, type) } : undefined, [conversation, client]);
+    const extras = useMemo(() => ({ conversation, state: sendError ? { ...state, error: sendError } : state }), [conversation, state, sendError]);
+    return useExternalStoreRuntime({
+        messages,
+        convertMessage: identity,
+        isRunning,
+        isLoading: state.isLoading,
+        hasEarlier: state.view?.items[0]?.kind === "earlier",
+        onLoadEarlier: conversation?.loadEarlier,
+        onRefetchThread: conversation ? async () => { conversation.reload(); } : undefined,
+        onNew: send,
+        onCancel: conversation && client.abort ? conversation.cancel : undefined,
+        onEdit: conversation && client.fork ? async (message) => { const fork = await conversation.edit(message); await aui.threads().switchToThread(String(fork.id)); } : undefined,
+        onReload: conversation && client.fork ? async (parentId) => { const fork = await conversation.regenerate(parentId); await aui.threads().switchToThread(String(fork.id)); } : undefined,
+        onRespondToToolApproval: client.respondToHumanInput ? async ({ approvalId, text }) => {
+            if (text === undefined)
+                throw new Error("This human-input request requires a text response");
+            await client.respondToHumanInput(Number(approvalId), text);
+        } : undefined,
+        suggestions: state.metadata.suggestions.map((prompt) => ({ prompt })),
+        queue,
+        extras,
+        adapters: { attachments, speech, dictation, feedback: feedback ?? nativeFeedback },
+    });
+}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@usecontextlayer/pi-durable-assistant-ui",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "license": "MIT",
+  "description": "Assistant UI runtime adapter for Pi Durable conversations",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/usecontextlayer/pi-durable-assistant-ui.git",
+    "directory": "packages/adapter"
+  },
+  "homepage": "https://github.com/usecontextlayer/pi-durable-assistant-ui#readme",
+  "bugs": {
+    "url": "https://github.com/usecontextlayer/pi-durable-assistant-ui/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true });\" && tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput"
+  },
+  "peerDependencies": {
+    "@assistant-ui/react": "^0.15.32",
+    "react": "^19.0.0",
+    "@earendil-works/pi-durable": "^1.5.0"
+  },
+  "dependencies": {
+    "@earendil-works/chord": "1.5.0",
+    "@earendil-works/pi-ai": "1.5.0"
+  },
+  "devDependencies": {
+    "@assistant-ui/react": "0.15.32",
+    "react": "19.3.1",
+    "@earendil-works/pi-durable": "1.5.0"
+  }
+}