@openagents-org/agent-launcher 0.2.223 → 0.2.225

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@openagents-org/agent-launcher",
3
- "version": "0.2.223",
3
+ "version": "0.2.225",
4
4
  "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
5
5
  "main": "src/index.js",
6
6
  "bin": {
@@ -15,10 +15,35 @@
15
15
 
16
16
  const { redactSecrets } = require('./utils');
17
17
 
18
- /** Build the argv tail (everything after the binary) for one headless run. */
19
- function buildAgyArgv({ prompt, model, conversationId, skipResume = false } = {}) {
18
+ /**
19
+ * Longest prompt passed as `-p <prompt>`. Past it the prompt goes over stdin
20
+ * (agyStdinMessage). Windows caps a whole command line at 32,767 characters
21
+ * and Node fails the spawn itself with ENAMETOOLONG — the system prompt plus a
22
+ * large pinned glossary got there with a one-word message. Linux caps a single
23
+ * argument at 128 KiB. Both limits are left headroom for quoting and the rest
24
+ * of the argv.
25
+ */
26
+ function agyPromptFitsArgv(prompt, platform = process.platform) {
27
+ const limit = platform === 'win32' ? 24000 : 100000;
28
+ return String(prompt || '').length <= limit;
29
+ }
30
+
31
+ /**
32
+ * The stdin line for a prompt sent with `--input-format stream-json` — the
33
+ * only stdin input headless agy accepts (plain-text stdin is not read, and a
34
+ * `-p` prompt is dropped in this mode). antigravity.google/docs/cli/headless
35
+ */
36
+ function agyStdinMessage(prompt) {
37
+ return `${JSON.stringify({ event: 'user', message: { content: String(prompt || '') } })}\n`;
38
+ }
39
+
40
+ /**
41
+ * Build the argv tail (everything after the binary) for one headless run.
42
+ * `viaStdin` leaves the prompt out: the caller writes agyStdinMessage(prompt).
43
+ */
44
+ function buildAgyArgv({ prompt, model, conversationId, skipResume = false, viaStdin = false } = {}) {
20
45
  const args = [
21
- '-p', prompt || '',
46
+ ...(viaStdin ? ['--input-format', 'stream-json'] : ['-p', prompt || '']),
22
47
  // Counterpart of gemini's `-y`: headless runs have no interactive
23
48
  // approval prompt, and a soft-denied tool call silently degrades the
24
49
  // answer. The daemon is the approval boundary here, same as every other
@@ -297,6 +322,8 @@ function agyBinaryCandidates({ home, isWindows, localAppData } = {}) {
297
322
  }
298
323
 
299
324
  module.exports = {
325
+ agyPromptFitsArgv,
326
+ agyStdinMessage,
300
327
  buildAgyArgv,
301
328
  parseAgyEvent,
302
329
  toolPreview,
@@ -28,6 +28,8 @@ const { whereBinary } = require('../paths');
28
28
  const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
29
29
  const { buildClaudeSystemPrompt } = require('./workspace-prompt');
30
30
  const {
31
+ agyPromptFitsArgv,
32
+ agyStdinMessage,
31
33
  buildAgyArgv,
32
34
  parseAgyEvent,
33
35
  AgyRunState,
@@ -175,13 +177,16 @@ class AntigravityAdapter extends BaseAdapter {
175
177
  const env = this.agentEnv || process.env;
176
178
  const model = (env.ANTIGRAVITY_MODEL || env.AGY_MODEL || '').trim();
177
179
 
180
+ // Too long for a command line: send it over stdin instead.
181
+ const viaStdin = !agyPromptFitsArgv(fullPrompt);
178
182
  const args = buildAgyArgv({
179
183
  prompt: fullPrompt,
180
184
  model,
181
185
  conversationId: this._channelConversations[channelName],
182
186
  skipResume,
187
+ viaStdin,
183
188
  });
184
- return { cmd: [agyBin, ...args] };
189
+ return { cmd: [agyBin, ...args], stdinPrompt: viaStdin ? fullPrompt : null };
185
190
  }
186
191
 
187
192
  async _handleMessage(msg) {
@@ -225,6 +230,7 @@ class AntigravityAdapter extends BaseAdapter {
225
230
  await this.sendStatus(msgChannel, 'thinking...');
226
231
 
227
232
  let cmd;
233
+ let stdinPrompt = null;
228
234
  const cleanEnv = { ...(this.agentEnv || process.env) };
229
235
 
230
236
  let _shouldRetry = false;
@@ -232,6 +238,7 @@ class AntigravityAdapter extends BaseAdapter {
232
238
  try {
233
239
  const built = this._buildAgyCmd(content, msgChannel, { skipResume: attempt > 0 });
234
240
  cmd = built.cmd;
241
+ stdinPrompt = built.stdinPrompt;
235
242
  } catch (e) {
236
243
  await this.sendError(msgChannel, e.message);
237
244
  return;
@@ -242,13 +249,21 @@ class AntigravityAdapter extends BaseAdapter {
242
249
 
243
250
  try {
244
251
  const proc = spawn(cmd[0], cmd.slice(1), {
245
- stdio: ['ignore', 'pipe', 'pipe'],
252
+ stdio: [stdinPrompt ? 'pipe' : 'ignore', 'pipe', 'pipe'],
246
253
  env: cleanEnv,
247
254
  cwd: this.workingDir,
248
255
  detached: !IS_WINDOWS,
249
256
  windowsHide: true,
250
257
  });
251
258
  this._channelProcesses[msgChannel] = proc;
259
+ // One turn, then EOF. Streaming input is a multi-turn mode; should
260
+ // agy keep running after its result anyway, the run is over then and
261
+ // it is stopped (see processLine), which is not a failure.
262
+ let stoppedAfterResult = false;
263
+ if (stdinPrompt && proc.stdin) {
264
+ proc.stdin.on('error', () => {});
265
+ proc.stdin.end(agyStdinMessage(stdinPrompt));
266
+ }
252
267
 
253
268
  const run = new AgyRunState();
254
269
  let stderrBuf = '';
@@ -301,11 +316,19 @@ class AntigravityAdapter extends BaseAdapter {
301
316
  try { await this.sendStatus(msgChannel, `${action.name} › ${action.preview}`); } catch {}
302
317
  }
303
318
  // 'result' is read from `run` after exit.
319
+ if (action.type === 'result' && stdinPrompt) {
320
+ setTimeout(() => {
321
+ if (proc.exitCode !== null || proc.signalCode !== null) return;
322
+ stoppedAfterResult = true;
323
+ this._stopProcess(proc).catch(() => {});
324
+ }, 5000).unref();
325
+ }
304
326
  }
305
327
  };
306
328
 
307
- proc.on('exit', async (code) => {
329
+ proc.on('exit', async (exitCode) => {
308
330
  if (timeoutTimer) clearInterval(timeoutTimer);
331
+ const code = stoppedAfterResult ? 0 : exitCode;
309
332
 
310
333
  try { await _pendingLines; } catch {}
311
334
 
@@ -71,6 +71,8 @@ const FAILURE_MESSAGES = {
71
71
  provider_not_configured: 'CodeArts Agent has no usable model provider. Check CODEARTS_MODEL, then retry.',
72
72
  model_not_found: "This account can't use the configured model. Pick one from the model list in this agent's configuration (or run `codearts models`), set CODEARTS_MODEL, then retry.",
73
73
  rate_limited: 'The model service is rate-limiting requests. Wait a moment and retry.',
74
+ quota_exhausted: 'The model service account has run out of balance or credit. Top it up, or give this agent a key with credit, then retry.',
75
+ request_too_large: 'The model service refused the request as too large — the conversation or its attachments exceed what it accepts. Start a new thread or send less, then retry.',
74
76
  network_error: 'CodeArts Agent could not reach Huawei Cloud (network or service error). Retry shortly.',
75
77
  provider_server_error: 'The model service returned a server error. Retry shortly.',
76
78
  timeout: 'CodeArts Agent timed out before producing a reply. Retry; if it persists, check the model configuration.',
@@ -444,6 +444,22 @@ function classifyCodeBuddyRun({ result = null, code = null, signal = null, stder
444
444
  const detail = result.errors[0]
445
445
  || result.errorsInfo.map((e) => e.details).find(Boolean)
446
446
  || '';
447
+ // `400 model [default-model] service info not found … Currently supported
448
+ // models: …` — the account has nothing behind that model id or alias, and
449
+ // every run fails until the agent names one it does have. Seen in the
450
+ // field on the bare `default-model` alias; the CLI's list of models is
451
+ // kept (it is the answer), the request ids are not.
452
+ const missing = /model \[([^\]]+)\] service info not found/i.exec(String(detail));
453
+ if (missing) {
454
+ const supported = /currently supported models?[^::]*[::]\s*([\s\S]*)/i.exec(String(detail));
455
+ return {
456
+ kind: 'model_unavailable',
457
+ ok: false,
458
+ userMessage: `This CodeBuddy account has no model behind "${missing[1]}". ` +
459
+ 'Set CODEBUDDY_MODEL in this agent\'s configuration to a model the account offers' +
460
+ (supported ? `: ${truncate(redactSecrets(supported[1].trim()), 300)}` : ', then retry.'),
461
+ };
462
+ }
447
463
  return {
448
464
  kind: 'run_error',
449
465
  ok: false,
@@ -953,6 +953,14 @@ class CodexAdapter extends BaseAdapter {
953
953
  'at an endpoint that supports the full Responses API, or edit the agent and set Agent capabilities to ' +
954
954
  '"Chat only · Chat Completions API" (it then answers without running tools on this device).';
955
955
  }
956
+ // A model the user's ChatGPT plan doesn't include for Codex. Seen in the
957
+ // field with several model names picked in the workspace; every run
958
+ // fails the same way until another model is chosen.
959
+ if (/not supported when using Codex with a ChatGPT account/i.test(detail)) {
960
+ return `${detail}\n\nThis model is not available to Codex on your ChatGPT plan. ` +
961
+ 'Pick another model for this agent (the model menu in the thread, or the agent\'s settings), ' +
962
+ 'or leave the model empty to use the account default.';
963
+ }
956
964
  // Ahead of the network check: a model that needs a newer Codex can
957
965
  // arrive with connection warnings in stderr, and the upgrade is the fix.
958
966
  if (/requires a newer version|upgrade to the latest (app|version)/i.test(detail)) {
@@ -83,6 +83,8 @@ const FAILURE_MESSAGES = {
83
83
  provider_not_configured: "MiMo Code has no usable model provider. Check this agent's base URL and model, then retry.",
84
84
  model_not_found: 'The configured model was not found or this key cannot use it. Pick one from the model list in this agent\'s configuration, then retry.',
85
85
  rate_limited: 'The model service is rate-limiting requests. Wait a moment and retry.',
86
+ quota_exhausted: 'The model service account has run out of balance or credit. Top it up, or give this agent a key with credit, then retry.',
87
+ request_too_large: 'The model service refused the request as too large — the conversation or its attachments exceed what it accepts. Start a new thread or send less, then retry.',
86
88
  network_error: 'MiMo Code could not reach the model service (network or service error). Retry shortly.',
87
89
  provider_server_error: 'The model service returned a server error. Retry shortly.',
88
90
  timeout: 'MiMo Code went quiet for too long and was stopped. If the model service keeps failing, MiMo retries without saying so — check the base URL and model, then retry.',
@@ -14,11 +14,12 @@ const fs = require('fs');
14
14
  const path = require('path');
15
15
  const os = require('os');
16
16
  const crypto = require('crypto');
17
- const { execSync } = require('child_process');
17
+ const { execSync, spawnSync } = require('child_process');
18
18
  // spawn() here is the WSL bridge from ../wsl: same signature as
19
19
  // child_process.spawn, and a straight pass-through unless the resolved CLI
20
20
  // lives on the other side of the Windows/WSL boundary.
21
21
  const { spawn } = require('../wsl');
22
+ const { opencodeTranscript } = require('../host-agent');
22
23
 
23
24
  const BaseAdapter = require('./base');
24
25
  const { formatAttachmentsForPrompt, redactSecrets, stripAnsi } = require('./utils');
@@ -82,6 +83,8 @@ const FAILURE_MESSAGES = {
82
83
  provider_not_configured: 'OpenCode has no usable provider configured. Configure a provider and model, then retry.',
83
84
  model_not_found: 'The configured model was not found or is not accessible. Check the model name and your access, then retry.',
84
85
  rate_limited: 'The provider is rate-limiting requests. Wait a moment and retry.',
86
+ quota_exhausted: "The provider account has run out of balance or credit. Top it up, or give this agent a key with credit, then retry.",
87
+ request_too_large: 'The provider refused the request as too large — the conversation or its attachments exceed what it accepts. Start a new thread or send less, then retry.',
85
88
  network_error: 'OpenCode could not reach the provider (network or service error). Retry shortly.',
86
89
  provider_server_error: 'The provider returned a server error. Retry shortly.',
87
90
  timeout: 'OpenCode timed out before producing a reply. Retry; if it persists, check the model and provider configuration.',
@@ -100,10 +103,14 @@ class OpenCodeAdapter extends BaseAdapter {
100
103
  * @param {object} opts - BaseAdapter opts plus:
101
104
  * @param {Set} [opts.disabledModules]
102
105
  * @param {string} [opts.workingDir]
106
+ * @param {{session_id: string}} [opts.seedSession] - The OpenCode chat this
107
+ * agent was created from (`agn join`). Each channel's first turn carries a
108
+ * transcript of it, so the agent starts with what was said there.
103
109
  */
104
110
  constructor(opts) {
105
111
  super(opts);
106
112
  this.disabledModules = opts.disabledModules || new Set();
113
+ this._seedSession = opts.seedSession && opts.seedSession.session_id ? opts.seedSession : null;
107
114
  // Pin the channel's glossary into the system prompt.
108
115
  this._usesPinnedContext = true;
109
116
 
@@ -181,7 +188,39 @@ class OpenCodeAdapter extends BaseAdapter {
181
188
  if (sessionId) return content;
182
189
  this._ensureWorkspaceSkill(msgChannel);
183
190
  const context = this._buildSystemContext(msgChannel);
184
- return `${context}\n\n---\n\n${content}`;
191
+ const seed = this._seedTranscript(msgChannel);
192
+ return seed
193
+ ? `${context}\n\n---\n\n${seed}\n\n---\n\n${content}`
194
+ : `${context}\n\n---\n\n${content}`;
195
+ }
196
+
197
+ /**
198
+ * For a channel's first turn: the conversation this agent was created from,
199
+ * read with `opencode export` (never written to), or ''. Not a fork: OpenCode
200
+ * forks of a session that ran tools are refused by Anthropic models, whose
201
+ * thinking blocks are bound to the original conversation. A seed that can
202
+ * no longer be read turns seeding off.
203
+ */
204
+ _seedTranscript(msgChannel) {
205
+ const seed = this._seedSession;
206
+ if (!seed || Object.prototype.hasOwnProperty.call(this._channelSessions, msgChannel)) return '';
207
+ try {
208
+ const r = spawnSync(this._opencodeBinary, ['export', seed.session_id], {
209
+ env: this._spawnEnv(msgChannel), encoding: 'utf-8', timeout: 30000,
210
+ maxBuffer: 64 * 1024 * 1024, windowsHide: true,
211
+ shell: IS_WINDOWS && /\.cmd$/i.test(this._opencodeBinary || ''),
212
+ });
213
+ if (r.status !== 0 || !r.stdout) throw new Error((r.stderr || r.error || `exit ${r.status}`).toString().slice(0, 200));
214
+ const text = opencodeTranscript(JSON.parse(r.stdout.slice(r.stdout.indexOf('{'))));
215
+ if (!text) return '';
216
+ return 'Before you joined this workspace, you were in this OpenCode conversation with the user. '
217
+ + 'It is your own memory, quoted for reference; continue from it.\n\n<previous_conversation>\n'
218
+ + `${text}\n</previous_conversation>`;
219
+ } catch (e) {
220
+ this._log(`Seed conversation ${seed.session_id} unavailable (${e.message}); new channels start fresh`);
221
+ this._seedSession = null;
222
+ return '';
223
+ }
185
224
  }
186
225
 
187
226
  /** Environment the CLI is spawned with. */
@@ -1403,17 +1442,23 @@ class OpenCodeAdapter extends BaseAdapter {
1403
1442
  // as "produced output this version could not parse", which said nothing
1404
1443
  // about reinstalling.
1405
1444
  category = 'unsupported_version';
1406
- } else if (has(/\b(401|403)\b/) || has(/unauthor|invalid api key|invalid_api_key|authentication|auth(entication)? failed|forbidden|invalid token|no api key|missing api key|permission denied/)) {
1445
+ } else if (has(/\b(401|403)\b/) || has(/unauthor|invalid api key|invalid_api_key|invalid or revoked api key|api key (?:has been |was )?revoked|authentication|auth(entication)? failed|forbidden|invalid token|no api key|missing api key|permission denied/)) {
1407
1446
  category = 'auth_failed';
1447
+ } else if (has(/\b402\b|insufficient (?:balance|credits?|funds)|insufficient_quota|out of credits?|payment required|余额不足|欠费|arrearage/)) {
1448
+ // A spent account, not a busy one: waiting does not fix it. Seen in the
1449
+ // field as "Insufficient balance" under "undetermined reason".
1450
+ category = 'quota_exhausted';
1408
1451
  } else if (has(/\b429\b/) || has(/rate.?limit|too many requests|quota|overloaded/)) {
1409
1452
  category = 'rate_limited';
1453
+ } else if (has(/\b413\b|request entity too large|payload too large|failed to buffer the request body|length limit exceeded|context(?:_| )length(?:_| )exceeded|maximum context length/)) {
1454
+ category = 'request_too_large';
1410
1455
  } else if (has(/model.*(not found|does not exist|unknown|invalid|unsupported)|no such model|unknown model|invalid model|model_not_found|\b404\b/)) {
1411
1456
  category = 'model_not_found';
1412
1457
  } else if (has(/no provider|provider not configured|not configured|no model configured|no providers|missing provider/)) {
1413
1458
  category = 'provider_not_configured';
1414
1459
  } else if (has(/econnrefused|enotfound|etimedout|eai_again|network|fetch failed|socket hang|connection (refused|reset|error)|getaddrinfo|\bdns\b/)) {
1415
1460
  category = 'network_error';
1416
- } else if (has(/\b5\d\d\b|server error|internal server|bad gateway|service unavailable|gateway timeout/)) {
1461
+ } else if (has(/\b5\d\d\b|server error|internal server|bad gateway|service unavailable|gateway timeout|server is busy|system is busy|系统繁忙|服务繁忙|đang bận/)) {
1417
1462
  category = 'provider_server_error';
1418
1463
  } else if (has(/timeout|timed out/)) {
1419
1464
  category = 'timeout';
package/src/host-agent.js CHANGED
@@ -75,7 +75,14 @@ const AUTH_SETTINGS = {
75
75
  codex: ['CODEX_HOME', 'OPENAI_API_KEY', 'OPENAI_BASE_URL'],
76
76
  codebuddy: ['CODEBUDDY_CONFIG_DIR', 'CODEBUDDY_API_KEY'],
77
77
  gemini: ['GEMINI_API_KEY', 'GOOGLE_API_KEY', 'GOOGLE_CLOUD_PROJECT', 'GOOGLE_GENAI_USE_VERTEXAI'],
78
- opencode: [],
78
+ opencode: [
79
+ 'OPENCODE_CONFIG', 'OPENCODE_CONFIG_DIR', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME',
80
+ 'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'OPENROUTER_API_KEY', 'GEMINI_API_KEY',
81
+ 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_API_KEY', 'GROQ_API_KEY', 'MISTRAL_API_KEY',
82
+ 'DEEPSEEK_API_KEY', 'XAI_API_KEY', 'AZURE_API_KEY', 'AZURE_OPENAI_API_KEY',
83
+ 'GOOGLE_CLOUD_PROJECT', 'VERTEX_LOCATION', 'GOOGLE_APPLICATION_CREDENTIALS',
84
+ 'AWS_REGION', 'AWS_PROFILE',
85
+ ],
79
86
  cursor: ['CURSOR_API_KEY'],
80
87
  };
81
88
  const SECRET_RE = /(KEY|TOKEN|SECRET)$/;
@@ -134,8 +141,67 @@ function snapshotTranscript(src, destDir) {
134
141
  return dest;
135
142
  }
136
143
 
144
+ // ---------------------------------------------------------------------------
145
+ // OpenCode sessions
146
+ // ---------------------------------------------------------------------------
147
+ //
148
+ // OpenCode sets OPENCODE=1 for the commands it runs but no session id, so the
149
+ // session is found by where it runs: the most recently updated one in the
150
+ // directory the command was run from is the chat running it.
151
+
152
+ /** Pick the chat's session from `opencode session list --format json` output. */
153
+ function pickOpencodeSession(sessions, cwd) {
154
+ const want = realpath(cwd);
155
+ const here = (Array.isArray(sessions) ? sessions : [])
156
+ .filter((s) => s && s.id && s.directory && realpath(s.directory) === want)
157
+ .sort((a, b) => (Number(b.updated) || 0) - (Number(a.updated) || 0));
158
+ return here[0] || null;
159
+ }
160
+
161
+ function realpath(p) {
162
+ try { return fs.realpathSync(p); } catch { return path.resolve(String(p || '')); }
163
+ }
164
+
165
+ /** `provider/model` the session runs on, from `opencode export <id>` output. */
166
+ function opencodeSessionModel(exported) {
167
+ const m = exported && exported.info && exported.info.model;
168
+ if (m && m.providerID && m.id) return `${m.providerID}/${m.id}`;
169
+ const msgs = (exported && exported.messages) || [];
170
+ for (let i = msgs.length - 1; i >= 0; i--) {
171
+ const info = msgs[i] && msgs[i].info;
172
+ if (info && info.role === 'assistant' && info.providerID && info.modelID) return `${info.providerID}/${info.modelID}`;
173
+ }
174
+ return null;
175
+ }
176
+
177
+ /**
178
+ * A plain-text transcript of an exported OpenCode session: what each side
179
+ * said and which tools ran, newest part kept when it is longer than
180
+ * `maxChars`. Reasoning is left out.
181
+ */
182
+ function opencodeTranscript(exported, maxChars = 30000) {
183
+ const lines = [];
184
+ for (const msg of (exported && exported.messages) || []) {
185
+ const role = msg && msg.info && msg.info.role === 'assistant' ? 'You' : 'User';
186
+ for (const part of (msg && msg.parts) || []) {
187
+ if (part.type === 'text' && part.text && !part.synthetic) {
188
+ lines.push(`${role}: ${part.text.trim()}`);
189
+ } else if (part.type === 'tool' && part.tool) {
190
+ const state = part.state || {};
191
+ const input = state.input ? JSON.stringify(state.input) : '';
192
+ const output = typeof state.output === 'string' ? state.output.trim() : '';
193
+ lines.push(`[You ran ${part.tool}${input ? ` ${input.slice(0, 500)}` : ''}${output ? ` → ${output.slice(0, 500)}` : ''}]`);
194
+ }
195
+ }
196
+ }
197
+ const text = lines.join('\n\n');
198
+ if (text.length <= maxChars) return text;
199
+ return `[…earlier part omitted…]\n\n${text.slice(text.length - maxChars)}`;
200
+ }
201
+
137
202
  module.exports = {
138
203
  detectHostAgent, sandboxedHost, hostFreeEnv, hostAuthEnv,
139
204
  claudeConfigDir, claudeProjectDir, findClaudeTranscript, snapshotTranscript,
205
+ pickOpencodeSession, opencodeSessionModel, opencodeTranscript,
140
206
  HOST_SESSION_KEYS,
141
207
  };
package/src/join.js CHANGED
@@ -22,9 +22,35 @@ const { AUTH_MODE_KEY, CLI_LOGIN } = require('./env');
22
22
  const { defaultAgentWorkdir } = require('./paths');
23
23
  const {
24
24
  detectHostAgent, sandboxedHost, hostFreeEnv, hostAuthEnv,
25
- claudeConfigDir, findClaudeTranscript,
25
+ claudeConfigDir, findClaudeTranscript, pickOpencodeSession, opencodeSessionModel,
26
26
  } = require('./host-agent');
27
27
 
28
+ /**
29
+ * The OpenCode chat running this command: `{ session_id, directory, model }`,
30
+ * or null. OpenCode exports no session id, so its session list is asked for
31
+ * the newest session in this directory.
32
+ */
33
+ function findOpencodeChat({ env, cwd, run }) {
34
+ const json = (args) => {
35
+ const r = run(args, { env, cwd });
36
+ if (!r || r.status !== 0 || !r.stdout) return null;
37
+ try { return JSON.parse(r.stdout); } catch { return null; }
38
+ };
39
+ const session = pickOpencodeSession(json(['session', 'list', '--format', 'json']), cwd);
40
+ if (!session) return null;
41
+ const exported = json(['export', session.id]);
42
+ return { session_id: session.id, directory: session.directory, model: exported ? opencodeSessionModel(exported) : null };
43
+ }
44
+
45
+ function runOpencodeCli(args, { env, cwd }) {
46
+ const { whichBinary } = require('./paths');
47
+ const bin = whichBinary('opencode') || 'opencode';
48
+ return require('child_process').spawnSync(bin, args, {
49
+ env, cwd, encoding: 'utf-8', timeout: 30000, maxBuffer: 64 * 1024 * 1024,
50
+ shell: process.platform === 'win32' && /\.cmd$/i.test(bin), windowsHide: true,
51
+ });
52
+ }
53
+
28
54
  /**
29
55
  * Browser URL of a workspace, matching the TUI's convention: a localhost/dev
30
56
  * endpoint serves its own web app; everything else lives on the hosted
@@ -181,16 +207,29 @@ async function join({ code, flags = {}, connector, env = process.env, print, dep
181
207
  }
182
208
 
183
209
  // 4. The agent.
184
- const workDir = typeof flags.path === 'string' ? path.resolve(flags.path) : defaultAgentWorkdir(name);
185
210
  const auth = hostAuthEnv(type, env);
186
211
  const agentEnv = { ...auth.env };
187
212
  if (auth.secrets.length === 0) agentEnv[AUTH_MODE_KEY] = CLI_LOGIN;
188
213
 
189
214
  let seed = null;
215
+ // Where the agent works. Claude Code writes a workspace skill (holding the
216
+ // workspace token) into its working directory, so it gets its own; an
217
+ // OpenCode agent keeps that in its agent home and can keep working in the
218
+ // chat's project.
219
+ let defaultDir = null;
190
220
  if (type === 'claude' && host.sessionId) {
191
221
  const transcript = findClaudeTranscript(host.sessionId, claudeConfigDir(env));
192
222
  if (transcript) seed = { session_id: host.sessionId, transcript };
223
+ } else if (type === 'opencode') {
224
+ const chat = findOpencodeChat({ env, cwd: deps.cwd || process.cwd(), run: deps.runOpencode || runOpencodeCli });
225
+ if (chat) {
226
+ seed = { session_id: chat.session_id, directory: chat.directory };
227
+ defaultDir = chat.directory;
228
+ // The OpenCode adapter needs a model on the command line; use the chat's.
229
+ if (chat.model && !agentEnv.OPENCODE_MODEL) agentEnv.OPENCODE_MODEL = chat.model;
230
+ }
193
231
  }
232
+ const workDir = typeof flags.path === 'string' ? path.resolve(flags.path) : (defaultDir || defaultAgentWorkdir(name));
194
233
 
195
234
  connector.addAgent({ name, type, role: 'worker', path: workDir, env: agentEnv });
196
235
  connector.connectWorkspace(name, res.workspaceSlug);
@@ -228,7 +267,9 @@ async function join({ code, flags = {}, connector, env = process.env, print, dep
228
267
  print('');
229
268
  print(`Connected. This agent is now '${name}' in the workspace '${res.workspaceName}': ${url}`);
230
269
  print(`- Runs as: ${runtimeLabel} on ${info.hostname || os.hostname()}, working in ${workDir}`);
231
- if (seed) {
270
+ if (seed && type === 'opencode') {
271
+ print('- Memory: each new workspace thread starts with a transcript of this conversation. This conversation itself is never changed.');
272
+ } else if (seed) {
232
273
  print('- Memory: each new workspace thread starts from a copy of this conversation. This conversation itself is never changed.');
233
274
  } else if (type === 'claude') {
234
275
  print('- Memory: starts fresh (this conversation\'s transcript was not found).');
@@ -238,6 +279,11 @@ async function join({ code, flags = {}, connector, env = process.env, print, dep
238
279
  print(auth.secrets.length
239
280
  ? `- Sign-in: copied ${auth.secrets.join(', ')} from this session into the agent's settings (~/.openagents/daemon.yaml).`
240
281
  : `- Sign-in: uses this machine's ${runtimeLabel} login.`);
282
+ if (type === 'opencode') {
283
+ print(agentEnv.OPENCODE_MODEL
284
+ ? `- Model: ${agentEnv.OPENCODE_MODEL} (the one this conversation uses)`
285
+ : '- Model: none found. Set one before messaging it: agn env opencode --set OPENCODE_MODEL=<provider/model>');
286
+ }
241
287
  print(`- Start at login: ${autostartNote}`);
242
288
  print(`- Undo: agn remove ${name} (and agn autostart --disable to stop starting at login)`);
243
289
  print('');