@usepipa/pipa 0.5.6 → 0.6.0-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,503 @@
1
+ import { OpenCode } from "@opencode/client";
2
+ import { randomUUID } from "node:crypto";
3
+ import path from "node:path";
4
+ import { setTimeout as delay } from "node:timers/promises";
5
+
6
+ export function createV2Adapter(options) {
7
+ const observers = new Map();
8
+ const controllers = new Set();
9
+ let events;
10
+ let eventTask;
11
+ let connected = false;
12
+ let stopped;
13
+ let stopping = [];
14
+ const client = OpenCode.make({ baseUrl: options.baseUrl, headers: options.headers, fetch: async (url, init) => {
15
+ const pathname = new URL(url).pathname;
16
+ const streaming = pathname === "/api/event";
17
+ const modelRead = (init.method ?? "GET").toUpperCase() === "GET" && ["/api/model", "/api/model/default"].includes(pathname);
18
+ const signal = streaming ? init.signal : AbortSignal.any([...(init.signal ? [init.signal] : []), AbortSignal.timeout(options.connectionRequestTimeoutMs ?? (modelRead ? 30_000 : 5_000))]);
19
+ const response = await options.fetch(url, { ...init, signal });
20
+ if (!response.body || streaming) return response;
21
+ const reader = response.body.getReader();
22
+ let abort;
23
+ return new Response(new ReadableStream({
24
+ start(controller) {
25
+ abort = () => {
26
+ controller.error(signal.reason);
27
+ void reader.cancel(signal.reason).catch(() => undefined);
28
+ };
29
+ if (signal.aborted) abort();
30
+ else signal.addEventListener("abort", abort, { once: true });
31
+ },
32
+ async pull(controller) {
33
+ try {
34
+ const next = await reader.read();
35
+ signal.throwIfAborted();
36
+ if (next.done) {
37
+ signal.removeEventListener("abort", abort);
38
+ reader.releaseLock();
39
+ controller.close();
40
+ } else controller.enqueue(next.value);
41
+ } catch (error) {
42
+ signal.removeEventListener("abort", abort);
43
+ controller.error(error);
44
+ }
45
+ },
46
+ cancel(reason) {
47
+ signal.removeEventListener("abort", abort);
48
+ void reader.cancel(reason).catch(() => undefined);
49
+ },
50
+ }), { status: response.status, statusText: response.statusText, headers: response.headers });
51
+ } });
52
+
53
+ async function readWithRecovery(operation, signal) {
54
+ const start = Date.now();
55
+ while (true) {
56
+ signal?.throwIfAborted();
57
+ try { return await operation(signal); }
58
+ catch (error) {
59
+ signal?.throwIfAborted();
60
+ if (!retryable(error) || Date.now() - start >= (options.connectionRecoveryTimeoutMs ?? 10_000)) throw error;
61
+ await delay(options.pollIntervalMs ?? 100, undefined, { signal });
62
+ }
63
+ }
64
+ }
65
+
66
+ async function lookup(sessionId, workingDirectory, signal) {
67
+ let session;
68
+ try { session = await readWithRecovery((signal) => client.session.get({ sessionID: sessionId }, { signal }), signal); }
69
+ catch (error) {
70
+ if (error._tag === "SessionNotFoundError" && error.sessionID === sessionId) return null;
71
+ throw error;
72
+ }
73
+ if (session?.id !== sessionId || typeof session.location?.directory !== "string"
74
+ || path.resolve(session.location.directory) !== path.resolve(workingDirectory)) throw new Error("OpenCode session workspace identity mismatch.");
75
+ return session;
76
+ }
77
+
78
+ async function listModels(workingDirectory, signal) {
79
+ const input = { location: { directory: workingDirectory } };
80
+ const [catalog, defaults] = await readWithRecovery((signal) => Promise.all([
81
+ client.model.list(input, { signal }), client.model.default(input, { signal }),
82
+ ]), signal);
83
+ for (const snapshot of [catalog, defaults]) {
84
+ if (typeof snapshot?.location?.directory !== "string" || path.resolve(snapshot.location.directory) !== path.resolve(workingDirectory)) throw new Error("OpenCode model workspace identity mismatch.");
85
+ }
86
+ if (!Array.isArray(catalog.data) || catalog.data.some((model) => !model || typeof model.id !== "string" || !model.id
87
+ || typeof model.providerID !== "string" || !model.providerID || typeof model.name !== "string" || typeof model.enabled !== "boolean"
88
+ || !Array.isArray(model.variants) || model.variants.some((variant) => typeof variant?.id !== "string" || !variant.id))) throw new Error("OpenCode returned an invalid model catalog.");
89
+ const models = catalog.data.filter((model) => model.enabled).map((model) => ({
90
+ providerID: model.providerID, id: model.id, name: model.name, variants: [...new Set(["default", ...model.variants.map((variant) => variant.id)])],
91
+ }));
92
+ const selected = defaults.data;
93
+ if (selected !== null && (!selected || typeof selected.providerID !== "string" || typeof selected.id !== "string")) throw new Error("OpenCode returned an invalid default model.");
94
+ const defaultModel = selected && models.find((model) => model.providerID === selected.providerID && model.id === selected.id);
95
+ return { models, defaultModel: defaultModel ? { providerID: defaultModel.providerID, id: defaultModel.id, variant: "default" } : null };
96
+ }
97
+
98
+ function settleWaiters(observer, value, error) {
99
+ for (const waiter of observer.waiters) {
100
+ if (error) waiter.reject(error);
101
+ else waiter.resolve(value);
102
+ }
103
+ }
104
+
105
+ async function report(observer, error) {
106
+ await observer.onError?.(error, observer.controller.signal);
107
+ settleWaiters(observer, undefined, error);
108
+ }
109
+
110
+ function detach(observer, reason = new Error("OpenCode observer stopped.")) {
111
+ observer.controller.abort(reason);
112
+ observer.initialized.reject(reason);
113
+ settleWaiters(observer, undefined, reason);
114
+ for (const entry of observer.interactions.values()) entry.settled.resolve();
115
+ if (observers.get(observer.sessionId) === observer) observers.delete(observer.sessionId);
116
+ if (!observers.size) events?.abort(reason);
117
+ }
118
+
119
+ async function belongs(observer, candidate) {
120
+ const original = candidate;
121
+ const visited = new Set();
122
+ while (candidate && !visited.has(candidate)) {
123
+ visited.add(candidate);
124
+ let session;
125
+ try { session = await client.session.get({ sessionID: candidate }, { signal: observer.controller.signal }); }
126
+ catch (error) { if (error._tag === "SessionNotFoundError") return false; throw error; }
127
+ if (session?.id !== candidate || typeof session.location?.directory !== "string"
128
+ || path.resolve(session.location.directory) !== path.resolve(observer.workingDirectory)) return false;
129
+ if (candidate === observer.sessionId) { observer.interactionSessions.add(original); return true; }
130
+ candidate = session.parentID;
131
+ }
132
+ return false;
133
+ }
134
+
135
+ async function pending(observer, entry) {
136
+ const signal = observer.controller.signal;
137
+ if (entry.kind === "permission") return (await client.permission.list({ sessionID: entry.request.sessionID }, { signal })).some((item) => item.id === entry.request.id);
138
+ try { return (await client.session.form.get({ sessionID: entry.request.sessionID, formID: entry.request.id }, { signal })).state.status === "pending"; }
139
+ catch (error) { if (error._tag === "FormNotFoundError") return false; throw error; }
140
+ }
141
+
142
+ function settle(entry) {
143
+ if (entry.accepted || entry.external) return;
144
+ entry.external = true;
145
+ entry.settled.resolve();
146
+ }
147
+
148
+ async function dispatch(observer, kind, request) {
149
+ const signal = observer.controller.signal;
150
+ const revision = observer.interactionRevision;
151
+ const key = `${kind}:${request.sessionID}:${request.id}`;
152
+ if (!observer.onInteraction || observer.interactions.has(key) || !await belongs(observer, request.sessionID)) return;
153
+ if (observer.interactions.has(key) || signal.aborted || revision !== observer.interactionRevision) return;
154
+ const fields = request.fields;
155
+ const question = kind === "form" && request.metadata?.kind === "question" && Array.isArray(fields) && fields.length
156
+ && fields.every((field, index) => field.key === `q${index}` && ["string", "multiselect"].includes(field.type) && !field.hidden && !field.when?.length);
157
+ const type = kind === "permission" ? "permission" : question ? "question" : "form";
158
+ let tool;
159
+ if (kind === "permission" && request.source?.type === "tool") {
160
+ try {
161
+ const message = await client.session.message.get({ sessionID: request.sessionID, messageID: request.source.messageID }, { signal });
162
+ const part = message.content?.find((part) => part.type === "tool" && part.id === request.source.id);
163
+ if (part) tool = { name: part.name, input: part.state?.input };
164
+ } catch (error) { if (error._tag !== "MessageNotFoundError") throw error; }
165
+ }
166
+ if (observer.interactions.has(key) || signal.aborted || revision !== observer.interactionRevision) return;
167
+ const normalized = question ? { ...request, questions: fields.map((field) => ({
168
+ header: field.title || request.title, question: field.description || field.title || request.title,
169
+ multiple: field.type === "multiselect", custom: field.custom ?? !field.options?.length,
170
+ options: field.options?.map((option) => ({ label: option.label, description: option.description })),
171
+ })) } : tool ? { ...request, tool } : request;
172
+ const entry = { kind, request, settled: Promise.withResolvers() };
173
+ observer.interactions.set(key, entry);
174
+ const submitDecision = async (decision) => {
175
+ if (entry.accepted) return;
176
+ if (entry.external) throw new Error("OpenCode request is already settled.");
177
+ if (type === "form") throw new Error("This form requires an OpenCode client response.");
178
+ signal.throwIfAborted();
179
+ entry.submitting = true;
180
+ const native = { sessionID: request.sessionID, ...(kind === "form" ? { formID: request.id } : { requestID: request.id }) };
181
+ try {
182
+ if (!await pending(observer, entry)) { settle(entry); throw new Error("OpenCode request is already settled."); }
183
+ try {
184
+ if (kind === "permission") {
185
+ const value = ["reject", "stop"].includes(decision?.type) ? "reject" : decision?.type === "reply" ? decision.reply : null;
186
+ if (!["once", "always", "reject"].includes(value)) throw new Error("Invalid OpenCode permission decision.");
187
+ await client.permission.reply({ ...native, decision: value }, { signal });
188
+ } else if (["reject", "stop"].includes(decision?.type)) {
189
+ await client.session.form.cancel(native, { signal });
190
+ } else if (question && decision?.type === "answer") {
191
+ if (!Array.isArray(decision.answers) || decision.answers.length !== fields.length) throw new Error("Invalid OpenCode question answers.");
192
+ const answer = Object.fromEntries(fields.map((field, index) => {
193
+ const values = decision.answers[index];
194
+ if (!Array.isArray(values) || !values.every((value) => typeof value === "string") || (field.type === "string" && values.length !== 1)) throw new Error("Invalid OpenCode question answer.");
195
+ const encoded = values.map((value) => field.options?.find((option) => option.label === value)?.value ?? value);
196
+ return [field.key, field.type === "multiselect" ? encoded : encoded[0]];
197
+ }));
198
+ await client.session.form.reply({ ...native, answer }, { signal });
199
+ } else throw new Error("This form requires an OpenCode client response.");
200
+ } catch (error) {
201
+ signal.throwIfAborted();
202
+ if (retryable(error) || error.reason === "MalformedResponse" || ["FormAlreadySettledError", "FormNotFoundError", "PermissionNotFoundError"].includes(error._tag)) {
203
+ if (!await pending(observer, entry)) { settle(entry); return; }
204
+ else throw error;
205
+ } else throw error;
206
+ }
207
+ entry.accepted = true;
208
+ // Native rejection/cancellation need not produce an idle event.
209
+ if (decision.type === "stop") {
210
+ try { await client.session.interrupt({ sessionID: request.sessionID, resume: false }, { signal }); }
211
+ finally { settleWaiters(observer, ""); }
212
+ } else if (decision.type === "reject" || decision.reply === "reject") settleWaiters(observer, "Stopped after a request was rejected.");
213
+ } finally { entry.submitting = false; }
214
+ };
215
+ const submit = (decision) => {
216
+ if (entry.submitting) return Promise.reject(new Error("OpenCode response is already being submitted."));
217
+ const submission = submitDecision(decision);
218
+ observer.handlers.add(submission);
219
+ void submission.then(() => observer.handlers.delete(submission), () => observer.handlers.delete(submission));
220
+ return submission;
221
+ };
222
+ const handler = Promise.resolve().then(() => {
223
+ signal.throwIfAborted();
224
+ return observer.onInteraction({ type, request: normalized, sessionId: request.sessionID, signal, submit, settled: entry.settled.promise });
225
+ })
226
+ .then(async (decision) => {
227
+ if (!entry.accepted && !entry.external && !signal.aborted && !["cancelled", "stopped"].includes(decision?.type)) await submit(decision);
228
+ }).catch(() => { if (!signal.aborted) process.stderr.write("OpenCode interaction handler failed.\n"); });
229
+ observer.handlers.add(handler);
230
+ void handler.finally(() => observer.handlers.delete(handler));
231
+ }
232
+
233
+ function reconcile(observer) {
234
+ observer.reconciliation = (observer.reconciliation ?? Promise.resolve()).catch(() => undefined).then(() => reconcilePending(observer));
235
+ return observer.reconciliation;
236
+ }
237
+
238
+ async function reconcilePending(observer) {
239
+ if (!observer.onInteraction && !observer.onPermissionsReconciled) return;
240
+ const signal = observer.controller.signal;
241
+ const revision = observer.interactionRevision;
242
+ const input = { location: { directory: observer.workingDirectory } };
243
+ const snapshots = await readWithRecovery((signal) => Promise.all([client.form.list(input, { signal }), client.permission.request.list(input, { signal })]), signal);
244
+ if (revision !== observer.interactionRevision) return;
245
+ for (const [index, snapshot] of snapshots.entries()) {
246
+ if (revision !== observer.interactionRevision) return;
247
+ if (path.resolve(snapshot.location?.directory ?? "") !== path.resolve(observer.workingDirectory) || !Array.isArray(snapshot.data)) throw new Error("OpenCode returned invalid interaction location projections.");
248
+ const kind = index === 0 ? "form" : "permission";
249
+ for (const request of snapshot.data) await dispatch(observer, kind, request);
250
+ if (revision !== observer.interactionRevision) return;
251
+ for (const [key, entry] of observer.interactions) {
252
+ if (entry.kind === kind && !entry.submitting && !snapshot.data.some((request) => request.id === entry.request.id && request.sessionID === entry.request.sessionID)) {
253
+ settle(entry);
254
+ observer.interactions.delete(key);
255
+ }
256
+ }
257
+ if (kind === "permission" && observer.onPermissionsReconciled) {
258
+ const scoped = [];
259
+ for (const request of snapshot.data) if (await belongs(observer, request.sessionID)) scoped.push(request);
260
+ for (const sessionId of observer.interactionSessions) await observer.onPermissionsReconciled({ sessionId, requestIds: new Set(scoped.filter((request) => request.sessionID === sessionId).map((request) => request.id)) });
261
+ }
262
+ }
263
+ }
264
+
265
+ // Native 2.2.5's experimental session log emits no responses; forward live events only.
266
+ function watchEvents() {
267
+ if (events && !events.signal.aborted) return;
268
+ events = new AbortController();
269
+ connected = false;
270
+ const signal = events.signal;
271
+ eventTask = (async () => {
272
+ while (!signal.aborted) {
273
+ try {
274
+ for await (const event of client.event.subscribe({ signal })) {
275
+ if (event.type === "server.connected") {
276
+ connected = true;
277
+ for (const observer of observers.values()) {
278
+ queueResponse(observer, async () => {
279
+ if (!await lookup(observer.sessionId, observer.workingDirectory, observer.controller.signal)) throw new Error("OpenCode session is unavailable.");
280
+ observer.initialized.resolve();
281
+ }, true);
282
+ void reconcile(observer).catch(() => undefined);
283
+ }
284
+ continue;
285
+ }
286
+ for (const observer of observers.values()) {
287
+ if (event.location && path.resolve(event.location.directory ?? "") !== path.resolve(observer.workingDirectory)) continue;
288
+ if (event.data?.sessionID === observer.sessionId) {
289
+ if (event.type === "session.step.ended" && event.data.finish === "stop") queueResponse(observer, async () => {
290
+ const message = await readWithRecovery((signal) => client.session.message.get({ sessionID: observer.sessionId, messageID: event.data.assistantMessageID }, { signal }), observer.controller.signal);
291
+ await deliverResponse(observer, message);
292
+ });
293
+ if (event.type === "session.execution.failed") queueResponse(observer, () => report(observer, executionError(event.data.error)));
294
+ if (event.type === "session.execution.interrupted") settleWaiters(observer, "");
295
+ if (event.type === "session.tool.called") void reconcile(observer).catch(() => undefined);
296
+ }
297
+ if (!["form.created", "permission.asked", "form.replied", "form.cancelled", "permission.replied", "location.shutdown"].includes(event.type)) continue;
298
+ observer.interactionTask = (observer.interactionTask ?? Promise.resolve()).then(async () => {
299
+ if (observer.controller.signal.aborted) return;
300
+ if (event.type === "form.created") await dispatch(observer, "form", event.data.form);
301
+ if (event.type === "permission.asked") await dispatch(observer, "permission", event.data);
302
+ if (event.type === "permission.replied" && await belongs(observer, event.data.sessionID)) {
303
+ const key = `${event.data.sessionID}:${event.data.requestID}`;
304
+ if (!observer.replied.has(key)) {
305
+ await observer.onPermissionReplied?.({ sessionId: event.data.sessionID, requestId: event.data.requestID, reply: event.data.reply });
306
+ observer.replied.add(key);
307
+ }
308
+ }
309
+ if (["form.replied", "form.cancelled", "permission.replied", "location.shutdown"].includes(event.type)) {
310
+ observer.interactionRevision++;
311
+ const kind = event.type.startsWith("form.") ? "form" : "permission";
312
+ const id = kind === "form" ? event.data?.id : event.data?.requestID;
313
+ const entry = observer.interactions.get(`${kind}:${event.data?.sessionID}:${id}`);
314
+ if (entry && !entry.submitting) settle(entry);
315
+ await reconcile(observer);
316
+ }
317
+ }).catch(() => { if (!observer.controller.signal.aborted) process.stderr.write("OpenCode interaction event failed.\n"); });
318
+ }
319
+ }
320
+ } catch { if (signal.aborted) return; }
321
+ connected = false;
322
+ await delay(options.pollIntervalMs ?? 100, undefined, { signal }).catch(() => undefined);
323
+ }
324
+ })();
325
+ }
326
+
327
+ function queueResponse(observer, operation, fatal = false) {
328
+ observer.task = (observer.task ?? Promise.resolve()).then(async () => {
329
+ const signal = observer.controller.signal;
330
+ if (signal.aborted) return;
331
+ try { await operation(); }
332
+ catch {
333
+ if (signal.aborted) return;
334
+ if (fatal) {
335
+ const safe = new Error("OpenCode session responses are unavailable.");
336
+ observer.initialized.reject(safe);
337
+ await report(observer, safe).catch(() => undefined);
338
+ detach(observer, safe);
339
+ return;
340
+ }
341
+ const safe = new Error("OpenCode response could not be delivered; it will not be replayed.");
342
+ await report(observer, safe).catch(() => process.stderr.write("Pipa could not deliver an OpenCode response.\n"));
343
+ }
344
+ });
345
+ }
346
+
347
+ async function deliverResponse(observer, message) {
348
+ if (observer.controller.signal.aborted || observer.delivered.has(message.id)) return;
349
+ if (message.type !== "assistant" || message.finish !== "stop" || typeof message.time?.completed !== "number") return;
350
+ if (!Array.isArray(message.content)) throw new Error("OpenCode returned an invalid assistant message.");
351
+ const text = message.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
352
+ // A failed Slack post may have sent earlier chunks; never replay the whole response.
353
+ observer.delivered.add(message.id);
354
+ if (text) {
355
+ await observer.onResponse?.(text, message.id, observer.controller.signal);
356
+ }
357
+ settleWaiters(observer, text);
358
+ }
359
+
360
+ async function follow(input, persistent, waiter) {
361
+ if (stopped) throw stopped;
362
+ if (typeof input.sessionId !== "string" || !input.sessionId || typeof input.workingDirectory !== "string" || !input.workingDirectory) throw new Error("Invalid OpenCode session context.");
363
+ let observer = observers.get(input.sessionId);
364
+ const created = !observer;
365
+ if (!observer) {
366
+ observer = { sessionId: input.sessionId, workingDirectory: input.workingDirectory, controller: new AbortController(), initialized: Promise.withResolvers(), delivered: new Set(), replied: new Set(), waiters: new Set(), handlers: new Set(), interactions: new Map(), interactionSessions: new Set([input.sessionId]), interactionRevision: 0, persistent };
367
+ observers.set(input.sessionId, observer);
368
+ // Observe rejection immediately, including shutdown during initial attachment.
369
+ void observer.initialized.promise.catch(() => undefined);
370
+ observer.registration = (async () => {
371
+ const signal = observer.controller.signal;
372
+ if (!await lookup(input.sessionId, input.workingDirectory, signal)) throw new Error("OpenCode session is unavailable.");
373
+ try {
374
+ const entries = await client.session.instructions.entry.list({ sessionID: input.sessionId }, { signal });
375
+ observer.instructions = entries.find((entry) => entry.key === "pipa.slack")?.value;
376
+ await Promise.all(entries.filter((entry) => /^pipa-[a-f0-9]{16}-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u.test(entry.key)).map((entry) => client.session.instructions.entry.remove({ sessionID: input.sessionId, key: entry.key }, { signal })));
377
+ } catch { signal.throwIfAborted(); /* Old context migration is best effort and session-local. */ }
378
+ watchEvents();
379
+ if (connected) observer.initialized.resolve();
380
+ const timer = setTimeout(() => observer.initialized.reject(new Error("OpenCode event attachment timed out.")), options.connectionRecoveryTimeoutMs ?? 10_000);
381
+ try { await observer.initialized.promise; } finally { clearTimeout(timer); }
382
+ })();
383
+ }
384
+ if (path.resolve(observer.workingDirectory) !== path.resolve(input.workingDirectory)) throw new Error("OpenCode session workspace identity mismatch.");
385
+ if (waiter) observer.waiters.add(waiter);
386
+ observer.persistent ||= persistent;
387
+ for (const key of ["onResponse", "onError", "onInteraction", "onPermissionReplied", "onPermissionsReconciled"]) if (input[key] !== undefined) observer[key] = input[key];
388
+ try {
389
+ await observer.registration;
390
+ observer.contextUpdate = (observer.contextUpdate ?? Promise.resolve()).catch(() => undefined).then(async () => {
391
+ if (input.instructions !== undefined && observer.instructions !== input.instructions) {
392
+ await client.session.instructions.entry.put({ sessionID: input.sessionId, key: "pipa.slack", value: input.instructions }, { signal: observer.controller.signal });
393
+ observer.instructions = input.instructions;
394
+ }
395
+ });
396
+ await observer.contextUpdate;
397
+ if (observer.onInteraction || observer.onPermissionReplied || observer.onPermissionsReconciled) {
398
+ watchEvents();
399
+ await reconcile(observer).catch(() => undefined);
400
+ }
401
+ return observer;
402
+ } catch (error) { if (created) detach(observer, error); throw error; }
403
+ }
404
+
405
+ return {
406
+ async ready(workingDirectory) { if (stopped) throw stopped; },
407
+ listModels,
408
+ async switchModel(sessionId, model, workingDirectory, signal) {
409
+ if (typeof sessionId !== "string" || !sessionId) throw new Error("Invalid OpenCode session ID.");
410
+ if (model !== null && (!model || typeof model.providerID !== "string" || !model.providerID || typeof model.id !== "string" || !model.id
411
+ || (model.variant !== undefined && (typeof model.variant !== "string" || !model.variant)))) throw new Error("Invalid OpenCode model selection.");
412
+ const catalog = await listModels(workingDirectory, signal);
413
+ const selection = model === null ? catalog.defaultModel : { providerID: model.providerID, id: model.id, variant: model.variant ?? "default" };
414
+ const available = selection && catalog.models.find((item) => item.providerID === selection.providerID && item.id === selection.id);
415
+ if (!available || !available.variants.includes(selection.variant)) throw new Error("OpenCode model or variant is unavailable.");
416
+ if (!await lookup(sessionId, workingDirectory, signal)) throw new Error("OpenCode session is unavailable; model selection did not create a replacement.");
417
+ signal.throwIfAborted();
418
+ await client.session.switchModel({ sessionID: sessionId, model: selection }, { signal });
419
+ },
420
+ async resolveSession(sessionId, workingDirectory, controller) {
421
+ const signal = controller.signal;
422
+ let session = sessionId ? await lookup(sessionId, workingDirectory, signal) : null;
423
+ const created = !session;
424
+ if (!session) {
425
+ session = await client.session.create({ location: { directory: workingDirectory } }, { signal });
426
+ if (typeof session?.id !== "string" || session.location?.directory !== workingDirectory) throw new Error("OpenCode did not create a session in the configured workspace.");
427
+ }
428
+ const history = !created && !session.model ? await readWithRecovery((signal) => client.message.list({ sessionID: session.id, limit: 1 }, { signal }), signal) : null;
429
+ if (history && !Array.isArray(history.data)) throw new Error("OpenCode returned an invalid message projection.");
430
+ return { sessionId: session.id, defaultEligible: !session.model && (created || !history.data.length) };
431
+ },
432
+ async followSession(input) { await follow(input, true); },
433
+ async execute(input) {
434
+ const signal = input.controller.signal;
435
+ signal.throwIfAborted();
436
+ controllers.add(input.controller);
437
+ const waiter = input.onResponse ? null : Promise.withResolvers();
438
+ if (waiter) void waiter.promise.catch(() => undefined);
439
+ const cancelled = Promise.withResolvers();
440
+ void cancelled.promise.catch(() => undefined);
441
+ let observer;
442
+ const abort = () => {
443
+ cancelled.reject(signal.reason);
444
+ if (waiter) waiter.reject(signal.reason);
445
+ const current = observer ?? observers.get(input.sessionId);
446
+ if (current && !current.persistent && current.waiters.size <= 1) detach(current, signal.reason);
447
+ };
448
+ signal.addEventListener("abort", abort, { once: true });
449
+ try {
450
+ observer = await Promise.race([follow(input, Boolean(input.onResponse), waiter), cancelled.promise]);
451
+ signal.throwIfAborted();
452
+ const selected = input.model ?? (input.defaultEligible ? input.defaultModel : null);
453
+ if (selected) await client.session.switchModel({ sessionID: input.sessionId, model: { providerID: selected.providerID, id: selected.modelID ?? selected.id, variant: selected.variant ?? "default" } }, { signal });
454
+ const id = options.inputId?.() ?? `msg_${randomUUID().replaceAll("-", "")}`;
455
+ const admitted = await client.session.prompt({ sessionID: input.sessionId, id, text: input.prompt,
456
+ ...(input.files?.length ? { files: input.files.map((file) => ({ uri: file.url, name: file.filename })) } : {}),
457
+ }, { signal });
458
+ if (admitted?.id !== id || admitted.sessionID !== input.sessionId || admitted.type !== "user" || admitted.payload?.text !== input.prompt) throw new Error("OpenCode returned an invalid prompt admission.");
459
+ if (input.onResponse) return { pending: true };
460
+ return await waiter.promise;
461
+ } catch (error) {
462
+ if (signal.aborted) throw signal.reason;
463
+ throw error;
464
+ } finally {
465
+ controllers.delete(input.controller);
466
+ signal.removeEventListener("abort", abort);
467
+ if (waiter) observer?.waiters.delete(waiter);
468
+ if (observer && !observer.persistent && !observer.waiters.size) detach(observer);
469
+ }
470
+ },
471
+ async abortTurn(sessionId) {
472
+ const observer = observers.get(sessionId);
473
+ if (observer) settleWaiters(observer, "");
474
+ await client.session.interrupt({ sessionID: sessionId, resume: false });
475
+ },
476
+ stopAll(reason = new Error("OpenCode bridge stopped.")) {
477
+ stopped = reason;
478
+ const current = [...observers.values()];
479
+ stopping = [...stopping, eventTask, ...current.flatMap((observer) => [observer.task, observer.interactionTask, observer.registration, observer.contextUpdate, observer.reconciliation, ...observer.handlers])];
480
+ for (const controller of controllers) controller.abort(reason);
481
+ for (const observer of current) detach(observer, reason);
482
+ events?.abort(reason);
483
+ },
484
+ async drain() { await Promise.allSettled(stopping); },
485
+ };
486
+ }
487
+
488
+ function retryable(error) {
489
+ return error.reason === "Transport" || (error.reason === "UnexpectedStatus" && [502, 503, 504].includes(error.cause?.status));
490
+ }
491
+
492
+ function executionError(error) {
493
+ const status = error?.status;
494
+ const http = Number.isInteger(status) && status >= 400 && status <= 599 ? ` (HTTP ${status})` : "";
495
+ // Classify native structured errors; provider messages/bodies can contain credentials.
496
+ if (status === 401 || error?.type === "provider.auth") {
497
+ const expired = status === 401 && typeof error.message === "string" && /\bAPI key (?:has )?expired\b/iu.test(error.message);
498
+ return new Error(expired
499
+ ? "OpenCode selected provider API key has expired. Replace that provider's API key in OpenCode, or choose another provider with your installation's model command, then start a new thread."
500
+ : `OpenCode selected provider authentication failed${http}. Reconnect that provider in OpenCode, or choose another provider with your installation's model command, then start a new thread.`);
501
+ }
502
+ return new Error(`OpenCode selected provider ${http ? `failed${http}` : "failed to complete the turn"}.`);
503
+ }