@opencode-ai/client 0.0.0-dev-18592 → 0.0.0-dev-18598

package/dist/solid/data.d.ts

@@ -1,4 +1,4 @@
-import type { AgentInfo, CommandInfo, FormCancelInput, FormInfo, FormReplyInput, IntegrationInfo, LocationRef, LocationGetOutput, McpResource, McpServer, ModelInfo, ModelRef, PermissionSavedInfo, PermissionRequest, PermissionReplyInput, Project, ProviderInfo, ReferenceInfo, SessionMessageInfo, SessionInfo, SessionInboxInfo, ShellInfo, SkillInfo, VcsInfo, OpenCodeEvent, OpenCodeClient, WebSearchProvider } from "../promise";
+import type { AgentInfo, CommandInfo, FormCancelInput, FormInfo, FormReplyInput, IntegrationInfo, LocationRef, LocationGetOutput, McpResource, McpServer, ModelInfo, ModelRef, PermissionSavedInfo, PermissionRequest, PermissionReplyInput, Project, ProviderInfo, ReferenceInfo, SessionMessageInfo, SessionInfo, SessionInboxInfo, SessionInboxCompaction, ShellInfo, SkillInfo, VcsInfo, OpenCodeEvent, OpenCodeClient, WebSearchProvider } from "../promise";
 import { type SessionPromptInput } from "../promise";
 export type DataSessionStatus = "idle" | "running";
 export type CreateDataInput = {
@@ -62,8 +62,13 @@ export declare function createData(config: CreateDataInput): {
             id: string;
             request: Promise<SessionInfo>;
         };
+        compact(input: {
+            sessionID: string;
+            model?: ModelRef;
+        }): Promise<SessionInboxCompaction>;
         prompt(input: SessionPromptInput & {
             gate?: Promise<unknown>;
+            prepare?: () => Promise<unknown>;
         }): Promise<import("../promise").SessionInboxUser>;
         sync(sessionID: string, options?: {
             children?: boolean;

package/dist/solid/data.js

@@ -164,12 +164,11 @@ export function createData(config) {
             return;
         setStore("session", "pending", sessionID, index, { ...item, delivery });
     }
-    // Inbox IDs of optimistic prompt admissions still awaiting their durable
-    // echo. This is the one deliberate piece of in-flight bookkeeping in this
-    // layer: it exists so a rejection only rolls back rows the server never
-    // acknowledged, and so a concurrent pending re-fetch cannot wipe a row the
-    // server does not know about yet. Entries clear on the enqueued echo or on
-    // rollback — not on POST success, which typically precedes the echo.
+    // Inbox IDs of optimistic admissions awaiting acknowledgement, so rejection
+    // only rolls back unacknowledged rows and a pending re-fetch cannot wipe a
+    // row the server does not know about yet. Prompts clear on their durable
+    // echo, positive pending read, or rollback; compactions also reconcile the
+    // POST's canonical ID.
     const outbox = new Set();
     // Session IDs of optimistic create admissions still awaiting acknowledgement
     // (the session.created echo or the create response itself). A failed create
@@ -180,11 +179,12 @@ export function createData(config) {
     // this so a prompt sent to a still-creating session waits for the session
     // to exist server-side instead of failing with "not found".
     const creating = new Map();
-    // Per-session send chain: prompts must be admitted in submission order,
-    // and HTTP gives no ordering across concurrent POSTs. Each prompt waits
-    // for the previous prompt's POST (settled, so one failure does not block
-    // the next) before sending its own.
+    // Per-session send chain: prompts and compactions must be admitted in
+    // submission order. Each waits for the previous POST to settle, so one
+    // failure does not block the next.
     const sending = new Map();
+    const compacting = new Map();
+    onCleanup(() => compacting.clear());
     // Register `promise` under `key` until it settles. A later registration
     // replaces an earlier one; settlement only clears its own entry.
     function track(map, key, promise) {
@@ -195,9 +195,19 @@ export function createData(config) {
         };
         void promise.then(settle, settle);
     }
+    // Capture creation before settlement clears its entry, so dependent RPCs still see a failed create.
+    function sendAdmission(sessionID, send, gate) {
+        const created = creating.get(sessionID);
+        const previous = sending.get(sessionID);
+        const request = Promise.resolve()
+            .then(() => Promise.all([gate, created, previous]))
+            .then(send);
+        track(sending, sessionID, request.catch(() => undefined));
+        return request;
+    }
     // Upsert an admitted inbox item into pending, input, and (for user and
     // synthetic items) the visible transcript. Used by the inbox.enqueued
-    // handler and by optimistic prompt admission; the upsert is what reconciles
+    // handler and by optimistic admission; the upsert is what reconciles
     // the durable echo with an optimistic placeholder — the durable payload and
     // times replace the client's guess.
     function admitLocal(item) {
@@ -205,6 +215,8 @@ export function createData(config) {
             const pending = store.session.pending[item.sessionID] ?? [];
             const at = pending.findIndex((entry) => entry.id === item.id);
             setStore("session", "pending", item.sessionID, at < 0 ? [...pending, item] : pending.map((entry, index) => (index === at ? item : entry)));
+            if (item.type === "compaction")
+                return;
             const input = store.session.input[item.sessionID] ?? [];
             if (!input.includes(item.id))
                 setStore("session", "input", item.sessionID, [...input, item.id]);
@@ -536,6 +548,7 @@ export function createData(config) {
                     draft.push(existing);
                     message.reindex(draft, index, position);
                 });
+                compacting.get(event.data.sessionID)?.observed.add(event.data.inboxID);
                 return;
             }
             case "session.inbox.delivery.changed":
@@ -543,6 +556,7 @@ export function createData(config) {
                 return;
             case "session.inbox.cancelled": {
                 retractLocal(event.data.sessionID, event.data.inboxID);
+                compacting.get(event.data.sessionID)?.observed.add(event.data.inboxID);
                 return;
             }
             case "session.inbox.enqueued": {
@@ -553,6 +567,12 @@ export function createData(config) {
                     timeCreated: event.created,
                     ...event.data.item,
                 });
+                if (event.data.item.type === "compaction") {
+                    const active = compacting.get(event.data.sessionID);
+                    active?.observed.add(event.data.inboxID);
+                    if (active && active.id !== event.data.inboxID && outbox.delete(active.id))
+                        removePending(event.data.sessionID, active.id);
+                }
                 return;
             }
             case "session.instructions.updated":
@@ -853,6 +873,8 @@ export function createData(config) {
                         time: { created: event.created },
                     });
                 });
+                if (event.data.inputID)
+                    compacting.get(event.data.sessionID)?.observed.add(event.data.inputID);
                 return;
             case "session.execution.succeeded":
             case "session.execution.failed":
@@ -953,6 +975,8 @@ export function createData(config) {
                     }
                     message.append(draft, index, failed);
                 });
+                if (event.data.inputID)
+                    compacting.get(event.data.sessionID)?.observed.add(event.data.inputID);
                 return;
             case "permission.asked":
                 if (store.session.permission[event.data.sessionID]?.some((request) => request.id === event.data.id))
@@ -1138,10 +1162,17 @@ export function createData(config) {
                 sync(sessionID) {
                     return sync.run(`session.pending:${sessionID}`, async () => {
                         const pending = await api().session.inbox.list({ sessionID });
+                        // A positive read acknowledges admission even when its SSE echo is delayed.
+                        pending.forEach((item) => outbox.delete(item.id));
+                        // Compactions also coalesce by Session, not just by the proposed ID.
+                        if (pending.some((item) => item.type === "compaction"))
+                            store.session.pending[sessionID]
+                                ?.filter((item) => item.type === "compaction")
+                                .forEach((item) => outbox.delete(item.id));
                         // Keep optimistic rows still awaiting their echo: this fetch may
                         // have raced ahead of an in-flight admission the server does not
                         // know about yet.
-                        const inflight = (store.session.pending[sessionID] ?? []).filter((item) => outbox.has(item.id) && !pending.some((row) => row.id === item.id));
+                        const inflight = (store.session.pending[sessionID] ?? []).filter((item) => outbox.has(item.id));
                         const merged = inflight.length === 0 ? pending : [...pending, ...inflight];
                         batch(() => {
                             setStore("session", "pending", sessionID, reconcile(merged));
@@ -1205,13 +1236,62 @@ export function createData(config) {
                     track(creating, id, request);
                 return { id, request };
             },
+            compact(input) {
+                const active = compacting.get(input.sessionID);
+                if (active)
+                    return active.request;
+                // A known pending control ID may be consumed while setup waits. Propose
+                // a fresh ID and let the server coalesce, without duplicating its row.
+                const id = SessionMessage.ID.create();
+                if (!store.session.pending[input.sessionID]?.some((item) => item.type === "compaction")) {
+                    outbox.add(id);
+                    admitLocal({
+                        id,
+                        sessionID: input.sessionID,
+                        timeCreated: Date.now(),
+                        type: "compaction",
+                        delivery: "steer",
+                        payload: {},
+                    });
+                }
+                // Compaction admission can coalesce onto a different ID. Retire the
+                // speculative row on an echo, and remember consumed IDs until the POST
+                // settles so its older response cannot resurrect a queued row.
+                const observed = new Set();
+                const request = sendAdmission(input.sessionID, async () => {
+                    if (input.model)
+                        await api().session.switchModel({ sessionID: input.sessionID, model: input.model });
+                    return api().session.compact({ sessionID: input.sessionID, id });
+                })
+                    .then((item) => {
+                    batch(() => {
+                        outbox.delete(id);
+                        if (item.id !== id)
+                            removePending(input.sessionID, id);
+                        if (!observed.has(item.id) && !messageIndex.get(input.sessionID)?.has(item.id))
+                            admitLocal(item);
+                    });
+                    return item;
+                })
+                    .catch((error) => {
+                    if (outbox.delete(id))
+                        removePending(input.sessionID, id);
+                    throw error;
+                })
+                    .finally(() => {
+                    if (compacting.get(input.sessionID)?.request === request)
+                        compacting.delete(input.sessionID);
+                });
+                compacting.set(input.sessionID, { id, observed, request });
+                return request;
+            },
             // Optimistic prompt admission: render the prompt immediately under a
             // client-minted ID, send it, and let the durable inbox.enqueued echo
             // upsert that same ID with the server's payload. Server admission is
             // idempotent per ID, so retrying with the identical payload cannot
             // double-admit.
             prompt(input) {
-                const { gate, ...request } = input;
+                const { gate, prepare, ...request } = input;
                 const id = request.id ?? SessionMessage.ID.create();
                 // A retry may reuse an ID that is already rendered — and possibly
                 // already durable. Admit optimistically only for new IDs so a failed
@@ -1236,18 +1316,11 @@ export function createData(config) {
                         },
                     });
                 }
-                // Wrapped so even a synchronous client failure reaches the rollback.
-                // The POST additionally waits for the caller's gate, for any
-                // in-flight optimistic create of this session, and for the previous
-                // prompt's POST: the row renders now, the send happens once the
-                // session exists server-side and earlier prompts are admitted.
-                const previous = sending.get(request.sessionID);
-                const send = Promise.resolve()
-                    .then(() => Promise.all([gate, creating.get(request.sessionID), previous]))
-                    .then(() => api().session.prompt({ ...request, id }));
-                track(sending, request.sessionID, send.then(() => undefined, () => undefined));
-                return send.catch((error) => {
-                    // Roll back only rows this call admitted and the echo has not
+                return sendAdmission(request.sessionID, async () => {
+                    await prepare?.();
+                    return api().session.prompt({ ...request, id });
+                }, gate).catch((error) => {
+                    // Roll back only rows this call admitted and the server has not
                     // acknowledged: anything else is server state.
                     if (fresh && outbox.delete(id))
                         retractLocal(request.sessionID, id);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/client",
-  "version": "0.0.0-dev-18592",
+  "version": "0.0.0-dev-18598",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -57,8 +57,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/schema": "0.0.0-dev-18592",
-    "@opencode-ai/protocol": "0.0.0-dev-18592"
+    "@opencode-ai/schema": "0.0.0-dev-18598",
+    "@opencode-ai/protocol": "0.0.0-dev-18598"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.112",
@@ -74,7 +74,7 @@
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode-ai/httpapi-codegen": "0.0.0-dev-18592",
+    "@opencode-ai/httpapi-codegen": "0.0.0-dev-18598",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",