@opencode-ai/client 0.0.0-dev-17829 → 0.0.0-dev-17843

package/dist/solid/data.d.ts

@@ -1,4 +1,4 @@
-import type { AgentInfo, CommandInfo, FormInfo, IntegrationInfo, LocationRef, LocationGetOutput, McpResource, McpServer, ModelInfo, PermissionSavedInfo, PermissionRequest, PermissionReplyInput, Project, ProviderInfo, ReferenceInfo, SessionMessageInfo, SessionInfo, SessionInboxInfo, ShellInfo, SkillInfo, VcsInfo, OpenCodeEvent, OpenCodeClient, WebSearchProvider } from "../promise";
+import type { AgentInfo, CommandInfo, FormInfo, 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 SessionPromptInput } from "../promise";
 export type DataSessionStatus = "idle" | "running";
 export type CreateDataInput = {
@@ -50,7 +50,20 @@ export declare function createData(config: CreateDataInput): {
             sync(sessionID: string): Promise<void>;
             invalidate(sessionID: string): void;
         };
-        prompt(input: SessionPromptInput): Promise<import("../promise").SessionInboxUser>;
+        create(input: {
+            id?: string;
+            title?: string;
+            agent?: string;
+            model?: ModelRef;
+            location?: LocationRef;
+            projectID?: string;
+        }): {
+            id: string;
+            request: Promise<SessionInfo>;
+        };
+        prompt(input: SessionPromptInput & {
+            gate?: Promise<unknown>;
+        }): Promise<import("../promise").SessionInboxUser>;
         sync(sessionID: string, options?: {
             children?: boolean;
         }): Promise<void>;

package/dist/solid/data.js

@@ -3,6 +3,7 @@
 // merges, live/history overlays, or other race machinery here—last write wins.
 // Reconnect invalidates cached reads; active UI owners decide what to sync again.
 import { Worktree } from "@opencode-ai/schema/worktree";
+import { SessionID } from "@opencode-ai/schema/session-id";
 import { SessionMessage } from "@opencode-ai/schema/session-message";
 import { isPermissionNotFoundError } from "../promise";
 import { createStore, produce, reconcile } from "solid-js/store";
@@ -105,6 +106,30 @@ export function createData(config) {
     // server does not know about yet. Entries clear on the enqueued echo or on
     // rollback — not on POST success, which typically precedes the echo.
     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
+    // only rolls back a session the server never acknowledged. Unlike
+    // `creating`, this clears on the echo rather than request settlement.
+    const sessionOutbox = new Set();
+    // In-flight optimistic creates by session ID. prompt() gates its POST on
+    // 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.
+    const sending = new Map();
+    // 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) {
+        map.set(key, promise);
+        const settle = () => {
+            if (map.get(key) === promise)
+                map.delete(key);
+        };
+        void promise.then(settle, settle);
+    }
     // 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
@@ -251,6 +276,7 @@ export function createData(config) {
         store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id));
         messageIndex.delete(sessionID);
         sync.invalidate(`session:${sessionID}`);
+        sync.invalidate(`session.family:${sessionID}`);
         sync.invalidate(`session.pending:${sessionID}`);
         sync.invalidate(`session.message:${sessionID}`);
         sync.invalidate(`session.permission:${sessionID}`);
@@ -294,6 +320,7 @@ export function createData(config) {
                 void result.project.sync().catch((error) => console.error("Failed to preload projects", error));
                 return;
             case "session.created":
+                sessionOutbox.delete(event.data.sessionID);
                 result.session.invalidate(event.data.sessionID);
                 void result.session.sync(event.data.sessionID);
                 // Band-aid: a newly created session starts empty, so live events can be its source of truth.
@@ -963,44 +990,103 @@ export function createData(config) {
                     sync.invalidate(`session.pending:${sessionID}`);
                 },
             },
+            // Optimistic session creation: admit a local record under a
+            // client-minted ID so a session view can mount immediately, then create
+            // the session on the server. The session.created echo re-syncs the
+            // record by ID, so the durable payload replaces the client's guess.
+            // Returns the ID synchronously along with the in-flight request:
+            // callers gate session-dependent sends on the request (prompt() gates
+            // itself on any in-flight create of its session automatically).
+            create(input) {
+                const { projectID, ...payload } = input;
+                const id = payload.id ?? SessionID.create();
+                const location = payload.location ?? defaultLocation();
+                const fresh = !store.session.info[id];
+                if (fresh) {
+                    const now = Date.now();
+                    sessionOutbox.add(id);
+                    result.session.remember({
+                        id,
+                        projectID: projectID ?? store.location[locationKey(location)]?.info?.project.id ?? "",
+                        agent: payload.agent,
+                        model: payload.model,
+                        cost: 0,
+                        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                        time: { created: now, updated: now },
+                        title: payload.title,
+                        location,
+                    });
+                    // A mounted optimistic session must not fetch its empty collections
+                    // before creation settles. The session.created echo re-syncs info.
+                    sync.complete(`session.family:${id}`);
+                    sync.complete(`session.pending:${id}`);
+                    sync.complete(`session.message:${id}`);
+                }
+                // Wrapped so even a synchronous client failure reaches the rollback.
+                const request = Promise.resolve()
+                    .then(() => api().session.create({ ...payload, id, location }))
+                    .then((info) => {
+                    sessionOutbox.delete(id);
+                    result.session.remember(info);
+                    return info;
+                })
+                    .catch((error) => {
+                    // Roll back only a record this call admitted and neither the echo
+                    // nor the response has acknowledged: anything else is server state.
+                    if (fresh && sessionOutbox.delete(id))
+                        removeSession(id);
+                    throw error;
+                });
+                if (fresh)
+                    track(creating, id, request);
+                return { id, 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 id = input.id ?? SessionMessage.ID.create();
+                const { gate, ...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
                 // retry cannot roll back acknowledged state.
-                const fresh = !messageIndex.get(input.sessionID)?.has(id) &&
-                    !store.session.pending[input.sessionID]?.some((item) => item.id === id);
+                const fresh = !messageIndex.get(request.sessionID)?.has(id) &&
+                    !store.session.pending[request.sessionID]?.some((item) => item.id === id);
                 if (fresh) {
                     outbox.add(id);
                     admitLocal({
                         id,
-                        sessionID: input.sessionID,
+                        sessionID: request.sessionID,
                         timeCreated: Date.now(),
                         type: "user",
-                        delivery: input.delivery ?? "steer",
+                        delivery: request.delivery ?? "steer",
                         // Files and skills stay off the optimistic row: their durable
                         // forms are server-loaded (content, mime, resolution), so they
                         // fill in when the echo upserts the row.
                         payload: {
-                            text: input.text,
-                            agents: input.agents?.map((agent) => ({ ...agent })),
-                            metadata: input.metadata,
+                            text: request.text,
+                            agents: request.agents?.map((agent) => ({ ...agent })),
+                            metadata: request.metadata,
                         },
                     });
                 }
                 // Wrapped so even a synchronous client failure reaches the rollback.
-                return Promise.resolve()
-                    .then(() => api().session.prompt({ ...input, id }))
-                    .catch((error) => {
+                // 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
                     // acknowledged: anything else is server state.
                     if (fresh && outbox.delete(id))
-                        retractLocal(input.sessionID, id);
+                        retractLocal(request.sessionID, id);
                     throw error;
                 });
             },

package/package.json

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