mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
263 lines
9.6 KiB
TypeScript
263 lines
9.6 KiB
TypeScript
// @effect-diagnostics nodeBuiltinImport:off globalTimers:off globalJsonInEffect:off globalConsole:off - a tiny stdio ACP agent spawned by the server; plain Node keeps it dependency-free.
|
|
/**
|
|
* A scripted stand-in for the `fx` CLI, registered as an Fx provider instance so the
|
|
* server streams deterministic replies with no model. A `[[eval:<script>]]` marker in
|
|
* the prompt picks the reply; see `scriptOf`. `hold` scripts wait for a release file
|
|
* named after the marker's key in `HANZO_EVAL_FX_CONTROL_DIR`.
|
|
*/
|
|
import * as NodeFS from "node:fs";
|
|
import * as NodePath from "node:path";
|
|
import * as NodeReadline from "node:readline";
|
|
|
|
const MODEL = "eval/scripted";
|
|
|
|
type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
|
|
interface Message {
|
|
readonly id?: number | string;
|
|
readonly method?: string;
|
|
readonly params?: { [key: string]: Json };
|
|
readonly result?: Json;
|
|
readonly error?: Json;
|
|
}
|
|
|
|
const controlDir = process.env.HANZO_EVAL_FX_CONTROL_DIR ?? "";
|
|
const send = (message: object) => process.stdout.write(`${JSON.stringify(message)}\n`);
|
|
const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
|
|
const update = (sessionId: string, value: object) =>
|
|
send({ jsonrpc: "2.0", method: "session/update", params: { sessionId, update: value } });
|
|
|
|
const select = (id: string, category: string, currentValue: string, values: string[]) => ({
|
|
id,
|
|
name: id,
|
|
category,
|
|
type: "select",
|
|
currentValue,
|
|
options: values.map((value) => ({ value, name: value })),
|
|
});
|
|
// The Fx adapter needs a mode option and the modes list; it sets mode and effort per session.
|
|
const configOptions = [
|
|
select("model", "model", MODEL, [MODEL]),
|
|
select("mode", "mode", "full-access", ["auto", "ask", "full-access"]),
|
|
select("effort", "thought_level", "auto", ["auto", "low", "medium", "high"]),
|
|
];
|
|
const modes = {
|
|
currentModeId: "full-access",
|
|
availableModes: ["auto", "ask", "full-access"].map((id) => ({ id, name: id })),
|
|
};
|
|
|
|
let nextOutgoingId = 1_000_000;
|
|
const pendingReplies = new Map<number, (message: Message) => void>();
|
|
const cancelled = new Set<string>();
|
|
let sessionCount = 0;
|
|
|
|
function request(method: string, params: object): Promise<Message> {
|
|
const id = nextOutgoingId++;
|
|
send({ jsonrpc: "2.0", id, method, params });
|
|
return new Promise((resolve) => pendingReplies.set(id, resolve));
|
|
}
|
|
|
|
/** Paragraphs of plain filler with a heading every fifth paragraph, so the feed lays out like a real reply. */
|
|
export function fillerText(words: number, seed = 0): string {
|
|
const vocabulary =
|
|
"the agent reads the file then edits the module and runs the focused test before it writes a short summary of what changed and why the change is safe".split(
|
|
" ",
|
|
);
|
|
const out: string[] = [];
|
|
let paragraph: string[] = [];
|
|
for (let index = 0; index < words; index++) {
|
|
paragraph.push(vocabulary[(index * 7 + seed) % vocabulary.length]!);
|
|
if (paragraph.length === 60 || index === words - 1) {
|
|
const count = out.length;
|
|
out.push(`${count % 5 === 0 ? `## Part ${count / 5 + 1}\n\n` : ""}${paragraph.join(" ")}.`);
|
|
paragraph = [];
|
|
}
|
|
}
|
|
return out.join("\n\n");
|
|
}
|
|
|
|
interface Script {
|
|
readonly kind: "reply" | "stream" | "hold" | "question" | "subagents" | "fail";
|
|
readonly words: number;
|
|
readonly chunkMs: number;
|
|
readonly key: string;
|
|
}
|
|
|
|
/** `[[eval:stream:3000:40]]` streams 3000 words in 40 ms chunks; `[[eval:hold:k]]` replies when `k` is released. */
|
|
export function scriptOf(prompt: string): Script {
|
|
const marker = /\[\[eval:([a-z]+)(?::([^\]:]+))?(?::([^\]:]+))?\]\]/.exec(prompt);
|
|
const kind = marker?.[1];
|
|
if (kind === "stream")
|
|
return {
|
|
kind,
|
|
words: Number(marker?.[2] ?? 3000),
|
|
chunkMs: Number(marker?.[3] ?? 40),
|
|
key: "",
|
|
};
|
|
if (kind === "hold" || kind === "subagents" || kind === "question")
|
|
return { kind, words: 40, chunkMs: 0, key: marker?.[2] ?? kind };
|
|
if (kind === "fail") return { kind, words: 0, chunkMs: 0, key: "" };
|
|
return { kind: "reply", words: 40, chunkMs: 0, key: "" };
|
|
}
|
|
|
|
async function waitForRelease(sessionId: string, key: string) {
|
|
const file = NodePath.join(controlDir, `release-${key}`);
|
|
while (!cancelled.has(sessionId) && !NodeFS.existsSync(file)) await sleep(100);
|
|
}
|
|
|
|
async function streamText(sessionId: string, text: string, chunkMs: number, messageId: string) {
|
|
const tokens = text.split(/(?<= )/);
|
|
for (let index = 0; index < tokens.length; index += 4) {
|
|
if (cancelled.has(sessionId)) return;
|
|
update(sessionId, {
|
|
sessionUpdate: "agent_message_chunk",
|
|
messageId,
|
|
content: { type: "text", text: tokens.slice(index, index + 4).join("") },
|
|
});
|
|
if (chunkMs > 0) await sleep(chunkMs);
|
|
}
|
|
}
|
|
|
|
async function runPrompt(sessionId: string, prompt: string, turn: number): Promise<object> {
|
|
const script = scriptOf(prompt);
|
|
const messageId = `${sessionId}-m${turn}`;
|
|
if (script.kind === "fail") throw new Error("Scripted provider failure.");
|
|
if (script.kind === "hold") await waitForRelease(sessionId, script.key);
|
|
if (script.kind === "question") {
|
|
const reply = await request("elicitation/create", {
|
|
sessionId,
|
|
mode: "form",
|
|
message: "Which option should I use?",
|
|
requestedSchema: {
|
|
type: "object",
|
|
properties: {
|
|
choice: {
|
|
type: "string",
|
|
title: "Option",
|
|
description: "Which option should I use?",
|
|
enum: ["First", "Second"],
|
|
},
|
|
},
|
|
required: ["choice"],
|
|
},
|
|
});
|
|
if (reply.error) return { stopReason: "cancelled" };
|
|
}
|
|
if (script.kind === "subagents") {
|
|
for (const name of ["one", "two"]) {
|
|
const toolCallId = `${sessionId}-sub-${name}-${turn}`;
|
|
update(sessionId, {
|
|
sessionUpdate: "tool_call",
|
|
toolCallId,
|
|
name: "subagent",
|
|
title: `Subagent · read ${name}`,
|
|
kind: "other",
|
|
status: "pending",
|
|
rawInput: { request: { action: "run", task: `Read file ${name}` } },
|
|
});
|
|
update(sessionId, { sessionUpdate: "tool_call_update", toolCallId, status: "in_progress" });
|
|
}
|
|
await waitForRelease(sessionId, script.key);
|
|
for (const name of ["one", "two"])
|
|
update(sessionId, {
|
|
sessionUpdate: "tool_call_update",
|
|
toolCallId: `${sessionId}-sub-${name}-${turn}`,
|
|
status: "completed",
|
|
content: [
|
|
{
|
|
type: "content",
|
|
// A long reply gives the child thread something to scroll.
|
|
content: {
|
|
type: "text",
|
|
text: JSON.stringify({ ok: true, result: fillerText(1500, turn) }),
|
|
},
|
|
},
|
|
],
|
|
});
|
|
}
|
|
if (cancelled.has(sessionId)) return { stopReason: "cancelled" };
|
|
await streamText(sessionId, fillerText(script.words, turn), script.chunkMs, messageId);
|
|
return { stopReason: cancelled.has(sessionId) ? "cancelled" : "end_turn" };
|
|
}
|
|
|
|
const turns = new Map<string, number>();
|
|
|
|
async function handle(message: Message) {
|
|
if (message.method === undefined) {
|
|
if (typeof message.id === "number") pendingReplies.get(message.id)?.(message);
|
|
return;
|
|
}
|
|
const reply = (result: object) => send({ jsonrpc: "2.0", id: message.id, result });
|
|
const params = message.params ?? {};
|
|
const sessionId = typeof params.sessionId === "string" ? params.sessionId : "";
|
|
switch (message.method) {
|
|
case "initialize":
|
|
return reply({
|
|
protocolVersion: 1,
|
|
agentCapabilities: {
|
|
loadSession: true,
|
|
promptCapabilities: { image: true, audio: false, embeddedContext: true },
|
|
mcpCapabilities: { http: true, sse: true, acp: true },
|
|
sessionCapabilities: { list: {}, resume: {}, close: {}, systemPrompt: {} },
|
|
},
|
|
agentInfo: { name: "fx", title: "fx", version: "0.0.14" },
|
|
authMethods: [],
|
|
});
|
|
case "session/new": {
|
|
sessionCount += 1;
|
|
const sessionId = `eval-session-${process.pid}-${sessionCount}`;
|
|
return reply({ sessionId, configOptions, modes });
|
|
}
|
|
case "session/load":
|
|
case "session/resume":
|
|
return reply({ configOptions, modes });
|
|
case "session/set_config_option":
|
|
return reply({ configOptions });
|
|
case "session/cancel":
|
|
cancelled.add(sessionId);
|
|
return;
|
|
case "session/prompt": {
|
|
cancelled.delete(sessionId);
|
|
const turn = (turns.get(sessionId) ?? 0) + 1;
|
|
turns.set(sessionId, turn);
|
|
const blocks = Array.isArray(params.prompt) ? params.prompt : [];
|
|
const text = blocks
|
|
.map((block) =>
|
|
block && typeof block === "object" && !Array.isArray(block) ? block.text : "",
|
|
)
|
|
.filter((value) => typeof value === "string")
|
|
.join("\n");
|
|
try {
|
|
return reply(await runPrompt(sessionId, text, turn));
|
|
} catch (error) {
|
|
return send({
|
|
jsonrpc: "2.0",
|
|
id: message.id,
|
|
error: { code: -32603, message: error instanceof Error ? error.message : String(error) },
|
|
});
|
|
}
|
|
}
|
|
default:
|
|
if (message.id !== undefined) return reply({});
|
|
}
|
|
}
|
|
|
|
function main(args: ReadonlyArray<string>) {
|
|
const probes: Record<string, string> = {
|
|
"--version": "fx 0.0.14",
|
|
status: JSON.stringify({ auth: "eval", model: MODEL }),
|
|
models: JSON.stringify({ ids: [MODEL] }),
|
|
};
|
|
const probe = probes[args[0] ?? ""];
|
|
if (probe !== undefined) return console.log(probe);
|
|
if (args[0] !== "acp") {
|
|
console.error(`fake-fx: unsupported command ${args.join(" ")}`);
|
|
process.exitCode = 2;
|
|
return;
|
|
}
|
|
NodeReadline.createInterface({ input: process.stdin }).on("line", (line) => {
|
|
if (line.trim()) void handle(JSON.parse(line) as Message);
|
|
});
|
|
}
|
|
|
|
if (import.meta.main) main(process.argv.slice(2));
|