@opencode-ai/client 0.0.0-next-17239 → 0.0.0-next-17247

package/dist/effect/api/api.d.ts

@@ -1236,6 +1236,7 @@ export type Endpoint5_31Output = ({
 export type SessionLogOperation<E = never> = (input: Endpoint5_31Input) => Stream.Stream<Endpoint5_31Output, E>;
 export type Endpoint5_32Input = {
     readonly sessionID: Session.ID;
+    readonly continue?: boolean | undefined;
 };
 export type Endpoint5_32Output = void;
 export type SessionInterruptOperation<E = never> = (input: Endpoint5_32Input) => Effect.Effect<Endpoint5_32Output, E>;

package/dist/effect/generated/client.js

@@ -130,7 +130,10 @@ const Endpoint5_31 = (raw) => (input) => preserveStream()(Stream.unwrap(raw["ses
     params: { sessionID: input["sessionID"] },
     query: { after: input["after"], follow: input["follow"] },
 }).pipe(Effect.mapError(mapClientError), Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))))));
-const Endpoint5_32 = (raw) => (input) => preserveEffect()(raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+const Endpoint5_32 = (raw) => (input) => preserveEffect()(raw["session.interrupt"]({
+    params: { sessionID: input["sessionID"] },
+    query: { continue: input["continue"] },
+}).pipe(Effect.mapError(mapClientError)));
 const Endpoint5_33 = (raw) => (input) => preserveEffect()(raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
 const Endpoint5_34 = (raw) => (input) => preserveEffect()(raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const adaptGroup5 = (raw) => ({

package/dist/effect/service.js

@@ -3,6 +3,7 @@ import { Effect, FileSystem, Option, Schedule, Schema } from "effect";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { defaultEnsureTiming, ensureTiming } from "../service-timing.js";
 export * from "../service.js";
 // Read-only lookup: registration file plus health check and version gate.
 // Never spawns; escalation to ensure() is the caller's policy.
@@ -33,11 +34,12 @@ const discoverLocal = Effect.fnUntraced(function* (options) {
 // becomes discoverable. A contender is never killed merely for slow startup.
 /** Ensure a healthy, compatible local service is running. */
 export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
+    const timing = ensureTiming(options);
     const contenders = new Set();
     let timeouts;
     let announced = false;
     let lastSpawn = 0;
-    let spawnDelay = 5_000;
+    let spawnDelay = timing.spawnDelay;
     const announce = (reason, previousVersion) => Effect.sync(() => {
         if (announced)
             return;
@@ -62,7 +64,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
         });
     });
     const found = yield* Effect.gen(function* () {
-        const registration = yield* registered(options.file, true);
+        const registration = yield* registered(options.file, true, timing.requestTimeout);
         const info = registration.info;
         const service = registration.service;
         if (registration.timedOut && info !== undefined) {
@@ -72,7 +74,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
             };
             if (timeouts.count >= 3) {
                 yield* announce("missing");
-                yield* evict(info, options);
+                yield* evict(info, options, timing);
                 timeouts = undefined;
                 lastSpawn = Date.now() - spawnDelay;
             }
@@ -80,7 +82,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
         else
             timeouts = undefined;
         if (service !== undefined) {
-            spawnDelay = 5_000;
+            spawnDelay = timing.spawnDelay;
             const compatible = !service.legacy && (options.version === undefined || service.version === options.version);
             if (compatible && service.state === "ready")
                 return Option.some(service);
@@ -89,7 +91,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
             if (compatible)
                 return Option.none();
             yield* announce("version-mismatch", service.version);
-            yield* kill(service, options).pipe(Effect.ignore);
+            yield* kill(service, options, timing).pipe(Effect.ignore);
             lastSpawn = 0;
             return Option.none();
         }
@@ -98,7 +100,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
         const finished = [...contenders].filter(contenderFinished);
         const failure = finished.map(contenderFailure).find((error) => error !== undefined);
         if (finished.some((item) => item.child.exitCode === 0)) {
-            spawnDelay = Math.min(spawnDelay * 2, 30_000);
+            spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
         }
         finished.forEach((item) => contenders.delete(item));
         if (failure !== undefined && contenders.size === 0)
@@ -112,7 +114,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
         return Option.none();
     }).pipe(Effect.repeat({
         until: Option.isSome,
-        schedule: Schedule.max([Schedule.spaced("1 second"), Schedule.recurs(120)]),
+        schedule: Schedule.max([Schedule.spaced(timing.pollInterval), Schedule.recurs(timing.attempts)]),
     }));
     if (Option.isNone(found))
         return yield* Effect.fail(new Error("Timed out waiting for the background service to start"));
@@ -135,7 +137,7 @@ function contenderFinished(contender) {
 export const stop = Effect.fn("service.stop")(function* (options = {}) {
     const existing = yield* find(options);
     if (existing !== undefined)
-        yield* kill(existing, options);
+        yield* kill(existing, options, defaultEnsureTiming);
 });
 function fallback() {
     const state = process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state");
@@ -170,14 +172,14 @@ const read = Effect.fnUntraced(function* (file) {
 const probe = Effect.fnUntraced(function* (info, allowLegacy = false) {
     return (yield* probeResult(info, allowLegacy)).service;
 });
-const probeResult = Effect.fnUntraced(function* (info, allowLegacy = false) {
+const probeResult = Effect.fnUntraced(function* (info, allowLegacy = false, timeout = defaultEnsureTiming.requestTimeout) {
     const endpoint = {
         url: info.url,
         auth: info.password === undefined
             ? undefined
             : { type: "basic", username: "opencode", password: info.password },
     };
-    const signal = AbortSignal.timeout(2_000);
+    const signal = AbortSignal.timeout(timeout);
     const result = yield* Effect.promise(() => fetch(new URL("/api/health", info.url), {
         headers: headers(endpoint),
         signal,
@@ -214,11 +216,11 @@ const probeResult = Effect.fnUntraced(function* (info, allowLegacy = false) {
         timedOut: false,
     };
 });
-const registered = Effect.fnUntraced(function* (file, allowLegacy = false) {
+const registered = Effect.fnUntraced(function* (file, allowLegacy = false, timeout) {
     const info = yield* read(file);
     if (info === undefined)
         return { info: undefined, service: undefined, timedOut: false };
-    return { info, ...(yield* probeResult(info, allowLegacy)) };
+    return { info, ...(yield* probeResult(info, allowLegacy, timeout)) };
 });
 // Health-checked lookup without the version gate: lifecycle operations must be
 // able to see (and replace or stop) a server from a different version.
@@ -227,7 +229,7 @@ const find = Effect.fnUntraced(function* (options) {
 });
 // 50ms cadence bounded at ~5s, shared by stop escalation and each ensure
 // discovery window.
-const poll = Schedule.max([Schedule.spaced("50 millis"), Schedule.recurs(100)]);
+const poll = (timing) => Schedule.max([Schedule.spaced(timing.stopPollInterval), Schedule.recurs(timing.stopPollAttempts)]);
 const signal = (pid, name) => Effect.try({ try: () => process.kill(pid, name), catch: (cause) => cause }).pipe(Effect.ignore);
 const stopped = Effect.fnUntraced(function* (pid) {
     const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(Effect.orElseSucceed(() => false));
@@ -238,22 +240,22 @@ const stopped = Effect.fnUntraced(function* (pid) {
 function same(left, right) {
     return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
 }
-const evict = Effect.fnUntraced(function* (info, options) {
+const evict = Effect.fnUntraced(function* (info, options, timing) {
     const current = yield* read(options.file);
     if (current === undefined || !same(current, info))
         return;
     yield* signal(info.pid, "SIGTERM");
-    const done = yield* stopped(info.pid).pipe(Effect.retry(poll), Effect.option);
+    const done = yield* stopped(info.pid).pipe(Effect.retry(poll(timing)), Effect.option);
     if (Option.isSome(done))
         return;
     const latest = yield* read(options.file);
     if (latest === undefined || !same(latest, info))
         return;
     yield* signal(info.pid, "SIGKILL");
-    yield* stopped(info.pid).pipe(Effect.retry(poll));
+    yield* stopped(info.pid).pipe(Effect.retry(poll(timing)));
 });
-const kill = Effect.fnUntraced(function* (service, options) {
-    const requested = yield* requestStop(service);
+const kill = Effect.fnUntraced(function* (service, options, timing) {
+    const requested = yield* requestStop(service, timing.requestTimeout);
     if (requested === "rejected")
         return;
     if (requested === "unsupported") {
@@ -264,24 +266,24 @@ const kill = Effect.fnUntraced(function* (service, options) {
             return;
         yield* signal(service.info.pid, "SIGTERM");
     }
-    const done = yield* stopped(service.info.pid).pipe(Effect.retry(poll), Effect.option);
+    const done = yield* stopped(service.info.pid).pipe(Effect.retry(poll(timing)), Effect.option);
     if (Option.isSome(done))
         return;
     const latest = yield* find(options);
     if (latest === undefined || !same(latest.info, service.info))
         return;
     yield* signal(service.info.pid, "SIGKILL");
-    yield* stopped(service.info.pid).pipe(Effect.retry(poll));
+    yield* stopped(service.info.pid).pipe(Effect.retry(poll(timing)));
 });
 const decodeStopResponse = Schema.decodeUnknownOption(ServiceStatus.StopResponse);
-const requestStop = Effect.fnUntraced(function* (service) {
+const requestStop = Effect.fnUntraced(function* (service, timeout = defaultEnsureTiming.requestTimeout) {
     if (service.info.id === undefined || service.legacy)
         return "unsupported";
     const response = yield* Effect.tryPromise(() => fetch(new URL("/api/service/stop", service.info.url), {
         method: "POST",
         headers: { ...headers(service.endpoint), "content-type": "application/json" },
         body: JSON.stringify({ instanceID: service.info.id }),
-        signal: AbortSignal.timeout(2_000),
+        signal: AbortSignal.timeout(timeout),
     })).pipe(Effect.option, Effect.map(Option.getOrUndefined));
     if (response === undefined || response.status === 404 || response.status === 405)
         return "unsupported";

package/dist/promise/generated/client.js

@@ -477,6 +477,7 @@ export function make(options) {
             interrupt: (input, requestOptions) => request({
                 method: "POST",
                 path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+                query: { continue: input["continue"] },
                 successStatus: 204,
                 declaredStatuses: [404, 400, 401],
                 empty: true,

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

@@ -5433,6 +5433,9 @@ export type SessionInterruptInput = {
     readonly sessionID: {
         readonly sessionID: string;
     }["sessionID"];
+    readonly continue?: {
+        readonly continue?: boolean | undefined;
+    }["continue"];
 };
 export type SessionInterruptOutput = void;
 export type SessionBackgroundInput = {

package/dist/promise/service.js

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { defaultEnsureTiming, ensureTiming } from "../service-timing.js";
 export * from "../service.js";
 /** Discover a healthy, compatible local service without starting one. */
 export async function discover(options = {}) {
@@ -17,12 +18,13 @@ async function discoverLocal(options) {
 }
 /** Ensure a healthy, compatible local service is running. */
 export async function ensure(options = {}) {
-    const deadline = Date.now() + 120_000;
+    const timing = ensureTiming(options);
+    const deadline = Date.now() + timing.promiseTimeout;
     const contenders = new Set();
     let timeouts;
     let announced = false;
     let lastSpawn = 0;
-    let spawnDelay = 5_000;
+    let spawnDelay = timing.spawnDelay;
     const announce = (reason, previousVersion) => {
         if (announced)
             return;
@@ -49,7 +51,7 @@ export async function ensure(options = {}) {
     while (true) {
         if (Date.now() >= deadline)
             throw new Error("Timed out waiting for the background service to start");
-        const registration = await registered(options.file, true);
+        const registration = await registered(options.file, true, timing.requestTimeout);
         if (registration.timedOut && registration.info !== undefined) {
             timeouts = {
                 info: registration.info,
@@ -57,7 +59,7 @@ export async function ensure(options = {}) {
             };
             if (timeouts.count >= 3) {
                 announce("missing");
-                await evict(registration.info, options);
+                await evict(registration.info, options, timing);
                 timeouts = undefined;
                 lastSpawn = Date.now() - spawnDelay;
             }
@@ -65,7 +67,7 @@ export async function ensure(options = {}) {
         else
             timeouts = undefined;
         if (registration.service !== undefined) {
-            spawnDelay = 5_000;
+            spawnDelay = timing.spawnDelay;
             const service = registration.service;
             const compatible = !service.legacy && (options.version === undefined || service.version === options.version);
             if (compatible && service.state === "ready")
@@ -74,7 +76,7 @@ export async function ensure(options = {}) {
                 throw new Error("Background service failed to start");
             if (!compatible) {
                 announce("version-mismatch", service.version);
-                await kill(service, options).catch(() => undefined);
+                await kill(service, options, timing).catch(() => undefined);
                 lastSpawn = 0;
             }
         }
@@ -84,7 +86,7 @@ export async function ensure(options = {}) {
             const finished = [...contenders].filter(contenderFinished);
             const failure = finished.map(contenderFailure).find((error) => error !== undefined);
             if (finished.some((item) => item.child.exitCode === 0)) {
-                spawnDelay = Math.min(spawnDelay * 2, 30_000);
+                spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
             }
             finished.forEach((item) => contenders.delete(item));
             if (failure !== undefined && contenders.size === 0)
@@ -96,7 +98,7 @@ export async function ensure(options = {}) {
                 lastSpawn = Date.now();
             }
         }
-        await delay(1_000);
+        await delay(timing.pollInterval);
     }
 }
 function contenderFailure(contender) {
@@ -116,7 +118,7 @@ function contenderFinished(contender) {
 export async function stop(options = {}) {
     const existing = await find(options);
     if (existing !== undefined)
-        await kill(existing, options);
+        await kill(existing, options, defaultEnsureTiming);
 }
 function fallback() {
     return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
@@ -143,14 +145,14 @@ async function read(file) {
 async function probe(info, allowLegacy = false) {
     return (await probeResult(info, allowLegacy)).service;
 }
-async function probeResult(info, allowLegacy = false) {
+async function probeResult(info, allowLegacy = false, timeout = defaultEnsureTiming.requestTimeout) {
     const endpoint = {
         url: info.url,
         auth: info.password === undefined
             ? undefined
             : { type: "basic", username: "opencode", password: info.password },
     };
-    const signal = AbortSignal.timeout(2_000);
+    const signal = AbortSignal.timeout(timeout);
     const result = await fetch(new URL("/api/health", info.url), {
         headers: headers(endpoint),
         signal,
@@ -187,11 +189,11 @@ async function probeResult(info, allowLegacy = false) {
         timedOut: false,
     };
 }
-async function registered(file, allowLegacy = false) {
+async function registered(file, allowLegacy = false, timeout) {
     const info = await read(file);
     if (info === undefined)
         return { info: undefined, service: undefined, timedOut: false };
-    return { info, ...(await probeResult(info, allowLegacy)) };
+    return { info, ...(await probeResult(info, allowLegacy, timeout)) };
 }
 async function find(options) {
     return (await registered(options.file, true)).service;
@@ -211,34 +213,34 @@ function stopped(pid) {
         return true;
     }
 }
-async function waitUntilStopped(pid) {
-    for (let attempt = 0; attempt <= 100; attempt++) {
+async function waitUntilStopped(pid, timing) {
+    for (let attempt = 0; attempt <= timing.stopPollAttempts; attempt++) {
         if (stopped(pid))
             return true;
-        if (attempt < 100)
-            await delay(50);
+        if (attempt < timing.stopPollAttempts)
+            await delay(timing.stopPollInterval);
     }
     return false;
 }
 function same(left, right) {
     return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
 }
-async function evict(info, options) {
+async function evict(info, options, timing) {
     const current = await read(options.file);
     if (current === undefined || !same(current, info))
         return;
     signal(info.pid, "SIGTERM");
-    if (await waitUntilStopped(info.pid))
+    if (await waitUntilStopped(info.pid, timing))
         return;
     const latest = await read(options.file);
     if (latest === undefined || !same(latest, info))
         return;
     signal(info.pid, "SIGKILL");
-    if (!(await waitUntilStopped(info.pid)))
+    if (!(await waitUntilStopped(info.pid, timing)))
         throw new Error(`Server process ${info.pid} is still running`);
 }
-async function kill(service, options) {
-    const requested = await requestStop(service);
+async function kill(service, options, timing) {
+    const requested = await requestStop(service, timing.requestTimeout);
     if (requested === "rejected")
         return;
     if (requested === "unsupported") {
@@ -247,23 +249,23 @@ async function kill(service, options) {
             return;
         signal(service.info.pid, "SIGTERM");
     }
-    if (await waitUntilStopped(service.info.pid))
+    if (await waitUntilStopped(service.info.pid, timing))
         return;
     const latest = await find(options);
     if (latest === undefined || !same(latest.info, service.info))
         return;
     signal(service.info.pid, "SIGKILL");
-    if (!(await waitUntilStopped(service.info.pid)))
+    if (!(await waitUntilStopped(service.info.pid, timing)))
         throw new Error(`Server process ${service.info.pid} is still running`);
 }
-async function requestStop(service) {
+async function requestStop(service, timeout = defaultEnsureTiming.requestTimeout) {
     if (service.info.id === undefined || service.legacy)
         return "unsupported";
     const response = await fetch(new URL("/api/service/stop", service.info.url), {
         method: "POST",
         headers: { ...headers(service.endpoint), "content-type": "application/json" },
         body: JSON.stringify({ instanceID: service.info.id }),
-        signal: AbortSignal.timeout(2_000),
+        signal: AbortSignal.timeout(timeout),
     }).catch(() => undefined);
     if (response === undefined || response.status === 404 || response.status === 405)
         return "unsupported";

package/dist/service-timing.d.ts

@@ -0,0 +1,13 @@
+export type EnsureTiming = {
+    readonly pollInterval: number;
+    readonly attempts: number;
+    readonly requestTimeout: number;
+    readonly spawnDelay: number;
+    readonly maxSpawnDelay: number;
+    readonly promiseTimeout: number;
+    readonly stopPollInterval: number;
+    readonly stopPollAttempts: number;
+};
+export declare const defaultEnsureTiming: EnsureTiming;
+export declare function ensureTiming(options: object): EnsureTiming;
+export declare function withEnsureTiming<A extends object>(options: A, overrides: Partial<EnsureTiming>): A;

package/dist/service-timing.js

@@ -0,0 +1,19 @@
+const timings = new WeakMap();
+export const defaultEnsureTiming = {
+    pollInterval: 1_000,
+    attempts: 120,
+    requestTimeout: 2_000,
+    spawnDelay: 5_000,
+    maxSpawnDelay: 30_000,
+    promiseTimeout: 120_000,
+    stopPollInterval: 50,
+    stopPollAttempts: 100,
+};
+export function ensureTiming(options) {
+    return timings.get(options) ?? defaultEnsureTiming;
+}
+// Keep test timing out of the public lifecycle option types.
+export function withEnsureTiming(options, overrides) {
+    timings.set(options, { ...defaultEnsureTiming, ...overrides });
+    return options;
+}

package/package.json

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