@visual-z/xeno 0.8.4 → 0.9.0

package/src/runtime/acp-agent.ts

@@ -1,289 +0,0 @@
-/** ACP is a transport over the existing session owner, never a second agent loop (Q24/D8). */
-import { isAbsolute, resolve } from "node:path";
-import { agent, PROTOCOL_VERSION, RequestError, type AgentApp, type AgentConnection, type AgentContext,
-  type ClientCapabilities, type ContentBlock, type ElicitationPropertySchema, type McpServer,
-  type SessionModeState, type SessionUpdate, type StopReason, type ToolCall, type RequestPermissionResponse } from "@agentclientprotocol/sdk";
-import { CONTROL_SCHEMA } from "../core/control-protocol.ts";
-import { parseMcpServers, type McpServers } from "../core/mcp-config.ts";
-import type { LogEvent } from "../core/events.ts";
-import type { QuestionRequest, QuestionReply } from "../core/question.ts";
-import type { ExecutionOutcome } from "../core/outcome.ts";
-import type { PendingApproval, SessionControl } from "./session-control.ts";
-import type { ApprovalChoice } from "./tools.ts";
-import type { SessionHub } from "./session-hub.ts";
-
-function invalid(message: string): never { throw RequestError.invalidParams(undefined, message); }
-function object(value: unknown): Record<string, unknown> | undefined {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-/** Normalize explicit client configuration; annotations and tool output cannot configure processes. */
-export function acpMcpServers(servers: readonly McpServer[]): McpServers {
-  const result: Record<string, unknown> = Object.create(null);
-  for (const server of servers) {
-    if (Object.hasOwn(result, server.name)) invalid("MCP server names must be unique");
-    if ("type" in server) {
-      if (server.type !== "http") invalid("This agent supports stdio and HTTP MCP servers only");
-      result[server.name] = { transport: "http", url: server.url, headers: pairs(server.headers) };
-    } else result[server.name] = { transport: "stdio", command: server.command, args: [...server.args], env: pairs(server.env) };
-  }
-  try { return parseMcpServers(result); } catch { return invalid("Invalid MCP server configuration"); }
-}
-function pairs(values: readonly { name: string; value: string }[]): Record<string, string> {
-  const result: Record<string, string> = Object.create(null);
-  for (const value of values) {
-    if (Object.hasOwn(result, value.name)) invalid("Duplicate MCP environment or header name");
-    result[value.name] = value.value;
-  }
-  return result;
-}
-function modes(control: SessionControl): SessionModeState | undefined {
-  return control.configureWorkflow ? { currentModeId: control.session.config.tools.workflowMode ?? "build", availableModes: [
-    { id: "build", name: "Build", description: "Implement and verify workspace changes." },
-    { id: "plan", name: "Plan", description: "Inspect and plan with read-only tools." },
-  ] } : undefined;
-}
-function promptText(blocks: readonly ContentBlock[]): string {
-  const parts = blocks.map(block => {
-    if (block.type === "text") return block.text;
-    // Baseline resource links remain references. Reading them goes through the normal tool admission.
-    if (block.type === "resource_link") return `Resource ${JSON.stringify(block.name)}: ${JSON.stringify(block.uri)}${block.description ? `\n${block.description}` : ""}`;
-    if (block.type === "resource" && "text" in block.resource) return `Resource ${JSON.stringify(block.resource.uri)}:\n${block.resource.text}`;
-    return invalid("This agent accepts text, resource links and embedded text; image/audio/binary prompts are unavailable");
-  });
-  const text = parts.join("\n\n");
-  if (!text.trim() || Buffer.byteLength(text) > CONTROL_SCHEMA.limits.frameBytes) invalid("Prompt must contain text within the ACP message limit");
-  return text;
-}
-function stopReason(outcome: ExecutionOutcome | undefined, cancelled: boolean): StopReason {
-  if (cancelled || outcome?.status === "cancelled") return "cancelled";
-  if (outcome?.reason === "model_refusal") return "refusal";
-  if (outcome?.reason === "output_limit") return "max_tokens";
-  if (outcome?.status === "completed") return "end_turn";
-  if (outcome?.status === "stopped") return "max_turn_requests";
-  throw RequestError.internalError(undefined, "The session failed or its termination is unknown; inspect the durable outcome");
-}
-function title(name: string, input: unknown): string {
-  const raw = object(input), detail = raw?.["cmd"] ?? raw?.["command"] ?? raw?.["path"];
-  return typeof detail === "string" ? `${name}: ${detail}` : name;
-}
-function kind(name: string): ToolCall["kind"] {
-  if (["read", "diff"].includes(name)) return "read";
-  if (["write", "edit", "apply_patch", "format"].includes(name)) return "edit";
-  if (["bash", "exec_command", "write_stdin"].includes(name)) return "execute";
-  if (["search", "glob", "grep"].includes(name)) return "search";
-  if (["webfetch", "websearch"].includes(name)) return "fetch";
-  return "other";
-}
-function content(text: string) { return [{ type: "content" as const, content: { type: "text" as const, text } }]; }
-
-/** SDK cancellation is cooperative; a peer ignoring it cannot hold the tool owner indefinitely. */
-async function cancellable<T>(request: Promise<T>, signal: AbortSignal): Promise<T | undefined> {
-  if (signal.aborted) { void request.catch(() => {}); return undefined; }
-  let cancel = () => {};
-  const aborted = new Promise<undefined>(done => { cancel = () => done(undefined); signal.addEventListener("abort", cancel, { once: true }); });
-  try { return await Promise.race([request, aborted]); } finally { signal.removeEventListener("abort", cancel); }
-}
-
-async function elicit(client: AgentContext, sessionId: string, toolCallId: string, request: QuestionRequest, signal: AbortSignal): Promise<QuestionReply | undefined> {
-  const properties: Record<string, ElicitationPropertySchema> = Object.create(null), required: string[] = [];
-  request.questions.forEach((question, index) => {
-    const key = `q${index}`, options = question.options.map(option => ({ const: option.id, title: option.label,
-      ...(option.description ? { description: option.description } : {}) }));
-    if (options.length) {
-      properties[key] = question.multiple ? { type: "array", title: question.header, description: question.question,
-        items: { anyOf: options }, minItems: question.custom ? 0 : 1, maxItems: options.length } :
-        { type: "string", title: question.header, description: question.question, oneOf: options };
-      if (!question.custom) required.push(key);
-    }
-    if (question.custom || !options.length) {
-      properties[`${key}_text`] = { type: "string", title: `${question.header}: your answer`, description: question.question, minLength: 1 };
-      if (!options.length) required.push(`${key}_text`);
-    }
-  });
-  const response = await cancellable(client.request("elicitation/create", { sessionId, toolCallId, mode: "form",
-    message: request.questions.map(question => question.question).join("\n"), requestedSchema: { type: "object", properties, required } },
-    { cancellationSignal: signal }), signal);
-  if (response?.action !== "accept") return undefined;
-  const answers = object(response["content"]);
-  if (!answers || Object.keys(answers).some(key => !Object.hasOwn(properties, key))) return undefined;
-  return { request_id: request.request_id, turn_id: request.turn_id, answers: request.questions.map((question, index) => {
-    const value = answers[`q${index}`], text = answers[`q${index}_text`];
-    return { id: question.id, choices: typeof value === "string" ? [value] : Array.isArray(value) && value.every(item => typeof item === "string") ? value : [],
-      ...(typeof text === "string" && text.trim() ? { text } : {}) };
-  }) };
-}
-
-interface Binding {
-  control: SessionControl;
-  abort: AbortController | null;
-  pending: Map<string, ToolCall>;
-  send(update: SessionUpdate): void;
-  replay(node: number, event: LogEvent): void;
-  drain(): Promise<void>;
-  close(): void;
-}
-
-/** One AgentApp serves one client connection. Each workspace has an explicit host-owned hub. */
-export function createAcpAgent(hub: SessionHub): AgentApp {
-  const app = agent({ name: "xeno" }), bindings = new Map<string, Binding>();
-  let connection: AgentConnection | undefined, initialized = false, capabilities: ClientCapabilities = {};
-  let inFlight = 0;
-  const admit = async <T>(operation: () => Promise<T>): Promise<T> => {
-    // Assumed ingress cap: SDK schema validation bounds frames, not concurrent async handlers.
-    if (inFlight >= CONTROL_SCHEMA.limits.queuedRequests) throw RequestError.invalidRequest(undefined, "ACP request concurrency limit exceeded");
-    inFlight++; try { return await operation(); } finally { inFlight--; }
-  };
-  const requireInitialized = () => { if (!initialized || !connection || connection.signal.aborted) throw RequestError.invalidRequest(undefined, "initialize must complete before session requests"); };
-  const workspace = (params: { cwd: string; additionalDirectories?: string[]; mcpServers: McpServer[] }) => {
-    requireInitialized();
-    if (!isAbsolute(params.cwd) || resolve(params.cwd) !== resolve(hub.initial.session.config.tools.root))
-      invalid("cwd must match this agent process workspace; start one process per workspace");
-    if (params.additionalDirectories?.length) invalid("Additional workspace directories are unavailable");
-    return { cwd: params.cwd, acpMcpServers: acpMcpServers(params.mcpServers) };
-  };
-  const get = (id: string) => { requireInitialized(); const value = bindings.get(id); if (!value) throw RequestError.resourceNotFound(id); return value; };
-  const bind = (control: SessionControl): Binding => {
-    const existing = bindings.get(control.threadId); if (existing) return existing;
-    const peer = connection!;
-    let queuedBytes = 0, tail: Promise<void> = Promise.resolve(), deliveryError: unknown;
-    const pending = new Map<string, ToolCall>(), originalInputs = new Map<string, unknown>();
-    const send = (update: SessionUpdate) => {
-      const bytes = Buffer.byteLength(JSON.stringify(update)); queuedBytes += bytes;
-      if (bytes > CONTROL_SCHEMA.limits.frameBytes || queuedBytes > CONTROL_SCHEMA.limits.outputBytes) { peer.close(Error("ACP output queue exceeded its limit")); return; }
-      tail = tail.then(async () => { if (deliveryError) return; await peer.client.notify("session/update", { sessionId: control.threadId, update }); })
-        .catch(error => { deliveryError = error; peer.close(Error("ACP notification delivery failed")); })
-        .finally(() => { queuedBytes -= bytes; });
-    };
-    const record = (node: number, event: LogEvent, replay = false) => {
-      if (event.t === "user" && replay) send({ sessionUpdate: "user_message_chunk", content: { type: "text", text: event.text }, messageId: `${node}:${event.id}` });
-      if (event.t === "assistant" && replay) for (const block of event.blocks) if (block.type === "text")
-        send({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: block.text }, messageId: `${node}:${event.id}` });
-      if (event.t === "assistant") for (const block of event.blocks) if (block.type === "tool_use") originalInputs.set(`${node}:${block.call_id}`, block.input);
-      if (event.t === "tool_invocation") {
-        // Unchanged direct calls omit inline input; recover it from the original model request.
-        const key = `${node}:${event.call_id}`, input = event.input ?? originalInputs.get(key); originalInputs.delete(key);
-        const call: ToolCall = { toolCallId: `${node}:${event.id}`, name: event.name, title: title(event.name, input), kind: kind(event.name)!, status: "pending",
-          ...(input !== undefined ? { rawInput: input } : {}) };
-        pending.set(`${node}:${event.call_id}`, call); send({ sessionUpdate: "tool_call", ...call });
-      }
-      if (event.t === "tool_result") {
-        const key = `${node}:${event.call_id}`, call = pending.get(key);
-        if (!call) {
-          send({ sessionUpdate: "tool_call", toolCallId: `${node}:${event.id}`, title: "Recorded tool result", status: "pending" });
-        }
-        send({ sessionUpdate: "tool_call_update", toolCallId: call?.toolCallId ?? `${node}:${event.id}`,
-          status: event.ok && (!event.outcome || event.outcome.status === "completed") ? "completed" : "failed", content: content(event.content), rawOutput: event.data ?? event.content });
-        pending.delete(key);
-      }
-    };
-    const permission = async (approval: PendingApproval) => {
-      const abort = binding.abort; if (!abort || abort.signal.aborted || peer.signal.aborted) return;
-      const request = approval.request;
-      const matches = [...pending.values()].filter(call => call.name === request.tool &&
-        (!request.command || object(call.rawInput)?.["cmd"] === request.command || object(call.rawInput)?.["command"] === request.command));
-      const call = matches.length === 1 ? matches[0]! : undefined;
-      const toolCall = { toolCallId: call?.toolCallId ?? `permission:${approval.id}`, name: request.tool,
-        title: title(request.tool, request), status: "pending" as const,
-        rawInput: call?.rawInput ?? request, ...(request.paths ? { locations: request.paths.map(path => ({ path: resolve(control.session.config.tools.root, path) })) } : {}) };
-      if (!call) send({ sessionUpdate: "tool_call", ...toolCall });
-      let choice: ApprovalChoice = "deny";
-      try {
-        await binding.drain();
-        if (abort.signal.aborted || peer.signal.aborted) return;
-        const response = await cancellable(peer.client.request<RequestPermissionResponse>("session/request_permission", { sessionId: control.threadId, toolCall,
-          options: [{ optionId: "once", name: "Allow once", kind: "allow_once" }, { optionId: "deny", name: "Reject", kind: "reject_once" }] },
-          { cancellationSignal: abort.signal }), abort.signal);
-        if (response?.outcome.outcome === "selected" && response.outcome.optionId === "once") choice = "once";
-      } catch { /* A failed permission request denies the original invocation; never retry it. */ }
-      if (!abort.signal.aborted && control.activeTurnId === approval.turnId) {
-        try { control.respond(approval.turnId, approval.id, choice); } catch { /* another legitimate client/cancel already resolved it */ }
-      }
-      if (!call) send({ sessionUpdate: "tool_call_update", toolCallId: toolCall.toolCallId, status: choice === "once" ? "completed" : "failed" });
-    };
-    const previousAsk = control.session.config.tools.askSlot?.current;
-    const ask = (request: Parameters<SessionControl["ask"]>[0]) => control.ask(request);
-    const askSlot = control.session.config.tools.askSlot;
-    if (askSlot) askSlot.current = ask;
-    const slot = control.questionSlot, previousQuestion = slot.current;
-    const question = (request: QuestionRequest, signal: AbortSignal) => control.askQuestion(request, signal,
-      value => elicit(peer.client, control.threadId, pending.get(`${control.session.state.node}:${value.call_id}`)?.toolCallId ?? value.call_id, value, signal));
-    // Capability negotiation must precede installation; unsupported form questions fail explicitly.
-    if (capabilities.elicitation?.form != null) slot.current = question;
-    const unsubscribe = control.subscribe(notice => {
-      if (notice.method === "approval/request") void permission(notice.params["approval"] as PendingApproval);
-      if (notice.method === "item/completed") {
-        const item = notice.params["item"] as { id: string; node: number };
-        const event = control.session.state.events.find(value => value.id === item.id);
-        if (event) record(item.node, event);
-      }
-    });
-    const binding: Binding = { control, abort: null, pending, send, replay: (node, event) => record(node, event, true), drain: async () => { await tail; if (deliveryError) throw RequestError.internalError(undefined, "ACP notification delivery failed"); },
-      close: () => { binding.abort?.abort(); if (control.activeTurnId && binding.abort) control.interrupt(control.activeTurnId); unsubscribe();
-        if (askSlot?.current === ask) { if (previousAsk) askSlot.current = previousAsk; else delete askSlot.current; }
-        if (slot.current === question) { if (previousQuestion) slot.current = previousQuestion; else delete slot.current; }
-      } };
-    bindings.set(control.threadId, binding);
-    return binding;
-  };
-  app.onConnect(peer => {
-    if (connection && !connection.signal.aborted) throw Error("ACP AgentApp already has a client connection");
-    connection = peer; initialized = false; capabilities = {};
-    peer.signal.addEventListener("abort", () => { for (const binding of bindings.values()) binding.close(); bindings.clear(); }, { once: true });
-  });
-  app.onRequest("initialize", ({ params }) => {
-    if (initialized) throw RequestError.invalidRequest(undefined, "Connection is already initialized");
-    if (params.protocolVersion < 1) invalid("ACP protocol version 1 is required");
-    capabilities = params.clientCapabilities ?? {}; initialized = true;
-    return { protocolVersion: PROTOCOL_VERSION, agentInfo: { name: "xeno", version: "0.1.0" },
-      agentCapabilities: { loadSession: true, promptCapabilities: { embeddedContext: true }, mcpCapabilities: { http: true }, sessionCapabilities: { close: {} } } };
-  });
-  app.onRequest("session/new", ({ params, signal }) => admit(async () => {
-    const forwarded = workspace(params), control = await hub.open("new", forwarded);
-    if (signal.aborted || connection!.signal.aborted) { await hub.close(control.threadId); throw RequestError.requestCancelled(); }
-    bind(control); const state = modes(control);
-    return { sessionId: control.threadId, ...(state ? { modes: state } : {}) };
-  }));
-  app.onRequest("session/load", ({ params, signal }) => admit(async () => {
-    const forwarded = workspace(params), control = await hub.open("resume", { ...forwarded, session: params.sessionId });
-    if (signal.aborted || connection!.signal.aborted) throw RequestError.requestCancelled();
-    if (control.busy) throw RequestError.invalidRequest(undefined, "Cannot replay a session with an active turn");
-    const binding = bind(control);
-    // Replay durable original messages/results only. Loading never executes tools or sends provider requests.
-    for (const { node, event } of await control.items()) { binding.replay(node, event); await binding.drain(); }
-    await binding.drain(); const state = modes(control); return state ? { modes: state } : {};
-  }));
-  app.onRequest("session/prompt", ({ params, signal }) => admit(async () => {
-    const binding = get(params.sessionId), control = binding.control, input = promptText(params.prompt);
-    if (control.busy || binding.abort) throw RequestError.invalidRequest(undefined, "A prompt is already running for this session");
-    const abort = new AbortController(); binding.abort = abort; binding.pending.clear();
-    const signals = AbortSignal.any([signal, abort.signal, connection!.signal]);
-    let outcome: ExecutionOutcome | undefined;
-    try {
-      for await (const event of control.send(input, signals)) {
-        // Emit committed model text once. Provider retry/discard deltas cannot become durable conversation.
-        if (event.kind === "assistant_text" && event.text) { binding.send({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: event.text } }); await binding.drain(); }
-        if (event.kind === "done") outcome = event.outcome;
-      }
-      await binding.drain(); return { stopReason: stopReason(outcome, signals.aborted) };
-    } catch {
-      if (signals.aborted) return { stopReason: "cancelled" as const };
-      throw RequestError.internalError(undefined, "Session prompt failed; inspect its durable outcome before continuing");
-    } finally { binding.abort = null; binding.pending.clear(); }
-  }));
-  app.onNotification("session/cancel", ({ params }) => {
-    const binding = get(params.sessionId); binding.abort?.abort();
-    if (binding.abort && binding.control.activeTurnId) binding.control.interrupt(binding.control.activeTurnId);
-  });
-  app.onRequest("session/set_mode", ({ params }) => admit(async () => {
-    const binding = get(params.sessionId), control = binding.control;
-    if (params.modeId !== "plan" && params.modeId !== "build") invalid("Unknown session mode");
-    if (!control.configureWorkflow) throw RequestError.methodNotFound("session/set_mode");
-    if (control.busy) throw RequestError.invalidRequest(undefined, "Mode changes require an idle checkpoint");
-    await control.configureWorkflow(params.modeId); binding.send({ sessionUpdate: "current_mode_update", currentModeId: params.modeId }); await binding.drain(); return {};
-  }));
-  app.onRequest("session/close", ({ params }) => admit(async () => {
-    const binding = get(params.sessionId); binding.close(); bindings.delete(params.sessionId); await hub.close(binding.control.threadId); return {};
-  }));
-  return app;
-}

package/src/runtime/agent-profiles.ts

@@ -1,21 +0,0 @@
-/** R13: configuration loading is separate from applying a role to a live Session. */
-import { join } from "node:path";
-import { configDir } from "../store/config.ts";
-import { readAgentProfileFile } from "../store/agent-profile-files.ts";
-import { parseAgentProfiles, type AgentProfileLayer } from "../core/agent-profile.ts";
-
-export async function loadAgentProfileLayers(options: { readonly workspace: string; readonly trustProject: boolean; readonly userDir?: string }):
-  Promise<{ readonly layers: readonly AgentProfileLayer[]; readonly diagnostics: readonly string[] }> {
-  const paths = [{ kind: "user" as const, path: join(options.userDir ?? configDir(), "agents.json") },
-    ...(options.trustProject ? [{ kind: "project" as const, path: join(options.workspace, ".xeno", "agents.json") }] : [])];
-  const layers: AgentProfileLayer[] = [], diagnostics: string[] = [];
-  for (const source of paths) {
-    const file = await readAgentProfileFile(source.path);
-    if (!file) continue;
-    if (file.diagnostic) { diagnostics.push(file.diagnostic); continue; }
-    const parsed = parseAgentProfiles(file.value);
-    diagnostics.push(...parsed.diagnostics.map(diagnostic => `${source.path}: ${diagnostic}`));
-    if (parsed.diagnostics.length === 0) layers.push({ source, profiles: parsed.profiles });
-  }
-  return { layers, diagnostics };
-}