@usepipa/pipa 0.6.0-beta.2 → 0.6.0-beta.4

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.
@@ -1,6 +1,5 @@
1
1
  import { OpenCode } from "@opencode/client";
2
2
  import { randomUUID } from "node:crypto";
3
- import path from "node:path";
4
3
  import { setTimeout as delay } from "node:timers/promises";
5
4
 
6
5
  export function createV2Adapter(options) {
@@ -11,88 +10,30 @@ export function createV2Adapter(options) {
11
10
  let connected = false;
12
11
  let stopped;
13
12
  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
- } });
13
+ const client = OpenCode.make({ baseUrl: options.baseUrl, headers: options.headers, fetch: options.fetch });
52
14
 
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) {
15
+ async function lookup(sessionId, signal) {
67
16
  let session;
68
- try { session = await readWithRecovery((signal) => client.session.get({ sessionID: sessionId }, { signal }), signal); }
17
+ try { session = await client.session.get({ sessionID: sessionId }, { signal }); }
69
18
  catch (error) {
70
19
  if (error._tag === "SessionNotFoundError" && error.sessionID === sessionId) return null;
71
20
  throw error;
72
21
  }
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.");
22
+ if (session?.id !== sessionId) throw new Error("OpenCode session identity mismatch.");
75
23
  return session;
76
24
  }
77
25
 
78
26
  async function listModels(workingDirectory, signal) {
79
27
  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)])],
28
+ const catalog = await client.model.list(input, { signal });
29
+ if (!Array.isArray(catalog.data)) throw new Error("OpenCode returned an invalid model catalog.");
30
+ const enabled = catalog.data.filter((model) => model?.enabled);
31
+ if (enabled.some((model) => typeof model.id !== "string" || !model.id
32
+ || typeof model.providerID !== "string" || !model.providerID)) throw new Error("OpenCode returned an invalid model catalog.");
33
+ const models = enabled.map((model) => ({
34
+ providerID: model.providerID, id: model.id, name: model.name,
91
35
  }));
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 };
36
+ return { models };
96
37
  }
97
38
 
98
39
  function settleWaiters(observer, value, error) {
@@ -117,16 +58,14 @@ export function createV2Adapter(options) {
117
58
  }
118
59
 
119
60
  async function belongs(observer, candidate) {
120
- const original = candidate;
121
61
  const visited = new Set();
122
62
  while (candidate && !visited.has(candidate)) {
123
63
  visited.add(candidate);
124
64
  let session;
125
65
  try { session = await client.session.get({ sessionID: candidate }, { signal: observer.controller.signal }); }
126
66
  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; }
67
+ if (session?.id !== candidate) return false;
68
+ if (candidate === observer.sessionId) return true;
130
69
  candidate = session.parentID;
131
70
  }
132
71
  return false;
@@ -152,8 +91,8 @@ export function createV2Adapter(options) {
152
91
  if (!observer.onInteraction || observer.interactions.has(key) || !await belongs(observer, request.sessionID)) return;
153
92
  if (observer.interactions.has(key) || signal.aborted || revision !== observer.interactionRevision) return;
154
93
  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);
94
+ const question = kind === "form" && Array.isArray(fields) && fields.length
95
+ && fields.every((field) => ["string", "multiselect"].includes(field.type) && !field.hidden && !field.when?.length);
157
96
  const type = kind === "permission" ? "permission" : question ? "question" : "form";
158
97
  let tool;
159
98
  if (kind === "permission" && request.source?.type === "tool") {
@@ -167,7 +106,8 @@ export function createV2Adapter(options) {
167
106
  const normalized = question ? { ...request, questions: fields.map((field) => ({
168
107
  header: field.title || request.title, question: field.description || field.title || request.title,
169
108
  multiple: field.type === "multiselect", custom: field.custom ?? !field.options?.length,
170
- options: field.options?.map((option) => ({ label: option.label, description: option.description })),
109
+ required: field.required ?? false,
110
+ options: field.options,
171
111
  })) } : tool ? { ...request, tool } : request;
172
112
  const entry = { kind, request, settled: Promise.withResolvers() };
173
113
  observer.interactions.set(key, entry);
@@ -189,17 +129,19 @@ export function createV2Adapter(options) {
189
129
  await client.session.form.cancel(native, { signal });
190
130
  } else if (question && decision?.type === "answer") {
191
131
  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) => {
132
+ const answer = Object.fromEntries(fields.flatMap((field, index) => {
193
133
  const values = decision.answers[index];
134
+ if (values === null && !field.required) return [];
194
135
  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]];
136
+ return [[field.key, field.type === "multiselect" ? values : values[0]]];
197
137
  }));
198
138
  await client.session.form.reply({ ...native, answer }, { signal });
199
139
  } else throw new Error("This form requires an OpenCode client response.");
200
140
  } catch (error) {
201
141
  signal.throwIfAborted();
202
- if (retryable(error) || error.reason === "MalformedResponse" || ["FormAlreadySettledError", "FormNotFoundError", "PermissionNotFoundError"].includes(error._tag)) {
142
+ if (["Transport", "MalformedResponse"].includes(error.reason)
143
+ || (error.reason === "UnexpectedStatus" && [502, 503, 504].includes(error.cause?.status))
144
+ || ["FormAlreadySettledError", "FormNotFoundError", "PermissionNotFoundError"].includes(error._tag)) {
203
145
  if (!await pending(observer, entry)) { settle(entry); return; }
204
146
  else throw error;
205
147
  } else throw error;
@@ -231,7 +173,17 @@ export function createV2Adapter(options) {
231
173
  }
232
174
 
233
175
  function reconcile(observer) {
234
- observer.reconciliation = (observer.reconciliation ?? Promise.resolve()).catch(() => undefined).then(() => reconcilePending(observer));
176
+ observer.reconcileRequested = true;
177
+ if (observer.reconciliation) return observer.reconciliation;
178
+ observer.reconciliation = Promise.resolve().then(async () => {
179
+ try {
180
+ while (observer.reconcileRequested && !observer.controller.signal.aborted) {
181
+ observer.reconcileRequested = false;
182
+ try { await reconcilePending(observer); }
183
+ catch (error) { if (!observer.reconcileRequested) throw error; }
184
+ }
185
+ } finally { observer.reconciliation = undefined; }
186
+ });
235
187
  return observer.reconciliation;
236
188
  }
237
189
 
@@ -239,26 +191,48 @@ export function createV2Adapter(options) {
239
191
  if (!observer.onInteraction && !observer.onPermissionsReconciled) return;
240
192
  const signal = observer.controller.signal;
241
193
  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);
194
+ const sessionIds = new Set([observer.sessionId]);
195
+ for (const sessionId of sessionIds) {
196
+ signal.throwIfAborted();
197
+ const input = { sessionID: sessionId };
198
+ const results = await Promise.allSettled(["form", "permission"].map(async (kind) => {
199
+ let snapshot;
200
+ try {
201
+ snapshot = await (kind === "form"
202
+ ? client.session.form.list(input, { signal }) : client.permission.list(input, { signal }));
203
+ if (!Array.isArray(snapshot) || snapshot.some((request) => request.sessionID !== sessionId)) throw new Error("OpenCode returned an invalid interaction projection.");
204
+ } catch {
205
+ if (!signal.aborted) process.stderr.write(`OpenCode ${kind} reconciliation read failed.\n`);
206
+ return;
255
207
  }
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
- }
208
+ if (signal.aborted || revision !== observer.interactionRevision) return;
209
+ for (const request of snapshot) await dispatch(observer, kind, request);
210
+ if (signal.aborted || revision !== observer.interactionRevision) return;
211
+ for (const [key, entry] of observer.interactions) {
212
+ if (entry.kind === kind && entry.request.sessionID === sessionId && !entry.submitting && !snapshot.some((request) => request.id === entry.request.id)) {
213
+ settle(entry);
214
+ observer.interactions.delete(key);
215
+ }
216
+ }
217
+ if (kind === "permission" && observer.onPermissionsReconciled && await belongs(observer, sessionId)
218
+ && !signal.aborted && revision === observer.interactionRevision) {
219
+ await observer.onPermissionsReconciled({ sessionId, requestIds: new Set(snapshot.map((request) => request.id)) });
220
+ }
221
+ }));
222
+ for (const result of results) if (result.status === "rejected") throw result.reason;
223
+ if (signal.aborted || revision !== observer.interactionRevision) return;
224
+ let cursor;
225
+ do {
226
+ try {
227
+ const page = await client.session.list({ parentID: sessionId, ...(cursor ? { cursor } : {}) }, { signal });
228
+ if (!Array.isArray(page.data)) throw new Error("OpenCode returned an invalid session projection.");
229
+ for (const child of page.data) if (typeof child.id === "string" && child.parentID === sessionId) sessionIds.add(child.id);
230
+ cursor = page.cursor.next;
231
+ } catch {
232
+ if (!signal.aborted) process.stderr.write("OpenCode descendant discovery failed.\n");
233
+ break;
234
+ }
235
+ } while (cursor);
262
236
  }
263
237
  }
264
238
 
@@ -276,7 +250,7 @@ export function createV2Adapter(options) {
276
250
  connected = true;
277
251
  for (const observer of observers.values()) {
278
252
  queueResponse(observer, async () => {
279
- if (!await lookup(observer.sessionId, observer.workingDirectory, observer.controller.signal)) throw new Error("OpenCode session is unavailable.");
253
+ if (!await lookup(observer.sessionId, observer.controller.signal)) throw new Error("OpenCode session is unavailable.");
280
254
  observer.initialized.resolve();
281
255
  }, true);
282
256
  void reconcile(observer).catch(() => undefined);
@@ -284,19 +258,20 @@ export function createV2Adapter(options) {
284
258
  continue;
285
259
  }
286
260
  for (const observer of observers.values()) {
287
- if (event.location && path.resolve(event.location.directory ?? "") !== path.resolve(observer.workingDirectory)) continue;
288
261
  if (event.data?.sessionID === observer.sessionId) {
289
262
  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);
263
+ const message = await client.session.message.get({ sessionID: observer.sessionId, messageID: event.data.assistantMessageID }, { signal: observer.controller.signal });
291
264
  await deliverResponse(observer, message);
292
265
  });
293
- if (event.type === "session.execution.failed") queueResponse(observer, () => report(observer, executionError(event.data.error)));
266
+ if (event.type === "session.execution.failed") queueResponse(observer, () => report(observer, Object.assign(new Error(event.data.error.message), event.data.error)));
294
267
  if (event.type === "session.execution.interrupted") settleWaiters(observer, "");
295
268
  if (event.type === "session.tool.called") void reconcile(observer).catch(() => undefined);
296
269
  }
297
- if (!["form.created", "permission.asked", "form.replied", "form.cancelled", "permission.replied", "location.shutdown"].includes(event.type)) continue;
270
+ if (!["form.created", "permission.asked", "form.replied", "form.cancelled", "permission.replied", "location.shutdown", "session.created", "session.forked", "session.moved"].includes(event.type)) continue;
298
271
  observer.interactionTask = (observer.interactionTask ?? Promise.resolve()).then(async () => {
299
272
  if (observer.controller.signal.aborted) return;
273
+ if (["session.created", "session.forked", "session.moved"].includes(event.type)
274
+ && await belongs(observer, event.data.parentID ?? event.data.sessionID)) void reconcile(observer).catch(() => undefined);
300
275
  if (event.type === "form.created") await dispatch(observer, "form", event.data.form);
301
276
  if (event.type === "permission.asked") await dispatch(observer, "permission", event.data);
302
277
  if (event.type === "permission.replied" && await belongs(observer, event.data.sessionID)) {
@@ -312,7 +287,7 @@ export function createV2Adapter(options) {
312
287
  const id = kind === "form" ? event.data?.id : event.data?.requestID;
313
288
  const entry = observer.interactions.get(`${kind}:${event.data?.sessionID}:${id}`);
314
289
  if (entry && !entry.submitting) settle(entry);
315
- await reconcile(observer);
290
+ void reconcile(observer).catch(() => undefined);
316
291
  }
317
292
  }).catch(() => { if (!observer.controller.signal.aborted) process.stderr.write("OpenCode interaction event failed.\n"); });
318
293
  }
@@ -329,17 +304,15 @@ export function createV2Adapter(options) {
329
304
  const signal = observer.controller.signal;
330
305
  if (signal.aborted) return;
331
306
  try { await operation(); }
332
- catch {
307
+ catch (error) {
333
308
  if (signal.aborted) return;
334
309
  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);
310
+ observer.initialized.reject(error);
311
+ await report(observer, error).catch(() => undefined);
312
+ detach(observer, error);
339
313
  return;
340
314
  }
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"));
315
+ await report(observer, error).catch(() => process.stderr.write("Pipa could not deliver an OpenCode response.\n"));
343
316
  }
344
317
  });
345
318
  }
@@ -363,13 +336,13 @@ export function createV2Adapter(options) {
363
336
  let observer = observers.get(input.sessionId);
364
337
  const created = !observer;
365
338
  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 };
339
+ observer = { sessionId: input.sessionId, controller: new AbortController(), initialized: Promise.withResolvers(), delivered: new Set(), replied: new Set(), waiters: new Set(), handlers: new Set(), interactions: new Map(), interactionRevision: 0, persistent };
367
340
  observers.set(input.sessionId, observer);
368
341
  // Observe rejection immediately, including shutdown during initial attachment.
369
342
  void observer.initialized.promise.catch(() => undefined);
370
343
  observer.registration = (async () => {
371
344
  const signal = observer.controller.signal;
372
- if (!await lookup(input.sessionId, input.workingDirectory, signal)) throw new Error("OpenCode session is unavailable.");
345
+ if (!await lookup(input.sessionId, signal)) throw new Error("OpenCode session is unavailable.");
373
346
  try {
374
347
  const entries = await client.session.instructions.entry.list({ sessionID: input.sessionId }, { signal });
375
348
  observer.instructions = entries.find((entry) => entry.key === "pipa.slack")?.value;
@@ -377,11 +350,9 @@ export function createV2Adapter(options) {
377
350
  } catch { signal.throwIfAborted(); /* Old context migration is best effort and session-local. */ }
378
351
  watchEvents();
379
352
  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); }
353
+ await observer.initialized.promise;
382
354
  })();
383
355
  }
384
- if (path.resolve(observer.workingDirectory) !== path.resolve(input.workingDirectory)) throw new Error("OpenCode session workspace identity mismatch.");
385
356
  if (waiter) observer.waiters.add(waiter);
386
357
  observer.persistent ||= persistent;
387
358
  for (const key of ["onResponse", "onError", "onInteraction", "onPermissionReplied", "onPermissionsReconciled"]) if (input[key] !== undefined) observer[key] = input[key];
@@ -409,23 +380,24 @@ export function createV2Adapter(options) {
409
380
  if (typeof sessionId !== "string" || !sessionId) throw new Error("Invalid OpenCode session ID.");
410
381
  if (model !== null && (!model || typeof model.providerID !== "string" || !model.providerID || typeof model.id !== "string" || !model.id
411
382
  || (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.");
383
+ const session = await lookup(sessionId, signal);
384
+ if (!session) throw new Error("OpenCode session is unavailable; model selection did not create a replacement.");
385
+ const selection = model === null ? (await client.model.default({ location: { directory: session.location.directory } }, { signal })).data
386
+ : model;
387
+ if (selection !== null && (!selection || typeof selection.providerID !== "string" || typeof selection.id !== "string")) throw new Error("OpenCode returned an invalid default model.");
388
+ if (!selection) throw new Error("OpenCode default model is unavailable.");
417
389
  signal.throwIfAborted();
418
- await client.session.switchModel({ sessionID: sessionId, model: selection }, { signal });
390
+ await client.session.switchModel({ sessionID: sessionId, model: { providerID: selection.providerID, id: selection.id, variant: model?.variant ?? "default" } }, { signal });
419
391
  },
420
392
  async resolveSession(sessionId, workingDirectory, controller) {
421
393
  const signal = controller.signal;
422
- let session = sessionId ? await lookup(sessionId, workingDirectory, signal) : null;
394
+ let session = sessionId ? await lookup(sessionId, signal) : null;
423
395
  const created = !session;
424
396
  if (!session) {
425
397
  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.");
398
+ if (typeof session?.id !== "string" || !session.id) throw new Error("OpenCode did not return a usable session identity.");
427
399
  }
428
- const history = !created && !session.model ? await readWithRecovery((signal) => client.message.list({ sessionID: session.id, limit: 1 }, { signal }), signal) : null;
400
+ const history = !created && !session.model ? await client.message.list({ sessionID: session.id, limit: 1 }, { signal }) : null;
429
401
  if (history && !Array.isArray(history.data)) throw new Error("OpenCode returned an invalid message projection.");
430
402
  return { sessionId: session.id, defaultEligible: !session.model && (created || !history.data.length) };
431
403
  },
@@ -452,10 +424,9 @@ export function createV2Adapter(options) {
452
424
  const selected = input.model ?? (input.defaultEligible ? input.defaultModel : null);
453
425
  if (selected) await client.session.switchModel({ sessionID: input.sessionId, model: { providerID: selected.providerID, id: selected.modelID ?? selected.id, variant: selected.variant ?? "default" } }, { signal });
454
426
  const id = options.inputId?.() ?? `msg_${randomUUID().replaceAll("-", "")}`;
455
- const admitted = await client.session.prompt({ sessionID: input.sessionId, id, text: input.prompt,
427
+ await client.session.prompt({ sessionID: input.sessionId, id, text: input.prompt,
456
428
  ...(input.files?.length ? { files: input.files.map((file) => ({ uri: file.url, name: file.filename })) } : {}),
457
429
  }, { 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
430
  if (input.onResponse) return { pending: true };
460
431
  return await waiter.promise;
461
432
  } catch (error) {
@@ -469,9 +440,13 @@ export function createV2Adapter(options) {
469
440
  }
470
441
  },
471
442
  async abortTurn(sessionId) {
443
+ if (stopped) throw stopped;
472
444
  const observer = observers.get(sessionId);
473
445
  if (observer) settleWaiters(observer, "");
474
- await client.session.interrupt({ sessionID: sessionId, resume: false });
446
+ const controller = new AbortController();
447
+ controllers.add(controller);
448
+ try { await client.session.interrupt({ sessionID: sessionId, resume: false }, { signal: controller.signal }); }
449
+ finally { controllers.delete(controller); }
475
450
  },
476
451
  stopAll(reason = new Error("OpenCode bridge stopped.")) {
477
452
  stopped = reason;
@@ -484,20 +459,3 @@ export function createV2Adapter(options) {
484
459
  async drain() { await Promise.allSettled(stopping); },
485
460
  };
486
461
  }
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
- }
package/src/opencode.mjs CHANGED
@@ -192,7 +192,6 @@ export function createOpenCodeExecutor(options = {}) {
192
192
  if (legacySession && sessionId && activeSessions.has(sessionId)) throw new Error("OpenCode attribution conflict: the session already has an active writer.");
193
193
  let temporaryDirectory;
194
194
  const selectedModel = normalizeModel(model);
195
- const newThreadModel = normalizeModel(defaultModel);
196
195
  const slackTurn = contextEnvironment.PIPA_MESSAGE_CHANNEL === "slack";
197
196
  const controller = new AbortController();
198
197
  const abort = () => controller.abort(signal.reason);
@@ -216,6 +215,7 @@ export function createOpenCodeExecutor(options = {}) {
216
215
  activeSessions.set(selectedSessionId, { controller, workingDirectory, resolved: true });
217
216
  await onSession?.(selectedSessionId);
218
217
  if (controller.signal.aborted) throw controller.signal.reason;
218
+ const newThreadModel = !selectedModel && (prepared.defaultEligible ?? !prepared.threadModel) ? normalizeModel(defaultModel) : null;
219
219
 
220
220
  if (slackTurn) artifactDirectory = await prepareArtifacts(selectedSessionId, workingDirectory, capabilities.backgroundResponses && !!onResponse);
221
221
 
@@ -273,12 +273,11 @@ export function createOpenCodeExecutor(options = {}) {
273
273
  if (signal?.aborted) abort();
274
274
  else signal?.addEventListener("abort", abort, { once: true });
275
275
  active.add(controller);
276
- // Slack is acknowledged before discovery; allow slow catalogs without waiting forever.
277
- const timer = setTimeout(() => controller.abort(new Error("Model discovery timed out.")), 30_000);
276
+ let timer;
278
277
  try {
279
278
  await abortable(ready(workingDirectory), controller.signal);
280
279
  controller.signal.throwIfAborted();
281
- if (!capabilities.modelDiscovery) throw new Error("OpenCode model discovery is not supported by this adapter.");
280
+ if (!capabilities.backgroundResponses) timer = setTimeout(() => controller.abort(new Error("Model discovery timed out.")), 30_000);
282
281
  const catalog = await abortable(adapter.listModels(workingDirectory, controller.signal), controller.signal);
283
282
  controller.signal.throwIfAborted();
284
283
  return flat ? catalog.models.map((model) => ({ providerID: model.providerID, modelID: model.id, name: model.name })) : catalog;
@@ -456,6 +455,10 @@ async function stageAttachments(attachments, temporaryDirectory, useDataUrls, si
456
455
  function turnInstructions(contextEnvironment, artifactDirectory) {
457
456
  const context = Object.entries(contextEnvironment).filter(([, value]) => value !== undefined && value !== null && String(value));
458
457
  const instructions = ["For scheduling requests, consult `pipa routine --help`, convert timezone wording to an IANA timezone, preview first, show the normalized details, and create only after user confirmation."];
458
+ const restartCommand = contextEnvironment.PIPA_MESSAGE_CHANNEL === "slack" && contextEnvironment.PIPA_CURRENT_SLACK_CHANNEL_ID
459
+ ? `pipa restart --channel ${contextEnvironment.PIPA_CURRENT_SLACK_CHANNEL_ID}${contextEnvironment.PIPA_CURRENT_SLACK_THREAD_TS ? ` --thread ${contextEnvironment.PIPA_CURRENT_SLACK_THREAD_TS}` : ""}`
460
+ : "pipa restart";
461
+ instructions.push(`When asked to restart Pipa, run \`${restartCommand}\`; existing messaging authorization is sufficient. It requests a detached restart and may end this turn. Use \`pipa restart --status\` to inspect the durable outcome; do not claim completion from the request alone. Both commands must run on the Pipa host, not a remote attached OpenCode host. If you lack command access to the Pipa host, explain that limitation instead of running them remotely. The Pipa profile home on that host is ${JSON.stringify(path.resolve(process.env.PIPA_HOME || os.homedir()))}; ensure PIPA_HOME has this value in the command environment. Do not use sequential stop/start or OpenCode /instance/dispose: that disposes an instance, not restarts the server.`);
459
462
  if (context.length) instructions.push(`Slack context for this turn (provided here, not as shell environment variables):\n${context.map(([key, value]) => `${key}=${value}`).join("\n")}`);
460
463
  if (contextEnvironment.PIPA_MESSAGE_CHANNEL === "slack") {
461
464
  instructions.push("Keep naturally short answers inline. For deeper work or larger deliverables, keep the Slack response concise and use the most suitable artifact format.");
@@ -632,22 +635,20 @@ export async function checkOpenCodeConnection(baseUrl, workingDirectory, options
632
635
  } else {
633
636
  const headers = authenticationHeaders(environment, 2);
634
637
  const info = await read("/api/info", headers, undefined, true);
635
- if (!info || typeof info.version !== "string" || !Number.isSafeInteger(info.pid) || info.pid <= 0
636
- || !Array.isArray(info.urls) || !info.urls.every((url) => typeof url === "string") || typeof info.paths?.tmp !== "string") {
638
+ if (typeof info?.version !== "string") {
637
639
  throw new Error("OpenCode identity protocol is unsupported. Check the selected server URL and install a supported v1 or v2 runtime.");
638
640
  }
639
641
  const identity = parseOpenCodeVersion(info.version);
640
642
  if (identity.major !== 2) throw new Error("OpenCode identity/protocol mismatch at /api/info.");
641
643
  connection = { ...identity, headers };
642
644
  }
643
- if (options.identity && options.identity.version !== connection.version) throw new Error("OpenCode CLI/server identity mismatch. Check the executable and selected listening server.");
645
+ if (options.identity && (options.identity.major !== connection.major || (connection.major === 1 && options.identity.version !== connection.version))) throw new Error("OpenCode CLI/server identity mismatch. Check the executable and selected listening server.");
644
646
  }
645
647
  const headers = connection.headers;
646
648
  if (connection.major === 2) {
647
649
  const locationUrl = `/api/location?${new URLSearchParams({ "location[directory]": workingDirectory })}`;
648
650
  const location = await read(locationUrl, headers);
649
- if (typeof location?.directory !== "string" || !path.isAbsolute(location.directory) || typeof location.project?.id !== "string"
650
- || typeof location.project?.directory !== "string" || typeof location.project?.canonical !== "string") throw new Error("OpenCode location protocol has an invalid schema.");
651
+ if (typeof location?.directory !== "string" || !path.isAbsolute(location.directory)) throw new Error("OpenCode location protocol has an invalid schema.");
651
652
  if (path.resolve(location.directory) !== path.resolve(workingDirectory)) throw new Error("OpenCode workspace identity mismatch. Select a server serving the configured working directory.");
652
653
  } else {
653
654
  const location = await read("/path", headers, workingDirectory);
package/src/state.mjs CHANGED
@@ -204,7 +204,6 @@ export async function loadConfig(file = pipaPaths().config) {
204
204
  if (config.mentionOnly !== undefined && typeof config.mentionOnly !== "boolean") {
205
205
  throw new Error("Invalid Pipa config: mentionOnly must be a boolean.");
206
206
  }
207
- normalizeModel(config.defaultModel);
208
207
  return { ...config, slackMode };
209
208
  }
210
209