@opencode-ai/client 0.0.0-dev-19178 → 0.0.0-dev-19182

package/dist/promise/client.d.ts

@@ -1,4 +1,5 @@
 export * as OpenCode from "./client.js";
+import { SharedEvents } from "../shared-events.js";
 import { OpenCode } from "./generated/index.js";
 import type { ClientOptions } from "./generated/client.js";
 export type { ClientOptions, RequestOptions } from "./generated/client.js";
@@ -7,9 +8,7 @@ export declare function make(options: ClientOptions): {
         call: (input: import("./index.js").RpcCallInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").RpcOutput>;
     };
     event: {
-        subscribe(options?: {
-            readonly signal?: AbortSignal;
-        } | undefined): AsyncIterable<import("./index.js").V2Event>;
+        subscribe(options?: SharedEvents.SubscribeOptions): AsyncIterable<import("./index.js").V2Event>;
     };
     health: {
         get: (requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").ServiceHealth>;

package/dist/promise/client.js

@@ -4,7 +4,7 @@ import { OpenCode } from "./generated/index.js";
 import { makeRpc } from "./rpc.js";
 export function make(options) {
     const raw = OpenCode.make(options);
-    const events = SharedEvents.make((signal) => raw.event.subscribe({ signal }));
+    const events = SharedEvents.make((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
     return {
         ...raw,
         rpc: Object.assign(makeRpc(raw, events), raw.rpc),

package/dist/promise/generated/client.d.ts

@@ -7,6 +7,8 @@ export interface ClientOptions {
 export interface RequestOptions {
     readonly signal?: AbortSignal;
     readonly headers?: RequestInit["headers"];
+    /** Reports every chunk a streaming response receives, including keepalive comments that yield no event. */
+    readonly onActivity?: () => void;
 }
 export declare function make(options: ClientOptions): {
     health: {

package/dist/promise/generated/client.js

@@ -84,6 +84,8 @@ export function make(options) {
                     catch (cause) {
                         throw new ClientError("Transport", { cause });
                     }
+                    if (!next.done)
+                        requestOptions?.onActivity?.();
                     buffer += decoder.decode(next.value, { stream: !next.done });
                     if (buffer.length > maxSseEventBytes)
                         throw new ClientError("SseEventTooLarge");

package/dist/shared-events.d.ts

@@ -1,8 +1,11 @@
 export * as SharedEvents from "./shared-events.js";
+export type SubscribeOptions = {
+    readonly signal?: AbortSignal;
+    /** Reports transport activity on the shared stream, including keepalive frames that carry no event. */
+    readonly onActivity?: () => void;
+};
 export declare function make<A extends {
     readonly type: string;
-}>(connect: (signal: AbortSignal) => AsyncIterable<A>): {
-    subscribe(options?: {
-        readonly signal?: AbortSignal;
-    }): AsyncIterable<A>;
+}>(connect: (signal: AbortSignal, onActivity: () => void) => AsyncIterable<A>): {
+    subscribe(options?: SubscribeOptions): AsyncIterable<A>;
 };

package/dist/shared-events.js

@@ -14,7 +14,9 @@ export function make(connect) {
         try {
             if (connection.controller.signal.aborted)
                 return;
-            iterator = connect(connection.controller.signal)[Symbol.asyncIterator]();
+            iterator = connect(connection.controller.signal, () => {
+                connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+            })[Symbol.asyncIterator]();
             while (!connection.controller.signal.aborted) {
                 const item = await iterator.next();
                 if (item.done || connection.controller.signal.aborted)
@@ -66,6 +68,7 @@ export function make(connect) {
                         finish({});
                     }
                     const subscriber = {
+                        activity: options?.onActivity,
                         finish(result) {
                             finish(result, false);
                         },

package/dist/solid/connection.d.ts

@@ -14,16 +14,24 @@ export type ClientConnectionOptions = {
     readonly onEvent: (event: OpenCodeEvent) => void;
     readonly flushInterval?: number;
     readonly pageLifecycle?: boolean;
+    /**
+     * Abort and reconnect a stream that receives no bytes for this long. The server writes a keepalive
+     * comment every 15 seconds, so a quiet but healthy stream never trips this.
+     */
+    readonly idleTimeout?: number;
     readonly log?: {
         readonly debug?: (message: string, data?: Readonly<Record<string, unknown>>) => void;
         readonly info?: (message: string, data?: Readonly<Record<string, unknown>>) => void;
     };
 };
+export declare const defaultIdleTimeout = 45000;
+export declare const foregroundIdleThreshold = 20000;
 export declare function createClientConnection(initialApi: OpenCodeClient, options: ClientConnectionOptions): {
     status: () => ClientConnectionStatus;
     attempt: () => number;
     error: () => string | undefined;
     internal: {
         history: () => ClientConnectionEvent[];
+        resync: (reason: string) => void;
     };
 };

package/dist/solid/connection.js

@@ -1,19 +1,27 @@
-import { batch, onCleanup, onMount } from "solid-js";
+import { batch, onCleanup } from "solid-js";
 import { createStore } from "solid-js/store";
 const connectTimeout = 2_000;
 const reconnectDelay = 1_000;
 const connectionHistoryLimit = 50;
+export const defaultIdleTimeout = 45_000;
+// Longer than one server keepalive interval: a stream that is silent this long when the page
+// returns to the foreground is probably half-open after the device slept.
+export const foregroundIdleThreshold = 20_000;
 export function createClientConnection(initialApi, options) {
     const abort = new AbortController();
     const history = [];
+    const idleTimeout = options.idleTimeout ?? defaultIdleTimeout;
     const [connection, setConnection] = createStore({ status: "connecting", attempt: 0 });
     let api = initialApi;
     let pending = [];
     let flushTimer;
     let stream;
+    let current;
     let run;
     let started = false;
     let generation = 0;
+    let lastActivity = 0;
+    let forced = false;
     function record(status, attempt, error) {
         history.push({ type: "client.connection", created: Date.now(), data: { status, attempt, error } });
         if (history.length > connectionHistoryLimit)
@@ -33,13 +41,24 @@ export function createClientConnection(initialApi, options) {
     async function connect(signal, attempt) {
         let connectedAt;
         const request = new AbortController();
+        current = request;
         const cancel = () => request.abort(signal.reason);
         const timeout = setTimeout(() => request.abort(new Error("Timed out connecting to server")), connectTimeout);
         signal.addEventListener("abort", cancel, { once: true });
+        // Any received bytes, including keepalive comments, push the stall deadline out. A timer whose
+        // deadline passed while the page was suspended fires as soon as the page resumes.
+        let watchdog;
+        const touch = () => {
+            lastActivity = Date.now();
+            if (connectedAt === undefined)
+                return;
+            clearTimeout(watchdog);
+            watchdog = setTimeout(() => request.abort(new Error("Event stream stalled")), idleTimeout);
+        };
         try {
             record(attempt === 0 ? "connecting" : "reconnecting", attempt);
             options.log?.info?.("event stream connecting", { attempt });
-            const iterator = api.event.subscribe({ signal: request.signal })[Symbol.asyncIterator]();
+            const iterator = api.event.subscribe({ signal: request.signal, onActivity: touch })[Symbol.asyncIterator]();
             const first = await iterator.next();
             if (signal.aborted)
                 return { error: undefined, connectedAt };
@@ -53,6 +72,7 @@ export function createClientConnection(initialApi, options) {
             clearTimeout(timeout);
             record("connected", attempt);
             connectedAt = Date.now();
+            touch();
             options.log?.info?.("event stream connected");
             publish(first.value);
             setConnection({ status: "connected", attempt: 0, error: undefined });
@@ -61,7 +81,11 @@ export function createClientConnection(initialApi, options) {
                 if (signal.aborted)
                     return { error: undefined, connectedAt };
                 if (event.done)
-                    return { error: new Error("Event stream disconnected"), connectedAt };
+                    return {
+                        error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
+                        connectedAt,
+                    };
+                touch();
                 if ("durable" in event.value && event.value.durable)
                     options.log?.debug?.("event", {
                         type: event.value.type,
@@ -77,7 +101,10 @@ export function createClientConnection(initialApi, options) {
         }
         finally {
             request.abort();
+            if (current === request)
+                current = undefined;
             clearTimeout(timeout);
+            clearTimeout(watchdog);
             signal.removeEventListener("abort", cancel);
         }
     }
@@ -113,6 +140,11 @@ export function createClientConnection(initialApi, options) {
                         continue;
                 }
             }
+            // A deliberate resync already knows the old socket is gone; reconnect without backing off.
+            if (forced) {
+                forced = false;
+                continue;
+            }
             await wait(reconnectDelay, controller.signal);
         }
     }
@@ -120,6 +152,7 @@ export function createClientConnection(initialApi, options) {
         if (started)
             return run;
         started = true;
+        forced = false;
         const active = ++generation;
         const previous = run;
         const current = (async () => {
@@ -135,26 +168,47 @@ export function createClientConnection(initialApi, options) {
         return run;
     }
     function stop() {
+        if (!started)
+            return;
         started = false;
         generation += 1;
         stream?.abort();
+        // Nothing is listening once stopped, so consumers must treat their data as stale until start() reconnects.
+        setConnection({ status: "connecting", attempt: 0, error: undefined });
     }
-    onMount(() => {
-        if (options.pageLifecycle) {
-            const pagehide = () => stop();
-            const pageshow = (event) => {
-                if (event.persisted)
-                    void start();
-            };
-            window.addEventListener("pagehide", pagehide);
-            window.addEventListener("pageshow", pageshow);
-            onCleanup(() => {
-                window.removeEventListener("pagehide", pagehide);
-                window.removeEventListener("pageshow", pageshow);
-            });
-        }
-        void start();
-    });
+    // Drop the live request so the reconnect loop replaces it now instead of waiting for the idle watchdog.
+    function resync(reason) {
+        if (!started || connection.status !== "connected")
+            return;
+        options.log?.info?.("event stream resync", { reason, idle: Date.now() - lastActivity });
+        forced = true;
+        current?.abort(new Error(reason));
+    }
+    if (options.pageLifecycle) {
+        const pagehide = () => stop();
+        const pageshow = () => void start();
+        // Locking a phone or switching apps hides the document without a pagehide; the socket usually
+        // dies while the page is suspended, and the browser may never report that on the hung read.
+        const visibility = () => {
+            if (document.visibilityState !== "visible")
+                return;
+            if (Date.now() - lastActivity < foregroundIdleThreshold)
+                return;
+            resync("Page returned to the foreground after the event stream went quiet");
+        };
+        const online = () => resync("Network connection restored");
+        window.addEventListener("pagehide", pagehide);
+        window.addEventListener("pageshow", pageshow);
+        window.addEventListener("online", online);
+        document.addEventListener("visibilitychange", visibility);
+        onCleanup(() => {
+            window.removeEventListener("pagehide", pagehide);
+            window.removeEventListener("pageshow", pageshow);
+            window.removeEventListener("online", online);
+            document.removeEventListener("visibilitychange", visibility);
+        });
+    }
+    void start();
     onCleanup(() => {
         stop();
         abort.abort();
@@ -168,6 +222,7 @@ export function createClientConnection(initialApi, options) {
         error: () => connection.error,
         internal: {
             history: () => history.slice(),
+            resync,
         },
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/client",
-  "version": "0.0.0-dev-19178",
+  "version": "0.0.0-dev-19182",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -57,8 +57,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/schema": "0.0.0-dev-19178",
-    "@opencode-ai/protocol": "0.0.0-dev-19178"
+    "@opencode-ai/schema": "0.0.0-dev-19182",
+    "@opencode-ai/protocol": "0.0.0-dev-19182"
   },
   "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-19178",
+    "@opencode-ai/httpapi-codegen": "0.0.0-dev-19182",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",