@camerontaylor/paseo-client 0.8.0-fork.1 → 0.8.0-fork.3

package/dist/provider-snapshots/index.js

@@ -3,57 +3,53 @@ export class ProviderSnapshotUpdates {
     constructor(host) {
         this.host = host;
         this.pending = new Map();
-        this.paused = false;
     }
     clear() {
         this.pending.clear();
     }
-    pause() {
-        this.paused = true;
-        // Invalidate old responses while retaining the announcements they would resolve.
-        for (const [cwd, pending] of this.pending) {
-            this.pending.set(cwd, { latest: pending.latest, running: false });
-        }
-    }
-    resume() {
-        this.paused = false;
-        for (const pending of this.pending.values())
-            this.receive(pending.latest);
-    }
     receive(update) {
-        const cwd = update.payload.cwd;
-        const pending = this.pending.get(cwd) ?? { latest: update, running: false };
+        if (!this.host.active(update))
+            return;
+        const key = JSON.stringify([update.payload.subscriptionId, update.payload.cwd]);
+        const pending = this.pending.get(key) ?? { latest: update, running: false };
         pending.latest = update;
-        this.pending.set(cwd, pending);
-        if (this.paused || pending.running)
+        this.pending.set(key, pending);
+        if (pending.running)
             return;
         pending.running = true;
-        void this.resolve(cwd, pending);
+        void this.resolve(key, pending);
     }
-    async resolve(cwd, pending) {
+    async resolve(key, pending) {
         try {
-            while (this.pending.get(cwd) === pending) {
+            while (this.pending.get(key) === pending) {
                 const announced = pending.latest;
-                const snapshot = await this.host.fetch(cwd);
-                if (this.pending.get(cwd) !== pending)
+                if (!this.host.active(announced))
+                    return;
+                const snapshot = await this.host.fetch(announced.payload.cwd);
+                if (!this.host.active(announced))
+                    return;
+                if (this.pending.get(key) !== pending)
                     return;
                 // A change arriving while the body was in flight needs the current body.
                 // If that response already covers it, no second fetch is necessary.
                 if (pending.latest !== announced &&
                     pending.latest.payload.snapshotHash !== snapshot.snapshotHash)
                     continue;
-                this.pending.delete(cwd);
-                this.host.emit({ type: "providers_snapshot_update", payload: snapshot });
+                this.pending.delete(key);
+                this.host.emit({
+                    type: "providers_snapshot_update",
+                    payload: { ...snapshot, subscriptionId: announced.payload.subscriptionId },
+                });
                 return;
             }
         }
         catch (error) {
-            if (this.pending.get(cwd) === pending)
+            if (this.pending.get(key) === pending)
                 this.host.failed(error);
         }
         finally {
-            if (this.pending.get(cwd) === pending)
-                this.pending.delete(cwd);
+            if (this.pending.get(key) === pending)
+                this.pending.delete(key);
         }
     }
 }

package/dist/terminal-stream-router.d.ts

@@ -1,28 +1,25 @@
 import { type TerminalStreamFrame } from "@camerontaylor/paseo-protocol/binary-frames/index";
-import type { TerminalInput, TerminalState } from "@camerontaylor/paseo-protocol/messages";
+import type { TerminalState } from "@camerontaylor/paseo-protocol/messages";
 export type TerminalStreamEvent = {
     terminalId: string;
+    subscriptionId: string;
+} & ({
     type: "output";
     data: Uint8Array;
 } | {
-    terminalId: string;
     type: "snapshot";
     state: TerminalState;
 } | {
-    terminalId: string;
     type: "restore";
     data: Uint8Array;
-};
+});
 export declare class TerminalStreamRouter {
-    private readonly terminalSlots;
-    private readonly slotTerminals;
+    private readonly slots;
     private readonly listeners;
+    /** Passive wire diagnostics. App state consumes the registration's callback. */
     onEvent(handler: (event: TerminalStreamEvent) => void): () => void;
-    setSlot(terminalId: string, slot: number): void;
-    removeTerminal(terminalId: string): void;
+    attach(subscriptionId: string, terminalId: string, slot: number, receive: (event: TerminalStreamEvent) => void): () => void;
     clearSlots(): void;
-    encodeInput(terminalId: string, message: TerminalInput["message"]): Uint8Array | null;
     handleFrame(frame: TerminalStreamFrame): void;
-    private emit;
 }
 //# sourceMappingURL=terminal-stream-router.d.ts.map

package/dist/terminal-stream-router.js

@@ -1,107 +1,60 @@
-import { decodeTerminalSnapshotPayload, encodeTerminalResizePayload, encodeTerminalStreamFrame, TerminalStreamOpcode, } from "@camerontaylor/paseo-protocol/binary-frames/index";
+import { decodeTerminalSnapshotPayload, TerminalStreamOpcode, } from "@camerontaylor/paseo-protocol/binary-frames/index";
 export class TerminalStreamRouter {
     constructor() {
-        this.terminalSlots = new Map();
-        this.slotTerminals = new Map();
+        this.slots = new Map();
         this.listeners = new Set();
     }
+    /** Passive wire diagnostics. App state consumes the registration's callback. */
     onEvent(handler) {
         this.listeners.add(handler);
         return () => {
             this.listeners.delete(handler);
         };
     }
-    setSlot(terminalId, slot) {
-        const existingTerminalId = this.slotTerminals.get(slot);
-        if (existingTerminalId && existingTerminalId !== terminalId) {
-            this.terminalSlots.delete(existingTerminalId);
-        }
-        const existingSlot = this.terminalSlots.get(terminalId);
-        if (typeof existingSlot === "number" && existingSlot !== slot) {
-            this.slotTerminals.delete(existingSlot);
-        }
-        this.terminalSlots.set(terminalId, slot);
-        this.slotTerminals.set(slot, terminalId);
-    }
-    removeTerminal(terminalId) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return;
-        }
-        this.terminalSlots.delete(terminalId);
-        if (this.slotTerminals.get(slot) === terminalId) {
-            this.slotTerminals.delete(slot);
-        }
+    attach(subscriptionId, terminalId, slot, receive) {
+        const registration = { subscriptionId, terminalId, receive };
+        const registrations = this.slots.get(slot) ?? new Set();
+        registrations.add(registration);
+        this.slots.set(slot, registrations);
+        return () => {
+            registrations.delete(registration);
+            if (registrations.size === 0)
+                this.slots.delete(slot);
+        };
     }
     clearSlots() {
-        this.terminalSlots.clear();
-        this.slotTerminals.clear();
-    }
-    encodeInput(terminalId, message) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return null;
-        }
-        if (message.type === "input") {
-            return encodeTerminalStreamFrame({
-                opcode: TerminalStreamOpcode.Input,
-                slot,
-                payload: message.data,
-            });
-        }
-        if (message.type === "resize") {
-            return encodeTerminalStreamFrame({
-                opcode: TerminalStreamOpcode.Resize,
-                slot,
-                payload: encodeTerminalResizePayload({
-                    rows: message.rows,
-                    cols: message.cols,
-                    ...(message.intent ? { intent: message.intent } : {}),
-                }),
-            });
-        }
-        return null;
+        this.slots.clear();
     }
     handleFrame(frame) {
-        const terminalId = this.slotTerminals.get(frame.slot);
-        if (!terminalId) {
-            return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Output) {
-            this.emit({
-                terminalId,
-                type: "output",
-                data: frame.payload,
-            });
+        const registrations = this.slots.get(frame.slot);
+        if (!registrations)
             return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Restore) {
-            this.emit({
-                terminalId,
-                type: "restore",
-                data: frame.payload,
-            });
-            return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Snapshot) {
-            const state = decodeTerminalSnapshotPayload(frame.payload);
-            if (!state) {
-                return;
+        for (const registration of registrations) {
+            const identity = {
+                subscriptionId: registration.subscriptionId,
+                terminalId: registration.terminalId,
+            };
+            let event;
+            if (frame.opcode === TerminalStreamOpcode.Output)
+                event = { ...identity, type: "output", data: frame.payload };
+            else if (frame.opcode === TerminalStreamOpcode.Restore)
+                event = { ...identity, type: "restore", data: frame.payload };
+            else if (frame.opcode === TerminalStreamOpcode.Snapshot) {
+                const state = decodeTerminalSnapshotPayload(frame.payload);
+                if (!state)
+                    return;
+                event = { ...identity, type: "snapshot", state };
             }
-            this.emit({
-                terminalId,
-                type: "snapshot",
-                state,
-            });
-        }
-    }
-    emit(event) {
-        for (const listener of this.listeners) {
-            try {
-                listener(event);
-            }
-            catch {
-                // no-op
+            else
+                return;
+            registration.receive(event);
+            for (const listener of this.listeners) {
+                try {
+                    listener(event);
+                }
+                catch {
+                    /* Passive diagnostics cannot interrupt delivery. */
+                }
             }
         }
     }

package/dist/timeline-subscription/index.d.ts

@@ -0,0 +1,25 @@
+import type { SessionOutboundMessage } from "@camerontaylor/paseo-protocol/messages";
+import type { OwnedSubscription, TimelineSubscription } from "../connection/index.js";
+type TimelineUpdate = Extract<SessionOutboundMessage, {
+    type: "agent_stream" | "agent.timeline.replacement";
+}>;
+/** Local SDK lifecycle messages; these are not additional wire RPCs. */
+export type TimelineMessage = TimelineUpdate | {
+    type: "agent.timeline.subscription_restored";
+    payload: {
+        agentId: string;
+        subscriptionId: string;
+    };
+} | {
+    type: "agent.timeline.error";
+    payload: {
+        agentId: string;
+        error: string;
+    };
+};
+/** Restores live delivery; the consumer owns history reads and gap recovery. */
+export declare function subscribeTimeline(agentId: string, observation: OwnedSubscription<{
+    agentIds: string[];
+}>, handler: (message: TimelineMessage) => void, reportError: (error: unknown) => void): TimelineSubscription;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/timeline-subscription/index.js

@@ -0,0 +1,56 @@
+/** Restores live delivery; the consumer owns history reads and gap recovery. */
+export function subscribeTimeline(agentId, observation, handler, reportError) {
+    let established = false;
+    let released = false;
+    const notify = (message) => {
+        if (released)
+            return;
+        try {
+            handler(message);
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    const release = () => {
+        released = true;
+        return observation.release();
+    };
+    const stop = () => {
+        // Use the public release entry point so the owning API also forgets this handle.
+        void subscription.release().catch(reportError);
+    };
+    const fail = (error) => {
+        notify({
+            type: "agent.timeline.error",
+            payload: { agentId, error: error instanceof Error ? error.message : String(error) },
+        });
+        stop();
+    };
+    observation.subscribe({
+        snapshot: ({ subscriptionId }) => {
+            if (!established) {
+                established = true;
+                return;
+            }
+            notify({
+                type: "agent.timeline.subscription_restored",
+                payload: { agentId, subscriptionId },
+            });
+        },
+        update: (message) => {
+            if (message.type === "agent_stream" || message.type === "agent.timeline.replacement")
+                notify(message);
+        },
+        error: fail,
+    });
+    const subscription = Object.assign(stop, {
+        ready: observation.ready.then(() => undefined),
+        release,
+        subscriptionId: null,
+    });
+    Object.defineProperty(subscription, "subscriptionId", { get: () => observation.subscriptionId });
+    void subscription.ready.catch(fail);
+    return subscription;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-client",
-  "version": "0.8.0-fork.1",
+  "version": "0.8.0-fork.3",
   "description": "Paseo client SDK package",
   "files": [
     "dist",
@@ -39,13 +39,17 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@camerontaylor/paseo-protocol": "0.8.0-fork.1",
-    "@camerontaylor/paseo-relay": "0.8.0-fork.1",
+    "@camerontaylor/paseo-protocol": "0.8.0-fork.3",
+    "@camerontaylor/paseo-relay": "0.8.0-fork.3",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",
     "typescript": "^5.2.2",
     "vitest": "^4.1.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camerontaylor/paseo"
   }
 }

package/dist/creation/index.d.ts

@@ -1,47 +0,0 @@
-import type { AgentSnapshotPayload, CreationSnapshot, WorkspaceCreateResponse } from "@camerontaylor/paseo-protocol/messages";
-import type { CreateAgentRequestOptions, CreateWorkspaceRequestOptions } from "../daemon-client.js";
-type Kind = CreationSnapshot["kind"];
-export interface CreationResult {
-    agent?: AgentSnapshotPayload | null;
-    workspace?: WorkspaceCreateResponse["payload"]["workspace"];
-    creation?: CreationSnapshot;
-    error: string | null;
-    errorCode?: string;
-    setupTerminalId?: string | null;
-    setupSkippedReason?: string;
-    requestId?: string;
-}
-interface Dependencies {
-    supports: () => boolean;
-    connected: () => boolean;
-    requestId: () => string;
-    request: (kind: Kind, input: Record<string, unknown>) => Promise<CreationResult>;
-    subscribe: (kind: Kind, key: string, enabled?: boolean) => Promise<CreationSnapshot | null>;
-    legacyAgent: (input: CreateAgentRequestOptions) => Promise<AgentSnapshotPayload>;
-    legacyWorkspace: (input: CreateWorkspaceRequestOptions) => Promise<WorkspaceCreateResponse["payload"]>;
-    sendMessage: (id: string, text: string, options: {
-        messageId: string;
-        images?: CreateAgentRequestOptions["images"];
-        attachments?: CreateAgentRequestOptions["attachments"];
-    }) => Promise<unknown>;
-}
-/** Client-owned observation and compatibility. UI callbacks never advance creation. */
-export declare class CreationClient {
-    private readonly deps;
-    private readonly operations;
-    constructor(deps: Dependencies);
-    createAgent(input: CreateAgentRequestOptions): Promise<CreationResult>;
-    createWorkspace(input: CreateWorkspaceRequestOptions): Promise<CreationResult>;
-    private legacyAgent;
-    private start;
-    private submit;
-    receive(snapshot: CreationSnapshot): void;
-    private recover;
-    reconnect(): void;
-    close(): void;
-    private finish;
-    private fail;
-    private notify;
-}
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/creation/index.js

@@ -1,216 +0,0 @@
-/** Client-owned observation and compatibility. UI callbacks never advance creation. */
-export class CreationClient {
-    constructor(deps) {
-        this.deps = deps;
-        this.operations = new Map();
-    }
-    createAgent(input) {
-        const { onEvent, ...request } = input;
-        return this.start("agent", request, onEvent, () => this.legacyAgent(request));
-    }
-    createWorkspace(input) {
-        const { onEvent, ...request } = input;
-        return this.start("workspace", request, onEvent, async (operation) => {
-            if (request.workspaceId || request.agent?.agentId)
-                throw new Error("Update the host to use caller-selected creation IDs.");
-            const { agent, ...workspaceInput } = request;
-            const workspace = await this.deps.legacyWorkspace(workspaceInput);
-            if (workspace.error || !workspace.workspace)
-                return workspace;
-            this.receive({
-                kind: "workspace",
-                idempotencyKey: operation.key,
-                revision: 1,
-                phase: "workspace_ready",
-                workspaceId: workspace.workspace.id,
-                agentId: null,
-                workspace: workspace.workspace,
-                setupSkippedReason: workspace.setupSkippedReason,
-                error: null,
-            });
-            if (!agent)
-                return workspace;
-            const sourceCwd = request.source.kind === "directory" ? request.source.path : request.source.cwd;
-            const cwd = sourceCwd
-                ? remapDirectory(agent.config.cwd, sourceCwd, workspace.workspace.workspaceDirectory)
-                : workspace.workspace.workspaceDirectory;
-            const created = await this.legacyAgent({
-                ...agent,
-                config: { ...agent.config, cwd },
-                workspaceId: workspace.workspace.id,
-                idempotencyKey: `${operation.key}:agent`,
-            });
-            return { ...workspace, agent: created.agent };
-        });
-    }
-    async legacyAgent(input) {
-        if (input.agentId)
-            throw new Error("Update the host to use caller-selected creation IDs.");
-        // COMPAT(creationLifecycle): added in v0.8.0, remove after 2027-03-11 once the daemon floor supports creationLifecycle.
-        // Old keyed creates reject initialPrompt. Keep this adaptation private to the SDK.
-        if (input.idempotencyKey) {
-            const { initialPrompt = "", images, attachments, ...creation } = input;
-            const hasPrompt = Boolean(initialPrompt.trim() || images?.length || attachments?.length);
-            if (hasPrompt && input.outputSchema)
-                throw new Error("Update the host to create a keyed agent with structured initial output.");
-            const agent = await this.deps.legacyAgent(creation);
-            if (hasPrompt)
-                await this.deps.sendMessage(agent.id, initialPrompt, {
-                    messageId: input.clientMessageId ?? `${input.idempotencyKey}:initial-message`,
-                    images,
-                    attachments,
-                });
-            return { agent, error: null };
-        }
-        return { agent: await this.deps.legacyAgent(input), error: null };
-    }
-    start(kind, input, observer, legacy) {
-        const key = typeof input.idempotencyKey === "string" ? input.idempotencyKey : this.deps.requestId();
-        const identity = JSON.stringify([kind, key]);
-        const { requestId: _requestId, ...intent } = input;
-        const fingerprint = JSON.stringify(intent, (_key, value) => value && typeof value === "object" && !Array.isArray(value)
-            ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)))
-            : value);
-        const previous = this.operations.get(identity);
-        if (previous) {
-            if (previous.fingerprint !== fingerprint)
-                return Promise.reject(new Error(`${kind}_request_key_conflict`));
-            if (observer) {
-                previous.observers.add(observer);
-                if (previous.snapshot)
-                    this.notify(observer, previous.snapshot);
-            }
-            return previous.result;
-        }
-        let resolve;
-        let reject;
-        const result = new Promise((done, fail) => {
-            resolve = done;
-            reject = fail;
-        });
-        const operation = {
-            kind,
-            key,
-            input: { ...input, idempotencyKey: key },
-            fingerprint,
-            observers: new Set(observer ? [observer] : []),
-            result,
-            resolve,
-            reject,
-            settled: false,
-            modern: this.deps.supports(),
-            recovering: false,
-        };
-        this.operations.set(identity, operation);
-        if (operation.modern)
-            void this.submit(operation);
-        else
-            void legacy(operation).then((value) => this.finish(operation, value), (error) => this.fail(operation, error));
-        return result;
-    }
-    async submit(operation) {
-        try {
-            const result = await this.deps.request(operation.kind, {
-                ...operation.input,
-                subscribe: true,
-            });
-            if (result.creation)
-                this.receive(result.creation);
-            this.finish(operation, result);
-        }
-        catch (error) {
-            if (operation.settled || !this.deps.connected())
-                return;
-            this.fail(operation, error);
-        }
-    }
-    receive(snapshot) {
-        const operation = this.operations.get(JSON.stringify([snapshot.kind, snapshot.idempotencyKey]));
-        if (!operation || (operation.snapshot && operation.snapshot.revision >= snapshot.revision))
-            return;
-        operation.snapshot = snapshot;
-        for (const observer of operation.observers)
-            this.notify(observer, snapshot);
-        if (operation.recovering && (snapshot.phase === "completed" || snapshot.phase === "failed")) {
-            this.finish(operation, {
-                agent: snapshot.agent,
-                workspace: snapshot.workspace,
-                creation: snapshot,
-                setupSkippedReason: snapshot.setupSkippedReason,
-                error: snapshot.error,
-                errorCode: snapshot.errorCode,
-            });
-        }
-    }
-    async recover(operation) {
-        operation.recovering = true;
-        const snapshot = await this.deps.subscribe(operation.kind, operation.key);
-        if (!snapshot) {
-            await this.submit(operation);
-            return;
-        }
-        this.receive(snapshot);
-        if (snapshot.phase === "completed" || snapshot.phase === "failed") {
-            this.finish(operation, {
-                agent: snapshot.agent,
-                workspace: snapshot.workspace,
-                creation: snapshot,
-                setupSkippedReason: snapshot.setupSkippedReason,
-                error: snapshot.error,
-                errorCode: snapshot.errorCode,
-            });
-        }
-    }
-    reconnect() {
-        for (const operation of this.operations.values()) {
-            if (operation.settled || !operation.modern)
-                continue;
-            void this.recover(operation).catch((error) => {
-                if (this.deps.connected())
-                    this.fail(operation, error);
-            });
-        }
-    }
-    close() {
-        for (const operation of this.operations.values())
-            if (!operation.settled)
-                this.fail(operation, new Error("Daemon client closed"));
-        this.operations.clear();
-    }
-    finish(operation, result) {
-        if (operation.settled)
-            return;
-        operation.settled = true;
-        if (operation.recovering)
-            void this.deps.subscribe(operation.kind, operation.key, false).catch(() => undefined);
-        operation.resolve(result);
-        operation.observers.clear();
-        this.operations.delete(JSON.stringify([operation.kind, operation.key]));
-    }
-    fail(operation, error) {
-        if (operation.settled)
-            return;
-        operation.settled = true;
-        operation.reject(error instanceof Error ? error : new Error(String(error)));
-        operation.observers.clear();
-        this.operations.delete(JSON.stringify([operation.kind, operation.key]));
-    }
-    notify(observer, snapshot) {
-        try {
-            observer(snapshot);
-        }
-        catch {
-            /* Observation does not control execution. */
-        }
-    }
-}
-function remapDirectory(cwd, source, target) {
-    const normalize = (value) => value.replace(/\\/g, "/").replace(/\/$/, "");
-    const normalized = normalize(cwd), root = normalize(source);
-    if (normalized === root)
-        return target;
-    if (!normalized.startsWith(`${root}/`))
-        throw new Error("Agent directory must be inside the workspace source");
-    return `${normalize(target)}${normalized.slice(root.length)}`;
-}
-//# sourceMappingURL=index.js.map