@usepipa/pipa 0.6.0-beta.2 → 0.6.0-beta.3
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.
- package/README.md +68 -124
- package/bin/pipa.mjs +5 -15
- package/package.json +1 -1
- package/src/app.mjs +43 -23
- package/src/errors.mjs +4 -0
- package/src/models.mjs +25 -39
- package/src/opencode-v2.mjs +107 -149
- package/src/opencode.mjs +6 -9
- package/src/state.mjs +0 -1
package/src/opencode-v2.mjs
CHANGED
|
@@ -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:
|
|
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
|
|
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
|
|
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
|
|
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
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
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
|
-
|
|
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
|
|
128
|
-
|
|
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" &&
|
|
156
|
-
&& fields.every((field
|
|
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
|
-
|
|
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.
|
|
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
|
-
|
|
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 (
|
|
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.
|
|
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
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
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
|
-
|
|
258
|
-
|
|
259
|
-
for (const
|
|
260
|
-
|
|
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.
|
|
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
|
|
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,
|
|
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
|
-
|
|
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
|
-
|
|
336
|
-
observer.
|
|
337
|
-
|
|
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
|
-
|
|
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,
|
|
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,
|
|
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
|
-
|
|
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
|
|
413
|
-
|
|
414
|
-
const
|
|
415
|
-
|
|
416
|
-
if (
|
|
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,
|
|
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.
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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.
|
|
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;
|
|
@@ -632,22 +631,20 @@ export async function checkOpenCodeConnection(baseUrl, workingDirectory, options
|
|
|
632
631
|
} else {
|
|
633
632
|
const headers = authenticationHeaders(environment, 2);
|
|
634
633
|
const info = await read("/api/info", headers, undefined, true);
|
|
635
|
-
if (
|
|
636
|
-
|| !Array.isArray(info.urls) || !info.urls.every((url) => typeof url === "string") || typeof info.paths?.tmp !== "string") {
|
|
634
|
+
if (typeof info?.version !== "string") {
|
|
637
635
|
throw new Error("OpenCode identity protocol is unsupported. Check the selected server URL and install a supported v1 or v2 runtime.");
|
|
638
636
|
}
|
|
639
637
|
const identity = parseOpenCodeVersion(info.version);
|
|
640
638
|
if (identity.major !== 2) throw new Error("OpenCode identity/protocol mismatch at /api/info.");
|
|
641
639
|
connection = { ...identity, headers };
|
|
642
640
|
}
|
|
643
|
-
if (options.identity && options.identity.version !== connection.version) throw new Error("OpenCode CLI/server identity mismatch. Check the executable and selected listening server.");
|
|
641
|
+
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
642
|
}
|
|
645
643
|
const headers = connection.headers;
|
|
646
644
|
if (connection.major === 2) {
|
|
647
645
|
const locationUrl = `/api/location?${new URLSearchParams({ "location[directory]": workingDirectory })}`;
|
|
648
646
|
const location = await read(locationUrl, headers);
|
|
649
|
-
if (typeof location?.directory !== "string" || !path.isAbsolute(location.directory)
|
|
650
|
-
|| typeof location.project?.directory !== "string" || typeof location.project?.canonical !== "string") throw new Error("OpenCode location protocol has an invalid schema.");
|
|
647
|
+
if (typeof location?.directory !== "string" || !path.isAbsolute(location.directory)) throw new Error("OpenCode location protocol has an invalid schema.");
|
|
651
648
|
if (path.resolve(location.directory) !== path.resolve(workingDirectory)) throw new Error("OpenCode workspace identity mismatch. Select a server serving the configured working directory.");
|
|
652
649
|
} else {
|
|
653
650
|
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
|
|