zhiqu 0.1.0 → 0.2.0

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/src/direct.js ADDED
@@ -0,0 +1,274 @@
1
+ // 直连供应商(第一百二十九轮,用户要的「单独一个、填完整 URL、不做格式校验」)。
2
+ //
3
+ // 为什么单独一份:平时模型请求走 /api/harness/model/stream,由服务器网关去调各家;内网环境里
4
+ // 那条路走不通(网关出不去,或者根本不想让请求经过服务器)。这里直接 POST 用户填的完整地址,
5
+ // 地址原样用 —— 不拼路径、不补 /v1、不校验域名,用户说是什么就是什么(用户明确要求「不做格式校验」)。
6
+ //
7
+ // 两种协议:
8
+ // openai POST <url> { model, messages, tools, stream: true },SSE 里是 choices[0].delta
9
+ // anthropic POST <url> { model, system, messages, tools, max_tokens, stream: true },SSE 里是 content_block_*
10
+ // 两者都翻译成服务器那套事件(start / reasoning / delta / tool_call / done),agent.js 不用分家。
11
+ import { ApiError } from './api.js';
12
+ import { HttpError, openStream, RETRYABLE_STATUS } from './http.js';
13
+ import { SseParser } from './sse.js';
14
+ import { USER_AGENT } from './version.js';
15
+
16
+ const fail = (message, extra = {}) => new ApiError(message, { beforeOutput: true, ...extra });
17
+
18
+ /** 服务器那套 done 的形状:{ message: { role, content, tool_calls }, finishReason, maxTokens, usage } */
19
+ const doneEvent = ({ text, calls, finishReason, usage, maxTokens }) => ({
20
+ message: { role: 'assistant', content: text, ...(calls.length ? { tool_calls: calls } : {}) },
21
+ finishReason, maxTokens,
22
+ usage: usage || undefined,
23
+ });
24
+
25
+ /** OpenAI 的 tool_calls 分片按 index 攒;有的网关连 index 都不给,按出现顺序编 */
26
+ function toolSink() {
27
+ const byIndex = new Map();
28
+ return {
29
+ add(index, part) {
30
+ const key = Number.isInteger(index) ? index : byIndex.size;
31
+ const slot = byIndex.get(key) || { id: '', name: '', arguments: '' };
32
+ if (part.id) slot.id = part.id;
33
+ if (part.name) slot.name = part.name;
34
+ if (part.arguments) slot.arguments += part.arguments;
35
+ byIndex.set(key, slot);
36
+ return slot;
37
+ },
38
+ list() {
39
+ return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([i, s]) => ({
40
+ id: s.id || `call_${i}`, type: 'function', function: { name: s.name, arguments: s.arguments || '{}' },
41
+ }));
42
+ },
43
+ };
44
+ }
45
+
46
+ export class DirectModel {
47
+ /**
48
+ * @param {{ protocol?: 'openai'|'anthropic', url: string, key?: string, model: string, maxTokens?: number }} cfg
49
+ */
50
+ constructor({ protocol = 'openai', url, key = '', model, maxTokens = 8192 } = {}) {
51
+ this.protocol = protocol === 'anthropic' ? 'anthropic' : 'openai';
52
+ this.url = url;
53
+ this.key = key;
54
+ this.model = model;
55
+ this.maxTokens = maxTokens;
56
+ }
57
+
58
+ /** 给界面上看的:直连哪家、哪个模型 */
59
+ get label() { return `${this.model}(直连 ${hostOf(this.url)})`; }
60
+
61
+ headers() {
62
+ if (this.protocol === 'anthropic') {
63
+ return {
64
+ 'User-Agent': USER_AGENT, 'content-type': 'application/json', accept: 'text/event-stream',
65
+ 'anthropic-version': '2023-06-01', ...(this.key ? { 'x-api-key': this.key } : {}),
66
+ };
67
+ }
68
+ return {
69
+ 'User-Agent': USER_AGENT, 'Content-Type': 'application/json', Accept: 'text/event-stream',
70
+ ...(this.key ? { Authorization: `Bearer ${this.key}` } : {}),
71
+ };
72
+ }
73
+
74
+ /** 和 Api.stream 一个签名:body 里的 modelId 不用,模型名来自配置 */
75
+ async stream(body, onEvent, { signal } = {}) {
76
+ const payload = this.protocol === 'anthropic' ? anthropicBody(this, body) : openaiBody(this, body);
77
+ const host = hostOf(this.url);
78
+ let res;
79
+ try {
80
+ res = await openStream(this.url, { headers: this.headers(), body: JSON.stringify(payload), signal });
81
+ } catch (e) {
82
+ if (e && e.name === 'AbortError') throw e;
83
+ // 和 Api.networkError 一个口径:连不上/断了可以重来,地址写错(ECONNREFUSED)也照实说
84
+ const code = e instanceof HttpError ? e.code : null;
85
+ const why = code === 'ECONNREFUSED' ? '连接被拒绝,这个地址上没有服务在听?'
86
+ : code === 'NO_RESPONSE' || code === 'IDLE_TIMEOUT' ? e.message : code || e.message;
87
+ throw new ApiError(`连不上 ${host}(${why})—— 地址是 ${this.url}`, { retryable: e instanceof HttpError ? e.retryable : false, code });
88
+ }
89
+ if (res.status !== 200) {
90
+ const text = await res.readAll().catch(() => '');
91
+ throw new ApiError(httpMessage(res.status, text), { status: res.status, retryable: res.status === 429 || RETRYABLE_STATUS.has(res.status) });
92
+ }
93
+ onEvent('start', { contextWindow: null, droppedMessages: 0, elidedToolOutputs: 0 });
94
+ // 收到过实质内容之后再断,就不能自动重来了(会重复输出、工具调用可能重复)
95
+ let substantive = false;
96
+ const emit = (name, data) => { if (name !== 'start') substantive = true; onEvent(name, data); };
97
+ try {
98
+ if (this.protocol === 'anthropic') return await readAnthropic(res, emit, this.maxTokens);
99
+ return await readOpenAI(res, emit, this.maxTokens);
100
+ } catch (e) {
101
+ if (e && e.name === 'AbortError') throw e;
102
+ if (e instanceof ApiError) throw e;
103
+ throw new ApiError(`回复中断了:和 ${host} 的连接断了(${e.code || e.message})`, { retryable: false, beforeOutput: !substantive });
104
+ }
105
+ }
106
+ }
107
+
108
+ const hostOf = (url) => {
109
+ try { return new URL(url).host; } catch { return String(url || '').replace(/^https?:\/\//, '').split('/')[0] || '直连地址'; }
110
+ };
111
+
112
+ /** 400/401 这种要说清是哪一步坏了 —— 地址是用户自己填的,拼错一个字符最难查 */
113
+ function httpMessage(status, text) {
114
+ const snippet = String(text || '').replace(/\s+/g, ' ').slice(0, 300);
115
+ const hint = status === 401 || status === 403 ? '(密钥可能不对,或者这个地址要的是别的认证头)'
116
+ : status === 404 ? '(地址可能不对:这里要求填完整的接口地址,不是站点根目录)'
117
+ : status === 400 ? '(请求被拒:可能是模型名不对,或者这个网关不认 tools / stream 参数)' : '';
118
+ return `模型接口返回 HTTP ${status}${hint}${snippet ? `:${snippet}` : ''}`;
119
+ }
120
+
121
+ function openaiBody(self, body) {
122
+ const tools = (body.tools || []).filter(Boolean);
123
+ return {
124
+ model: self.model,
125
+ messages: body.messages || [],
126
+ stream: true,
127
+ ...(tools.length ? { tools, tool_choice: 'auto' } : {}),
128
+ ...(body.maxTokens ? { max_tokens: body.maxTokens } : {}),
129
+ };
130
+ }
131
+
132
+ async function readOpenAI(res, onEvent, maxTokens) {
133
+ const sink = toolSink();
134
+ const announced = new Set();
135
+ let text = '';
136
+ let finish = null;
137
+ let usage = null;
138
+ const parser = new SseParser((_name, raw) => {
139
+ const data = String(raw || '').trim();
140
+ if (!data || data === '[DONE]') return;
141
+ let json;
142
+ try { json = JSON.parse(data); } catch { return; }
143
+ if (json.usage) usage = openaiUsage(json.usage);
144
+ const choice = (json.choices || [])[0];
145
+ if (!choice) return;
146
+ const d = choice.delta || {};
147
+ // 思考:DeepSeek 用 reasoning_content,vLLM 一类用 reasoning,别家可能叫 thinking
148
+ const think = d.reasoning_content ?? d.reasoning ?? d.thinking;
149
+ if (think) onEvent('reasoning', { text: String(think) });
150
+ if (d.content) { text += d.content; onEvent('delta', { text: String(d.content) }); }
151
+ for (const [i, part] of (d.tool_calls || []).entries()) {
152
+ const slot = sink.add(Number.isInteger(part.index) ? part.index : i, {
153
+ id: part.id, name: part.function && part.function.name, arguments: part.function && part.function.arguments,
154
+ });
155
+ const key = slot.id || String(i);
156
+ if (slot.name && !announced.has(key)) { announced.add(key); onEvent('tool_call', { index: Number.isInteger(part.index) ? part.index : i, name: slot.name }); }
157
+ }
158
+ if (choice.finish_reason) finish = choice.finish_reason;
159
+ });
160
+ for await (const chunk of res.body) parser.feed(chunk);
161
+ parser.end();
162
+ onEvent('done', doneEvent({ text, calls: sink.list(), finishReason: finish, usage, maxTokens }));
163
+ }
164
+
165
+ function openaiUsage(u) {
166
+ return {
167
+ promptTokens: u.prompt_tokens || 0,
168
+ completionTokens: u.completion_tokens || 0,
169
+ cachedTokens: (u.prompt_tokens_details && u.prompt_tokens_details.cached_tokens) || u.prompt_cache_hit_tokens || 0,
170
+ };
171
+ }
172
+
173
+ // ── Anthropic ────────────────────────────────────────────────────────────
174
+
175
+ function anthropicBody(self, body) {
176
+ const { system, messages } = toAnthropicMessages(body.messages || []);
177
+ const tools = (body.tools || []).filter(Boolean).map((t) => ({
178
+ name: t.function.name, description: t.function.description || '', input_schema: t.function.parameters || { type: 'object', properties: {} },
179
+ }));
180
+ return {
181
+ model: self.model,
182
+ max_tokens: body.maxTokens || self.maxTokens,
183
+ ...(system ? { system } : {}),
184
+ messages,
185
+ stream: true,
186
+ ...(tools.length ? { tools } : {}),
187
+ };
188
+ }
189
+
190
+ /**
191
+ * 我们历史里的形状(OpenAI 那套)翻成 Anthropic 的:
192
+ * system 提到顶层;assistant 的 tool_calls 变 tool_use 块;role:'tool' 变 user 的 tool_result 块。
193
+ * 连着几条 tool 结果要并进同一条 user 消息 —— Anthropic 要求 user/assistant 交替。
194
+ */
195
+ export function toAnthropicMessages(messages) {
196
+ const system = messages.filter((m) => m.role === 'system').map((m) => String(m.content || '')).filter(Boolean).join('\n\n');
197
+ const out = [];
198
+ const isResults = (m) => m && m.role === 'user' && Array.isArray(m.content) && m.content.length && m.content.every((b) => b.type === 'tool_result');
199
+ for (const m of messages) {
200
+ if (m.role === 'system') continue;
201
+ if (m.role === 'tool') {
202
+ const block = { type: 'tool_result', tool_use_id: m.tool_call_id, content: String(m.content ?? '') };
203
+ const last = out[out.length - 1];
204
+ if (isResults(last)) last.content.push(block);
205
+ else out.push({ role: 'user', content: [block] });
206
+ continue;
207
+ }
208
+ if (m.role === 'assistant') {
209
+ const blocks = [];
210
+ if (m.content) blocks.push({ type: 'text', text: String(m.content) });
211
+ for (const c of m.tool_calls || []) {
212
+ let input = {};
213
+ try { input = JSON.parse(c.function.arguments || '{}'); } catch { input = {}; }
214
+ blocks.push({ type: 'tool_use', id: c.id, name: c.function.name, input });
215
+ }
216
+ if (blocks.length) out.push({ role: 'assistant', content: blocks });
217
+ continue;
218
+ }
219
+ out.push({ role: 'user', content: [{ type: 'text', text: String(m.content ?? '') }] });
220
+ }
221
+ return { system, messages: out };
222
+ }
223
+
224
+ /** Anthropic 的用量分两次给(message_start 有 input,message_delta 有 output):缺的沿用上一次的 */
225
+ const mergeUsage = (prev, u) => ({
226
+ promptTokens: u.input_tokens ?? (prev ? prev.promptTokens : 0),
227
+ completionTokens: u.output_tokens ?? (prev ? prev.completionTokens : 0),
228
+ cachedTokens: u.cache_read_input_tokens ?? (prev ? prev.cachedTokens : 0),
229
+ });
230
+
231
+ async function readAnthropic(res, onEvent, maxTokens) { let text = '';
232
+ let finish = null;
233
+ let usage = null;
234
+ const blocks = new Map(); // index → { id, name, json }
235
+ const parser = new SseParser((name, raw) => {
236
+ let json;
237
+ try { json = raw ? JSON.parse(raw) : {}; } catch { return; }
238
+ if (name === 'content_block_start') {
239
+ const b = json.content_block || {};
240
+ if (b.type === 'tool_use') {
241
+ blocks.set(json.index, { id: b.id, name: b.name, json: '' });
242
+ onEvent('tool_call', { index: json.index, name: b.name });
243
+ }
244
+ return;
245
+ }
246
+ if (name === 'content_block_delta') {
247
+ const d = json.delta || {};
248
+ if (d.type === 'text_delta' && d.text) { text += d.text; onEvent('delta', { text: d.text }); }
249
+ else if (d.type === 'thinking_delta' && d.thinking) onEvent('reasoning', { text: d.thinking });
250
+ else if (d.type === 'input_json_delta' && d.partial_json != null) {
251
+ const slot = blocks.get(json.index);
252
+ if (slot) slot.json += d.partial_json;
253
+ }
254
+ return;
255
+ }
256
+ if (name === 'message_delta') {
257
+ if (json.delta && json.delta.stop_reason) finish = json.delta.stop_reason;
258
+ // message_delta 只带 output_tokens,input 在 message_start 里 —— 不能整个覆盖
259
+ if (json.usage) usage = mergeUsage(usage, json.usage);
260
+ return;
261
+ }
262
+ if (name === 'message_start' && json.message && json.message.usage) {
263
+ usage = mergeUsage(usage, json.message.usage);
264
+ return;
265
+ }
266
+ if (name === 'error') throw fail(`模型接口报错:${(json.error && json.error.message) || '未知错误'}`);
267
+ });
268
+ for await (const chunk of res.body) parser.feed(chunk);
269
+ parser.end();
270
+ const calls = [...blocks.entries()].sort((a, b) => a[0] - b[0]).map(([i, s]) => ({
271
+ id: s.id || `call_${i}`, type: 'function', function: { name: s.name, arguments: s.json || '{}' },
272
+ }));
273
+ onEvent('done', doneEvent({ text, calls, finishReason: finish, usage, maxTokens }));
274
+ }
@@ -3,22 +3,28 @@
3
3
  // 后端(Java 的 JsCodeAgent)起这个进程,stdin / stdout 一行一个 JSON:
4
4
  // 后端 → 这里:run(开始)、event / error(模型调用的回音)、exec_result(命令跑完了)、tool_result(远程工具的结果)
5
5
  // 这里 → 后端:model(请后端调一次模型)、exec(请后端跑一条命令)、tool(请后端执行一个 Wiki / 里程碑工具,第九十五轮)、
6
- // step(轨迹里的一句)、result(收尾)、fatal(出错了)
6
+ // step(轨迹里的一句)、trace(回答里按顺序列出的一步,第一百二十七轮,形状见 steps.js)、result(收尾)、fatal(出错了)
7
7
  // 门(是不是管理员、工作区档位、写意图、能不能执行)后端判好了才起这个进程;模型和命令都回到后端去做 —— 这里只有循环和工作区的读、草稿。
8
8
  // 认不出的消息就停,不猜。
9
+ //
10
+ // 桌面版本机代码助手(第一百二十九轮,docs/desktop-remote-plan.md 第 2 步):Mac 桌面外壳也起这个进程,协议同一个(run → step / trace → result),
11
+ // 只是旁边没有后端 —— run 里带 local: { server, token },模型和远程工具直接走服务器网关(和命令行同一份 Api),命令在本机的系统沙箱里跑(DesktopTools),
12
+ // 不往外壳要 model / exec / tool。外壳可以叫停:一行 { type: 'stop' }、关掉 stdin、或者 SIGTERM。
9
13
  import { normalizeEffort } from '../config.js';
10
14
  import fs from 'node:fs';
11
15
  import path from 'node:path';
12
16
  import readline from 'node:readline';
13
17
  import { fileURLToPath } from 'node:url';
14
18
  import { PassThrough, Writable } from 'node:stream';
15
- import { ApiError } from '../api.js';
16
- import { runTurn } from '../agent.js';
19
+ import { Api, ApiError } from '../api.js';
20
+ import { REMOTE_READ_TOOLS, runTurn } from '../agent.js';
17
21
  import { initPrompt } from '../instructions.js';
22
+ import { StepLog } from '../steps.js';
18
23
  import { BUILTIN_SYSTEM_PROMPT } from '../prompt.js';
19
24
  import { collectChanges, nothingReport, parseReviewWords, renderReport, reviewSpec, runReview } from '../review.js';
20
25
  import { detectSandbox } from '../tools/sandbox.js';
21
- import { ArtifactTools, DraftTools } from '../tools/drafts.js';
26
+ import { ArtifactTools, DesktopTools, DraftTools } from '../tools/drafts.js';
27
+ import { NETWORK_MODES } from '../tools/sandbox.js';
22
28
  import { Ui } from '../ui.js';
23
29
 
24
30
  /** 一行一个 JSON 的两头。send 写给后端;pending 等后端回音 */
@@ -28,24 +34,41 @@ export function createBridge({ input, output }) {
28
34
  // 已经收尾的请求(中断了、出错了、done 了):后端在半路的回音还可能到 —— 认得、丢掉,不当成「认不出的消息」停下(第九十九轮 review)
29
35
  const retired = new Set();
30
36
  let onRun = null;
37
+ let onStop = null;
31
38
  let closed = false;
32
- const send = (msg) => { if (!closed) output.write(`${JSON.stringify(msg)}\n`); };
39
+ // 不能出现在任何一行里的字(桌面版的令牌):多一道,万一哪条报错把它带出来,换成 zqp_…
40
+ const secrets = [];
41
+ const line = (msg) => {
42
+ let text = JSON.stringify(msg);
43
+ for (const s of secrets) text = text.split(s).join('zqp_…');
44
+ return text;
45
+ };
46
+ const send = (msg) => { if (!closed) output.write(`${line(msg)}\n`); };
47
+ const stop = () => { if (onStop) { const f = onStop; onStop = null; f(); } };
33
48
  const lines = readline.createInterface({ input, crlfDelay: Infinity });
34
49
  const fail = (message) => { send({ type: 'fatal', message }); closed = true; lines.close(); };
35
50
  lines.on('line', (line) => {
36
51
  let msg;
37
52
  try { msg = JSON.parse(line); } catch { fail('收到的不是 JSON'); return; }
38
53
  if (msg.type === 'run' && onRun) { const f = onRun; onRun = null; f(msg); return; }
54
+ // 叫停(第一百二十九轮,桌面外壳):后端从来不发,发了也只是中断这一轮
55
+ if (msg.type === 'stop') { stop(); return; }
39
56
  if (retired.has(msg.id) && ['event', 'error', 'exec_result', 'tool_result'].includes(msg.type)) return;
40
57
  const waiter = pending.get(msg.id);
41
58
  if (!waiter || !['event', 'error', 'exec_result', 'tool_result'].includes(msg.type)) { fail(`认不出的消息:${String(msg.type).slice(0, 40)}`); return; }
42
59
  waiter(msg);
43
60
  });
44
- lines.on('close', () => { for (const w of pending.values()) w({ type: 'error', message: '后端关掉了连接', retryable: false }); pending.clear(); });
61
+ lines.on('close', () => { for (const w of pending.values()) w({ type: 'error', message: '后端关掉了连接', retryable: false }); pending.clear(); stop(); });
45
62
  const retire = (id) => { pending.delete(id); retired.add(id); };
46
63
  return {
47
64
  send,
48
65
  fail,
66
+ line,
67
+ /** 这些字不许出现在发出去的任何一行里 */
68
+ redact: (s) => { if (typeof s === 'string' && s.length >= 8) secrets.push(s); },
69
+ /** 外壳叫停时做什么(只有桌面版设);SIGTERM 也走这里 */
70
+ onStop: (f) => { onStop = f; },
71
+ requestStop: stop,
49
72
  nextRun: () => new Promise((resolve) => { onRun = resolve; }),
50
73
  /** 和 Api.stream 一样的样子:事件一个个交给 onEvent,done 之后返回;出错抛 ApiError(循环据此决定重不重试) */
51
74
  stream(pathname, body, onEvent, { signal } = {}) {
@@ -143,18 +166,60 @@ async function reviewHosted(ctx, message, signal, home) {
143
166
  return r.error || r.text;
144
167
  }
145
168
 
169
+ /**
170
+ * 桌面版(第一百二十九轮):run.local 给的服务器和令牌。服务器只认 http(s) 的地址,令牌只认 zqp_ 开头的 ——
171
+ * 外壳自己定服务器(不听页面的),这里再挡一次形状。不是桌面版返回 null;给了却不对抛错。
172
+ */
173
+ export function desktopTarget(run) {
174
+ if (!run || run.local == null) return null;
175
+ const { server, token } = run.local || {};
176
+ let url = null;
177
+ try { url = new URL(String(server)); } catch { /* 下面说 */ }
178
+ if (!url || !['http:', 'https:'].includes(url.protocol)) throw new Error('本机代码助手没拿到服务器地址');
179
+ if (typeof token !== 'string' || !/^zqp_[A-Za-z0-9_-]{16,}$/.test(token)) throw new Error('本机代码助手没拿到登录令牌(页面要先签一张)');
180
+ if (typeof run.home !== 'string' || !path.isAbsolute(run.home)) throw new Error('本机代码助手没拿到家目录(沙箱要挡它)');
181
+ return { server: url.origin, token };
182
+ }
183
+
184
+ /** 桌面版:用哪个模型 —— 页面选的那个(没有就用账号的默认),和命令行的 pickModel 同一个口径 */
185
+ async function desktopModel(api, wanted, signal) {
186
+ const { models, defaultModelId } = await api.get('/api/harness/models', { signal, timeoutMs: 15_000 });
187
+ if (!Array.isArray(models) || !models.length) throw new Error('这个账号还没有可用的模型:请先在「设置 → AI 模型」里配一个');
188
+ const id = wanted && typeof wanted === 'object' ? wanted.id : wanted;
189
+ return (id != null && models.find((m) => String(m.id) === String(id))) || models.find((m) => m.id === defaultModelId) || models[0];
190
+ }
191
+
146
192
  /** 跑一轮:run 消息 → 循环 → result。返回 result(测试直接调) */
147
- export async function runHosted(bridge, run) {
148
- const Tools = run.artifact ? ArtifactTools : DraftTools; // 生成到产物:写进临时空间,不走草稿
149
- const local = new Tools({ root: run.root, exec: (req, opts) => bridge.exec(req, opts),
150
- canWrite: Boolean(run.canWrite), canExec: Boolean(run.canExec), canShell: Boolean(run.canShell), shellWrite: Boolean(run.shellWrite), hosted: Boolean(run.hosted),
151
- sandboxNetwork: typeof run.sandboxNetwork === 'string' ? run.sandboxNetwork : 'off', commands: Array.isArray(run.commands) ? run.commands.map(String) : [] });
193
+ export async function runHosted(bridge, run, { detectBox = detectSandbox } = {}) {
194
+ let desktop = null;
195
+ try {
196
+ desktop = desktopTarget(run);
197
+ } catch (e) {
198
+ return { type: 'result', text: '', conclusion: String(e.message || e), context: '', drafts: [], writeCalls: 0, usage: { prompt: 0, completion: 0, cached: 0 }, rounds: 0, aborted: false, error: String(e.message || e) };
199
+ }
200
+ if (desktop) bridge.redact(desktop.token);
201
+ const network = typeof run.sandboxNetwork === 'string' ? run.sandboxNetwork : 'off';
202
+ let local;
203
+ if (desktop) {
204
+ // 有系统沙箱才给命令;联网档认不出的照断网(sandbox.js 本身也这样算)
205
+ const box = run.canShell ? detectBox() : null;
206
+ local = new DesktopTools({ root: run.root, canWrite: Boolean(run.canWrite), sandbox: box, shellWrite: Boolean(run.shellWrite),
207
+ sandboxNetwork: NETWORK_MODES.includes(network) ? network : 'off', home: run.home });
208
+ } else {
209
+ const Tools = run.artifact ? ArtifactTools : DraftTools; // 生成到产物:写进临时空间,不走草稿
210
+ local = new Tools({ root: run.root, exec: (req, opts) => bridge.exec(req, opts),
211
+ canWrite: Boolean(run.canWrite), canExec: Boolean(run.canExec), canShell: Boolean(run.canShell), shellWrite: Boolean(run.shellWrite), hosted: Boolean(run.hosted),
212
+ sandboxNetwork: network, commands: Array.isArray(run.commands) ? run.commands.map(String) : [] });
213
+ }
152
214
  let transcript = '';
153
215
  const ui = new Ui({ input: new PassThrough(), output: new Writable({ write(c, e, cb) { transcript += c; cb(); } }), interactive: false, color: false });
154
216
  // 轨迹:每一步(读了什么、改了什么、跑了什么)交给后端,网页的「执行轨迹」照命令行的说法显示
155
217
  const step = ui.step.bind(ui);
156
218
  ui.step = (text) => { bridge.send({ type: 'step', text: String(text) }); return step(text); };
157
- const api = { stream: (p, body, onEvent, opts) => bridge.stream(p, body, onEvent, opts),
219
+ // 回答里按顺序列出的每一步(第一百二十七轮,像 Codex):开始一条、结束一条,形状见 steps.js
220
+ const stepLog = new StepLog((s) => bridge.send({ type: 'trace', step: s }));
221
+ // 桌面版直接连服务器网关(和命令行同一份 Api);后端起的那一份经 stdout 回给后端
222
+ const api = desktop ? new Api({ server: desktop.server, token: desktop.token }) : { stream: (p, body, onEvent, opts) => bridge.stream(p, body, onEvent, opts),
158
223
  post: async (p, body, opts) => {
159
224
  if (p !== '/api/harness/tools/call') throw new ApiError('这里没有这个远程接口', { retryable: false });
160
225
  return bridge.tool(body.name, body.arguments, opts);
@@ -166,14 +231,19 @@ export async function runHosted(bridge, run) {
166
231
  messages: historyBlock(run.history),
167
232
  allow: { write: false, run: false, delete: false, tasks: false, mcp: new Set() }, usage: { prompt: 0, completion: 0, cached: 0 },
168
233
  changedFiles: new Set(), todos: [], system: { text: BUILTIN_SYSTEM_PROMPT }, instructionsText: '', skillsText: '', skills: [],
169
- verbose: true, model: run.model,
234
+ verbose: true, model: run.model, stepLog,
170
235
  // 网页输入框下面选的思考档位(第一百零八轮);明说,不听服务端给命令行的默认(第五十四轮:工具轮想起来,一问要等几分钟)
171
236
  effort: normalizeEffort(run.effort) || 'instant',
172
237
  };
173
238
  // 远程工具(第九十五轮):一直给的那几个 + 真的跑过一次命令之后才给的(create_wiki_patch:判过题才许记薄弱点)。工具表每一轮重建,所以随时变
174
- const always = Array.isArray(run.remoteTools) ? run.remoteTools : [];
175
- const afterRun = Array.isArray(run.remoteToolsAfterRun) ? run.remoteToolsAfterRun : [];
176
- Object.defineProperty(ctx, 'remoteTools', { get: () => (local.ranCommand ? [...always, ...afterRun] : always), enumerable: true });
239
+ // 桌面版(第一百二十九轮)没有后端替它挑:开工前问服务器要(和命令行同一份清单,执行的也是那一份),只读档只留读的
240
+ if (!desktop) {
241
+ const always = Array.isArray(run.remoteTools) ? run.remoteTools : [];
242
+ const afterRun = Array.isArray(run.remoteToolsAfterRun) ? run.remoteToolsAfterRun : [];
243
+ Object.defineProperty(ctx, 'remoteTools', { get: () => (local.ranCommand ? [...always, ...afterRun] : always), enumerable: true });
244
+ } else {
245
+ ctx.remoteTools = [];
246
+ }
177
247
  // 说的和这一次做的对不上 —— 推一次让它照实做 / 照实说(第九十五轮,真浏览器里两回:0 轮就说「已生成三个文件的草稿」;
178
248
  // 0 轮就说「跑了 test_two_sum.py,输出 ok,三组断言全过」—— 解法还是 return [],根本没跑)
179
249
  // 审查的结论是 JSON,引用的代码里什么话都可能有:不拿它核对(命令行的 /review 也没有这一道)
@@ -197,43 +267,102 @@ export async function runHosted(bridge, run) {
197
267
  };
198
268
  const controller = new AbortController();
199
269
  const timer = run.timeoutMs ? setTimeout(() => controller.abort(), Number(run.timeoutMs)) : null;
270
+ // 外壳叫停(桌面版):和到点一样中断,照实交 result。后端起的那一份、测试里的假桥没有这个方法
271
+ let stopped = false;
272
+ if (typeof bridge.onStop === 'function') bridge.onStop(() => { stopped = true; controller.abort(); });
200
273
  let error = null;
201
274
  let reviewed = null;
275
+ let turn = null;
202
276
  // /init、/review 要项目文件夹:页面已经拦过,这里是最后一道(生成到产物时根目录是临时空间,没什么可看、写了也没人读)
203
277
  const command = run.command === 'init' || run.command === 'review' ? run.command : null;
204
278
  const needsFolder = command && run.artifact;
205
279
  const before = ctx.messages.length;
206
280
  try {
281
+ if (desktop) {
282
+ ctx.model = await desktopModel(api, run.model, controller.signal);
283
+ const remote = await api.get('/api/harness/tools', { signal: controller.signal, timeoutMs: 15_000 }).catch((e) => { if (e && e.auth) throw e; return []; });
284
+ ctx.remoteTools = (Array.isArray(remote) ? remote : []).filter((t) => run.canWrite || REMOTE_READ_TOOLS.has(t && t.function && t.function.name));
285
+ }
207
286
  if (needsFolder) reviewed = `/${command} 要先选一个项目文件夹,现在是生成到产物,没有项目可看。`;
208
287
  else if (command === 'review') reviewed = await reviewHosted(ctx, String(run.message || ''), controller.signal, typeof run.home === 'string' ? run.home : undefined);
209
- else await runTurn(ctx, command === 'init' ? initPrompt(fs.existsSync(path.join(local.root, 'ZHIQU.md'))) : String(run.message || ''), { signal: controller.signal });
288
+ else turn = await runTurn(ctx, command === 'init' ? initPrompt(fs.existsSync(path.join(local.root, 'ZHIQU.md'))) : String(run.message || ''), { signal: controller.signal });
210
289
  } catch (e) {
211
- error = String((e && e.message) || e);
290
+ // 桌面版的令牌失效(过期 / 撤销):命令行那句「请运行 zhiqu login」在这里没用
291
+ error = desktop && e && e.auth ? '本机代码助手的登录令牌失效了(过期或被撤销),重新发一次就会换一张新的。' : String((e && e.message) || e);
212
292
  // 审查的过程在单独的上下文里,这里没有别的字:不写一句,最终回答就只能照空的编
213
293
  if (command === 'review') reviewed = `审查没做完:${error}`;
214
294
  } finally {
215
295
  if (timer) clearTimeout(timer);
296
+ if (typeof bridge.onStop === 'function') bridge.onStop(null);
297
+ // 后台命令随这一轮收掉(桌面版:这个进程交完结果就退,留下的就没人管了;后端那一份由后端收)
298
+ if (desktop && local.jobs) local.jobs.stopAll();
216
299
  }
217
300
  const last = [...ctx.messages].reverse().find((m) => m.role === 'assistant' && !(m.tool_calls || []).length);
218
301
  const text = reviewed != null ? reviewed : last ? String(last.content || '') : '';
219
302
  // 给用户的回答(第一百二十一轮):后端原样用它,不再另调一次模型重写 —— 重写的那一步照上一轮的选项编过「已写入文件」,其实一个都没写。
220
303
  // 只认这一次新说的、没出错没被打断的:历史那段后面跟着一句固定的「好的,前面的对话我当参考」,半路断了时 last 会是它(或者上一轮的旧回答)
221
- const own = [...ctx.messages.slice(before)].reverse().find((m) => m.role === 'assistant' && !(m.tool_calls || []).length);
222
- const conclusion = reviewed != null ? reviewed : !error && !controller.signal.aborted && own ? String(own.content || '').trim() : '';
304
+ // 而且必须是这一次「最后」说的那句:说了一句被推回去(核对 / 清单),后面接着调工具直到用完轮数 / 连着重复被停下 ——
305
+ // 那句被推回去的(往往正是「已写入文件」这种没做的说法)不是结论(第一百二十八轮 review)
306
+ const lastSaid = [...ctx.messages.slice(before)].reverse().find((m) => m.role === 'assistant');
307
+ const ownText = lastSaid && !(lastSaid.tool_calls || []).length ? String(lastSaid.content || '').trim() : '';
308
+ const rounds = ctx.messages.filter((m) => m.role === 'assistant' && (m.tool_calls || []).length).length;
309
+ // 到了时间预算(或出错)、模型没来得及写结论:照实说做到哪一步(第一百二十八轮)。原来交空的,后端就另调一次模型、照「这一轮没有改文件」编了一段 ——
310
+ // 线上那一次新建了 core.js、跑过测试,回答却说一个文件都没写、扯到上一轮的项目上
311
+ const stoppedEarly = !ownText || error || controller.signal.aborted;
312
+ const conclusion = reviewed != null ? reviewed : !stoppedEarly ? ownText
313
+ : unfinishedReport({ local, steps: ctx.steps || [], timedOut: controller.signal.aborted && !stopped, stopped, error, budgetMs: Number(run.timeoutMs) || 0,
314
+ exhausted: Boolean(turn && turn.exhausted), stalled: Boolean(turn && turn.stalled), maxRounds: ctx.maxRounds });
223
315
  // 给后端写最终回答用的上下文:和 Java 循环同一个样子(每个工具的结果一段),最后是这份循环自己的结论
224
316
  const names = new Map();
225
317
  for (const m of ctx.messages) for (const c of m.role === 'assistant' ? m.tool_calls || [] : []) names.set(c.id, c.function.name);
226
318
  const context = [...ctx.messages.filter((m) => m.role === 'tool').map((m) => `【工作区 ${names.get(m.tool_call_id) || '工具'}】\n${m.content}`),
227
- text ? `【代码 agent 的结论】\n${text}` : ''].filter(Boolean).join('\n\n');
319
+ conclusion ? `【代码 agent 的结论】\n${conclusion}` : ''].filter(Boolean).join('\n\n');
228
320
  // 调过几次写文件的工具(不管成没成):后端据此决定最终回答能不能说「这一轮没写成」
229
321
  const writeCalls = ctx.messages.reduce((n, m) => n + (m.role === 'assistant' ? (m.tool_calls || []).filter((c) => ['write_file', 'edit_file', 'apply_patch'].includes(c.function.name)).length : 0), 0);
230
322
  return { type: 'result', text, conclusion, context, drafts: local.draftList(), writeCalls, usage: ctx.usage,
231
- rounds: ctx.messages.filter((m) => m.role === 'assistant' && (m.tool_calls || []).length).length,
232
- aborted: controller.signal.aborted, error };
323
+ rounds,
324
+ aborted: controller.signal.aborted, error, ...(stopped ? { stopped: true } : {}) };
325
+ }
326
+
327
+ /**
328
+ * 没做完时交给用户的那段话:做到哪了(改了哪些文件、跑了什么、最后一步是什么),怎么接着做。只说真的发生了的 ——
329
+ * 改过的文件看草稿 / 产物的记录,跑过什么看步骤,不让模型另编。
330
+ */
331
+ export function unfinishedReport({ local, steps, timedOut, stopped = false, error, budgetMs, exhausted = false, stalled = false, maxRounds = 0 }) {
332
+ // 几种停法分开说:到时间、真出错、轮数用尽、连着重复同一个调用被停下。原来只有前两种,用完轮数时 error 是 null,回答里会出现「半路出错停下了:null」
333
+ // 用户在桌面上点了停(第一百二十九轮)也单说:不是到点,也不是出错
334
+ const why = stopped ? '这一轮被你停下了'
335
+ : timedOut ? `这一轮到了时间上限(${Math.round(budgetMs / 1000)} 秒),停在了半路`
336
+ : error ? `这一轮半路出错停下了:${error}`
337
+ : exhausted ? `这一轮用完了 ${maxRounds} 轮,停在了半路`
338
+ : stalled ? '这一轮停下了:模型连着发同一个调用,结果一直没变'
339
+ : '这一轮停在了半路';
340
+ // 生成到产物(ArtifactTools)写的是真的、记在 wrote;选了文件夹的是草稿、记在 drafts
341
+ const files = local.artifact ? [...(local.wrote || [])] : [...((local.drafts && local.drafts.keys()) || [])];
342
+ const lines = [`${why},还没写结论。`];
343
+ if (files.length) {
344
+ lines.push('', `已经${local.artifact ? '生成' : '改好(草稿,确认后才写进磁盘)'}的文件:${files.map((f) => `\`${f}\``).join('、')}`);
345
+ } else if (local.ranCommand) {
346
+ // auto 档的 shell 可能已经直接写了文件,这里看不出来 —— 不能断言「还没有改任何文件」
347
+ lines.push('', '跑过命令,改没改文件看不出来(见上面的步骤)。');
348
+ } else {
349
+ lines.push('', '还没有改任何文件。');
350
+ }
351
+ if (steps.length) {
352
+ // 只取第一行:shell 那条是整条命令原文,heredoc 里的 $…$ 会被网页当 Markdown / 公式渲染成乱码
353
+ const first = String(steps[steps.length - 1] || '').split('\n')[0].trim();
354
+ const shown = first.length > 160 ? `${first.slice(0, 160)}…` : first;
355
+ lines.push('', shown ? `做过的 ${steps.length} 步见上面;最后一步是:\`${shown.replace(/`/g, "'")}\``
356
+ : `做过的 ${steps.length} 步见上面。`);
357
+ }
358
+ lines.push('', '说「继续」我接着做(会先看一眼已经写了的,不从头来)。');
359
+ return lines.join('\n');
233
360
  }
234
361
 
235
362
  async function main() {
236
363
  const bridge = createBridge({ input: process.stdin, output: process.stdout });
364
+ // 桌面外壳退出时先 SIGTERM:和叫停一样中断、收掉后台命令、照实交 result(外壳等一会儿还没退才 SIGKILL)
365
+ process.on('SIGTERM', () => bridge.requestStop());
237
366
  const run = await bridge.nextRun();
238
367
  let last;
239
368
  try {
@@ -241,8 +370,8 @@ async function main() {
241
370
  } catch (e) {
242
371
  last = { type: 'fatal', message: String((e && e.message) || e) };
243
372
  }
244
- // 管道上的 stdout 是异步的:写完最后一行再退出,不然后端可能收不到 result
245
- process.stdout.write(`${JSON.stringify(last)}\n`, () => process.exit(0));
373
+ // 管道上的 stdout 是异步的:写完最后一行再退出,不然后端可能收不到 result。令牌照样不许出现(bridge.line 换掉)
374
+ process.stdout.write(`${bridge.line(last)}\n`, () => process.exit(0));
246
375
  }
247
376
 
248
377
  // 比真实路径(第九十六轮):import.meta.url 是解过软链的,argv[1] 不是 —— macOS 的临时目录 /var 是 /private/var 的软链,
@@ -12,7 +12,7 @@ process.stdin.on('end', () => {
12
12
  const req = JSON.parse(input);
13
13
  const env = req.env || {};
14
14
  if (req.probe) {
15
- process.stdout.write(JSON.stringify({ box: detectSandbox({ env, hosted: Boolean(req.hosted) }) }));
15
+ process.stdout.write(JSON.stringify({ box: detectSandbox({ env, hosted: Boolean(req.hosted), network: req.network }) }));
16
16
  return;
17
17
  }
18
18
  const box = detectSandbox({ env, probe: false, hosted: Boolean(req.hosted) });
package/src/prompt.js CHANGED
@@ -24,8 +24,8 @@ export const BUILTIN_SYSTEM_PROMPT = `你是 zhiqu,「知趣·象限」AI 办
24
24
  - 用户给的内容很长(日志、文档)时,命令行会把原文存成文件:先用 read_file / search 把和问题有关的部分读全,再下结论。
25
25
  - 收尾之前对照用户的原话逐条检查:每一条要求都做到了吗?里面的例子、边界情况(空的、重复的、顺序、出错的)都验证过了吗?有没有做了用户没要的?
26
26
 
27
- ## 少说、多做(用户看不到你调工具前写的字,只看得到结论和改动)
28
- - 调工具之前最多写一句话(接下来做什么)。不要把推测、自言自语、「让我重新想想」写出来 —— 想清楚了直接调工具。
27
+ ## 少说、多做(用户在看着:调工具前的那一句会马上显示,结论和改动也看得到)
28
+ - 每次调工具之前先用一句话说判断:看到了什么、接下来做什么、为什么。不超过 40 字。不写推测过程,不写自言自语(「让我重新想想」)。连着几次,每次一句,不重复上一句。
29
29
  - 拿不准原因时做实验:写一个最小的复现或检查脚本跑一下(或者临时加打印),用输出判断;不要反复读同一段代码猜。
30
30
  - 用户要你再跑一次、再看一次(「再跑一下」「现在呢」),就真的再调工具做一次 —— 文件可能已经变了,不要拿对话里上一次的结果回答。
31
31
  - 最后的回答只说结论和改了什么:哪个文件、改了哪里、怎么验证的、用户接下来要做什么。不复述过程,不说客套话。
package/src/replay.js CHANGED
@@ -7,6 +7,7 @@
7
7
  // 但用户翻回去要看的是当时说了什么。每一步的写法和当时一样(⏺ 做了什么、⎿ 结果的第一行),
8
8
  // 不是用户打的 user 消息(goal 模式推的下一轮、命令行补的说明)不显示成「› …」。
9
9
  import { describeCall, parseArgs, QUIET_TOOLS } from './agent.js';
10
+ import { judgmentText } from './steps.js';
10
11
  import { generatedOrigin } from './origins.js';
11
12
 
12
13
  const RESULT_CHARS = 120;
@@ -77,13 +78,17 @@ export function replayTranscript(ui, entries, { verbose = false, lastTurns = REP
77
78
  }
78
79
  if (m.role === 'assistant') {
79
80
  const text = textOf(m.content);
80
- const thinking = !verbose && (m.tool_calls || []).length > 0;
81
- if (text.trim() && !thinking) {
81
+ const calls = m.tool_calls || [];
82
+ // 安静模式:调工具前的那一句只留一行判断(第一百三十轮),不把整段推测铺出来。verbose 原样
83
+ if (calls.length && !verbose) {
84
+ const said = judgmentText(text);
85
+ if (said) ui.note(`· ${said}`);
86
+ } else if (text.trim()) {
82
87
  const md = ui.markdown();
83
88
  md.feed(text.endsWith('\n') ? text : `${text}\n`);
84
89
  md.finish();
85
90
  }
86
- for (const call of m.tool_calls || []) {
91
+ for (const call of calls) {
87
92
  const name = call.function && call.function.name;
88
93
  if (!verbose && QUIET_TOOLS.has(name)) { hiddenCalls.add(call.id); continue; }
89
94
  const parsed = parseArgs(call.function && call.function.arguments);