@dyx9/rosetta 0.0.0-stage → 0.0.1

package/build/server/agent/conversation.js

@@ -0,0 +1,244 @@
+/**
+ * Conversation turns, independent of any transport.
+ *
+ * A caller admits a request, delivers progress however it can, and receives one
+ * final result. HTTP (http/chat.ts) is one such caller; tests call this directly.
+ */
+import { SESSION_NOT_FOUND, } from "./sessions.js";
+import { startTurnRecording, } from "../records/turn-recording.js";
+import { TurnError, stopResult, validTurnId, } from "./turn.js";
+export const DEFAULT_TURN_LIMITS = {
+    timeoutMs: 180_000,
+    abortGraceMs: 5_000,
+};
+export const MAX_MESSAGE_CHARS = 32_000;
+const REJECTIONS = {
+    invalid_message: "A message between 1 and 32,000 characters is required",
+    invalid_turn_id: "A valid turnId is required",
+    session_not_found: SESSION_NOT_FOUND,
+    session_busy: "This session is already answering",
+    turn_id_reused: "This turnId has already been used",
+};
+const rejection = (reason) => ({
+    reason,
+    message: REJECTIONS[reason],
+});
+const rejected = (reason) => ({
+    accepted: false,
+    rejection: rejection(reason),
+});
+/** Decides whether a question may start. The turn it admits does the rest. */
+export class Conversations {
+    #sessions;
+    #services;
+    constructor(sessions, recordings, operations, limits = DEFAULT_TURN_LIMITS) {
+        this.#sessions = sessions;
+        this.#services = { sessions, recordings, operations, limits };
+    }
+    /** Early check before a transport waits for the full request. Admission checks again. */
+    eligibility(sessionId) {
+        const session = this.#sessions.find(sessionId);
+        if (!session)
+            return rejection("session_not_found");
+        if (session.busy)
+            return rejection("session_busy");
+        return undefined;
+    }
+    /** Validates the request against the session's current state and takes exclusive ownership of its turn. */
+    admit(request) {
+        const message = typeof request.message === "string" ? request.message.trim() : "";
+        if (!message || message.length > MAX_MESSAGE_CHARS)
+            return rejected("invalid_message");
+        if (!validTurnId(request.turnId))
+            return rejected("invalid_turn_id");
+        const session = this.#sessions.find(request.sessionId);
+        if (!session)
+            return rejected("session_not_found");
+        if (session.turnRecordings.has(request.turnId))
+            return rejected("turn_id_reused");
+        const turn = session.beginTurn(request.turnId);
+        if (!turn)
+            return rejected("session_busy");
+        const recording = startTurnRecording(session.recording, message);
+        session.turnRecordings.set(request.turnId, recording);
+        return {
+            accepted: true,
+            turn: new AcceptedTurn(this.#services, session, turn, message, recording),
+        };
+    }
+}
+/**
+ * An admitted turn owns its session until it finishes. Admission starts the deadline
+ * and run() starts the agent. A turn cancelled before run() still finishes: it is
+ * recorded and releases its session without the agent being asked.
+ */
+export class AcceptedTurn {
+    id;
+    #services;
+    #session;
+    #turn;
+    #message;
+    #recording;
+    #result;
+    /** Called by run(); until then the turn waits, or finishes if it is cancelled. */
+    #start;
+    #deadline;
+    /** True once the agent has been asked; only then does a cancel have to stop it. */
+    #agentStarted = false;
+    /** False once the result is decided; anything the agent sends after that is dropped. */
+    #forwarding = true;
+    #replyChars = 0;
+    #tools = new Set();
+    constructor(services, session, turn, message, recording) {
+        this.id = turn.id;
+        this.#services = services;
+        this.#session = session;
+        this.#turn = turn;
+        this.#message = message;
+        this.#recording = recording;
+        const start = new Promise((resolve) => {
+            this.#start = resolve;
+        });
+        this.#deadline = setTimeout(() => turn.cancel("timeout"), services.limits.timeoutMs);
+        this.#result = Promise.race([start, turn.cancelled]).then((onProgress) => this.#run(onProgress ?? (() => { })));
+        // A caller may abandon this turn without ever observing its result.
+        void this.#result.catch((error) => {
+            console.error("Turn finalization failed", error);
+        });
+    }
+    /** Cancels this turn only; no effect once it has finished. */
+    cancel(reason) {
+        if (this.#session.activeTurn === this.#turn)
+            this.#turn.cancel(reason);
+    }
+    /**
+     * Resolves with the single final result after recording, measurement, and session
+     * release. Progress stops before it resolves; repeated calls share the one result.
+     */
+    run(onProgress = () => { }) {
+        this.#start(onProgress);
+        return this.#result;
+    }
+    /** One pass: the question unless already cancelled, a stop if it is cancelled, then the record and the release. */
+    async #run(onProgress) {
+        const { sessions } = this.#services;
+        const turn = this.#turn;
+        let result = {
+            outcome: "failed",
+            message: "The response could not be completed.",
+        };
+        try {
+            if (turn.stopReason) {
+                result = stopResult(turn.stopReason);
+                return result;
+            }
+            const asked = this.#ask(onProgress);
+            const answer = await Promise.race([asked, turn.cancelled]);
+            if (turn.stopReason) {
+                this.#forwarding = false;
+                result = stopResult(turn.stopReason);
+                if (this.#agentStarted && !(await this.#stopAgent(asked))) {
+                    sessions.destroy(this.#session.id, "unresponsive_agent");
+                    result.message +=
+                        " This session was ended; start a new conversation to continue.";
+                }
+            }
+            else if (answer)
+                result = answer;
+        }
+        catch (error) {
+            result = {
+                outcome: "failed",
+                message: error instanceof Error ? error.message : "The response failed.",
+            };
+            sessions.destroy(this.#session.id, "response_failure");
+        }
+        finally {
+            this.#forwarding = false;
+            clearTimeout(this.#deadline);
+            try {
+                this.#record(result);
+            }
+            finally {
+                this.#session.endTurn(turn);
+            }
+        }
+        return result;
+    }
+    /** Asks the agent and resolves with what happened. Never rejects. */
+    #ask(onProgress) {
+        const turn = this.#turn;
+        // Started on a later tick, so a turn cancelled straight after run() never reaches the agent.
+        return Promise.resolve()
+            .then(async () => {
+            if (turn.stopReason)
+                return stopResult(turn.stopReason);
+            this.#agentStarted = true;
+            await this.#session.agent.ask(this.#message, (event) => this.#forward(event, onProgress), (event) => {
+                if (this.#forwarding && !turn.stopReason)
+                    this.#recording.event(event);
+            });
+            return { outcome: "completed" };
+        })
+            .catch((error) => ({
+            outcome: error instanceof TurnError ? error.outcome : "failed",
+            message: error instanceof Error ? error.message : "The agent failed.",
+        }));
+    }
+    /** Passes one progress event on, unless the result is already decided. */
+    #forward(event, onProgress) {
+        if (!this.#forwarding || this.#turn.stopReason)
+            return;
+        if (event.t === "delta")
+            this.#replyChars += event.text.length;
+        if (event.t === "tool" && event.state === "running")
+            this.#tools.add(event.name);
+        // A recipient that cannot take progress has gone, so its turn ends as a disconnect.
+        try {
+            onProgress(event);
+        }
+        catch (error) {
+            console.error("Turn progress delivery failed", error);
+            this.#turn.cancel("disconnected");
+        }
+    }
+    /**
+     * Stops the agent after a cancel. Both the question and the abort must settle
+     * before the agent can take another question; false means they did not within
+     * the grace period, or the abort itself failed.
+     */
+    async #stopAgent(asked) {
+        const stopped = Promise.resolve()
+            .then(() => this.#session.agent.abort())
+            .then(() => asked)
+            .then(() => true, () => false);
+        let grace;
+        const outOfTime = new Promise((resolve) => {
+            grace = setTimeout(() => resolve(false), this.#services.limits.abortGraceMs);
+        });
+        const clean = await Promise.race([stopped, outOfTime]);
+        clearTimeout(grace);
+        return clean;
+    }
+    /** Writes the result to the transcript, the admin totals, and the recent-question list. */
+    #record(result) {
+        const { operations, recordings } = this.#services;
+        const { outcome, message } = result;
+        const measurement = this.#recording.finish({
+            outcome,
+            error: outcome === "completed" ? undefined : message,
+        });
+        if (measurement) {
+            this.#session.contextPercent = measurement.contextPercent;
+            operations.recordTurn(outcome, measurement, message);
+        }
+        recordings.logQuestion({
+            outcome,
+            at: new Date().toISOString(),
+            question: this.#message,
+            replyChars: this.#replyChars,
+            tools: [...this.#tools],
+            ...(outcome !== "completed" ? { error: message ?? outcome } : {}),
+        });
+    }
+}

package/build/server/agent/harness.js

@@ -0,0 +1,435 @@
+/**
+ * The only file that imports pi.
+ *
+ * Everything else in the server sees these two interfaces. If the harness is ever
+ * swapped, this file is what gets rewritten.
+ */
+import { realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { relative, join, resolve as resolvePath } from "node:path";
+import { Type } from "typebox";
+import { createAgentSession, createReadToolDefinition, createGrepToolDefinition, createFindToolDefinition, createLsToolDefinition, defineTool, createExtensionRuntime, loadSkillsFromDir, getAgentDir, ModelRuntime, resolveCliModel, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { CHECK_TOOL, } from "../../src/shared/protocol.js";
+import {} from "../stone/stone.js";
+import { runChecks } from "../stone/verify.js";
+import {} from "../records/recording.js";
+import {} from "../records/turn-recording.js";
+import { TurnError } from "./turn.js";
+import { contains, stoneToolPath } from "../stone/file-boundary.js";
+/** Read-only. pi's defaults include bash, edit and write, which a question-answering assistant must not have. */
+const TOOLS = ["read", "grep", "find", "ls"];
+/** Custom definitions override Pi's built-ins under the same allowlisted names. */
+export function createStoneTools(stonePath) {
+    const root = realpathSync(stonePath);
+    function guard(tool) {
+        return defineTool({
+            ...tool,
+            description: `${tool.description} Only files inside the active stone are accessible. Directory scans cannot include symbolic links.`,
+            async execute(id, args, signal, onUpdate, ctx) {
+                const params = args;
+                const scan = tool.name === "read"
+                    ? "none"
+                    : tool.name === "ls"
+                        ? "shallow"
+                        : "recursive";
+                const path = await stoneToolPath(root, params.path ?? ".", scan, signal);
+                return tool.execute(id, { ...params, path }, signal, onUpdate, ctx);
+            },
+        });
+    }
+    return [
+        guard(createReadToolDefinition(root)),
+        guard(createGrepToolDefinition(root)),
+        guard(createFindToolDefinition(root)),
+        guard(createLsToolDefinition(root)),
+    ];
+}
+export async function createHarness(stone, modelPattern) {
+    const modelRuntime = await ModelRuntime.create();
+    const { model, thinkingLevel, source } = await resolveModel(modelRuntime, modelPattern);
+    const loader = createStoneLoader(stone);
+    const skills = loader.getSkills().skills;
+    // Reported rather than assumed: the check tool is only enabled when the
+    // stone declares checkers, and the banner should say what is actually on.
+    const tools = stone.checks.length ? [...TOOLS, CHECK_TOOL] : TOOLS;
+    const modelName = model ? `${model.provider}/${model.id}` : null;
+    return {
+        stone,
+        tools,
+        model: modelName ? `${modelName} (${source})` : "unresolved",
+        skills: skills.map((skill) => skill.name),
+        checks: stone.checks.map((check) => check.name),
+        async create() {
+            const findResource = createResourceFinder(stone, skills);
+            // The budget is per question, not per session: each new turn starts fresh.
+            const attempts = { failed: 0 };
+            const checkTool = stone.checks.length
+                ? createCheckTool(stone, attempts)
+                : undefined;
+            const { session } = await createAgentSession({
+                resourceLoader: loader,
+                modelRuntime,
+                sessionManager: SessionManager.inMemory(stone.path),
+                cwd: stone.path,
+                tools,
+                customTools: [
+                    ...createStoneTools(stone.path),
+                    ...(checkTool ? [checkTool] : []),
+                ],
+                ...(model ? { model } : {}),
+                ...(thinkingLevel ? { thinkingLevel } : {}),
+            });
+            return new PiAgent(session, {
+                metadata: {
+                    model: modelName,
+                    stone: stone.agentName,
+                    alwaysInContext: stone.context.map((file) => file.path),
+                },
+                model,
+                findResource,
+                attempts,
+            });
+        },
+    };
+}
+/** One conversation with the model, held in a Pi session. */
+class PiAgent {
+    metadata;
+    #session;
+    #model;
+    #findResource;
+    #attempts;
+    constructor(session, options) {
+        this.#session = session;
+        this.metadata = options.metadata;
+        this.#model = options.model;
+        this.#findResource = options.findResource;
+        this.#attempts = options.attempts;
+    }
+    async ask(message, onEvent, record = () => { }) {
+        this.#attempts.failed = 0;
+        const question = { onEvent, record, reads: new Map() };
+        this.#recordContextUsage(record);
+        const unsubscribe = this.#session.subscribe((event) => this.#translate(event, question));
+        try {
+            await this.#session.prompt(message);
+            const { stopReason, errorMessage } = question.lastResponse ?? {};
+            const outcome = turnOutcome(stopReason);
+            record({
+                type: "provider_outcome",
+                data: { outcome, error: errorMessage },
+            });
+            if (outcome !== "completed")
+                throw new TurnError(outcome, errorMessage ||
+                    (stopReason === "length"
+                        ? "The model reached its output limit. This response is incomplete."
+                        : `Agent turn ${outcome}`));
+        }
+        finally {
+            this.#recordContextUsage(record);
+            unsubscribe();
+        }
+    }
+    async abort() {
+        await this.#session.abort();
+    }
+    dispose() {
+        this.#session.dispose();
+    }
+    /** Passes one Pi event on as what the browser shows and what the recording keeps. */
+    #translate(event, question) {
+        const { onEvent, record, reads } = question;
+        switch (event.type) {
+            case "message_update": {
+                if (event.assistantMessageEvent.type !== "text_delta")
+                    return;
+                const text = event.assistantMessageEvent.delta;
+                record({ type: "assistant_delta", data: { text } });
+                onEvent({ t: "delta", text });
+                return;
+            }
+            case "message_end": {
+                if (event.message.role !== "assistant")
+                    return;
+                question.lastResponse = event.message;
+                record({
+                    type: "assistant_message",
+                    data: measureResponse(event.message, this.#model),
+                });
+                return;
+            }
+            case "tool_execution_start": {
+                record({ type: "tool_used", data: { name: event.toolName } });
+                if (event.toolName === "read" && typeof event.args?.path === "string") {
+                    const resource = this.#findResource(event.args.path);
+                    if (resource)
+                        reads.set(event.toolCallId, resource);
+                }
+                onEvent({ t: "tool", name: event.toolName, state: "running" });
+                return;
+            }
+            case "tool_execution_end": {
+                // A read is recorded as a document or a skill only once it has succeeded.
+                const resource = reads.get(event.toolCallId);
+                if (resource && !event.isError) {
+                    record(resource.skill
+                        ? { type: "skill_loaded", data: { skill: resource.skill } }
+                        : { type: "document_read", data: { path: resource.path } });
+                }
+                reads.delete(event.toolCallId);
+                onEvent({
+                    t: "tool",
+                    name: event.toolName,
+                    state: "done",
+                    isError: event.isError,
+                });
+                return;
+            }
+            case "compaction_end":
+                this.#recordContextUsage(record);
+                return;
+        }
+    }
+    #recordContextUsage(record) {
+        let percent = null;
+        try {
+            percent = this.#session.getContextUsage()?.percent ?? null;
+        }
+        catch {
+            // Unknown usage is recorded as null.
+        }
+        record({ type: "context_usage", data: { percent } });
+    }
+}
+/** Pi's stop reason for the last response, as the outcome of the turn. */
+function turnOutcome(stopReason) {
+    if (stopReason === "stop")
+        return "completed";
+    if (stopReason === "error")
+        return "failed";
+    if (stopReason === "aborted")
+        return "stopped";
+    return "incomplete";
+}
+/** A finished response as the recording keeps it: its text, and its usage and cost when they are real. */
+function measureResponse(message, model) {
+    const reported = message.usage;
+    // Pi initializes missing usage to zero; do not pretend those placeholders are measured.
+    const usage = reported &&
+        [
+            reported.input,
+            reported.output,
+            reported.cacheRead,
+            reported.cacheWrite,
+            reported.totalTokens,
+        ].every(Number.isFinite) &&
+        reported.totalTokens > 0
+        ? {
+            input: reported.input,
+            output: reported.output,
+            cacheRead: reported.cacheRead,
+            cacheWrite: reported.cacheWrite,
+            totalTokens: reported.totalTokens,
+        }
+        : null;
+    // Use Pi's per-response estimate: it already accounts for cache and pricing tiers.
+    const cost = reported?.cost;
+    const estimatedCostUsd = usage &&
+        hasRealPrices(model) &&
+        model?.provider === message.provider &&
+        model.id === message.model &&
+        cost &&
+        [
+            cost.input,
+            cost.output,
+            cost.cacheRead,
+            cost.cacheWrite,
+            cost.total,
+        ].every((value) => Number.isFinite(value) && value >= 0)
+        ? cost.total
+        : null;
+    return {
+        text: message.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join(""),
+        usage,
+        estimatedCostUsd,
+    };
+}
+/** All-zero catalog prices can be placeholders (e.g. subscription/custom models). */
+function hasRealPrices(model) {
+    const rates = model?.cost;
+    return Boolean(rates &&
+        [rates, ...(rates.tiers ?? [])].some((rate) => [rate.input, rate.output, rate.cacheRead, rate.cacheWrite].some((value) => Number.isFinite(value) && value > 0)));
+}
+/** Finds which stone file a `read` call names. A failed or external read names none. */
+function createResourceFinder(stone, skills) {
+    const catalog = skills.map((skill) => ({
+        name: skill.name,
+        path: relative(stone.path, skill.filePath),
+    }));
+    const root = realpathSync(stone.path);
+    return (requested) => {
+        try {
+            const resolved = realpathSync(resolvePath(stone.path, requested));
+            if (!contains(root, resolved))
+                return undefined;
+            const path = relative(root, resolved);
+            return {
+                path,
+                skill: catalog.find((skill) => skill.path === path)?.name,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+/**
+ * Two failed checks and the agent must stop offering the script.
+ *
+ * Counted here rather than trusted to the prompt: after the budget is spent the
+ * tool itself refuses, so a model that keeps trying is told no by the runtime.
+ */
+const MAX_FAILED_CHECKS = 2;
+/**
+ * The tool a draft script must pass before the model shows it. It counts failed
+ * checks itself, so the limit holds whether or not the model follows the prompt.
+ * A check that passes does not count.
+ */
+function createCheckTool(stone, attempts) {
+    const say = (text, isError = false) => ({
+        content: [{ type: "text", text }],
+        details: {},
+        isError,
+    });
+    return defineTool({
+        name: CHECK_TOOL,
+        label: "Check script",
+        description: "Check a draft script against this language's checkers before showing it to " +
+            "anyone. Returns whether it passed and, when it did not, the checker's " +
+            "diagnostics. Always call this before putting a script in your reply.",
+        parameters: Type.Object({
+            script: Type.String({
+                description: "The complete draft script to check.",
+            }),
+        }),
+        // One check at a time, so each one sees the failures counted before it.
+        executionMode: "sequential",
+        async execute(_id, { script }, signal) {
+            if (attempts.failed >= MAX_FAILED_CHECKS) {
+                return say("Attempt limit reached. Do not show this script. Tell the person what the " +
+                    "checker rejected and what you would need to get it right.", true);
+            }
+            const report = await runChecks(stone.checks, script, stone.path, signal);
+            if (report.ok)
+                return say("All checks passed. The script is safe to show.");
+            attempts.failed += 1;
+            const failedChecks = report.checks.filter((check) => !check.ok);
+            const remaining = MAX_FAILED_CHECKS - attempts.failed;
+            return say([
+                ...failedChecks.map((check) => `${check.name} failed:\n${check.output || "(no output)"}`),
+                remaining > 0
+                    ? `Fix the script and check again. ${remaining} attempt left.`
+                    : "No attempts left. Do not show this script; explain what failed.",
+            ].join("\n\n"), true);
+        },
+    });
+}
+/**
+ * Rosetta resolves the model itself rather than letting pi pick silently.
+ *
+ * pi's own order is session, then settings.defaultModel, then first available.
+ * That is right for a terminal where you can see and change the model, but on a
+ * shared server the admin needs to know which model is answering, so we resolve
+ * explicitly and report it at startup.
+ */
+async function resolveModel(modelRuntime, pattern) {
+    // 1. ROSETTA_MODEL wins. Accepts pi's own syntax, including "provider/id"
+    //    and a ":thinking" suffix, e.g. "anthropic/claude-sonnet-5:high".
+    if (pattern) {
+        const result = resolveCliModel({ cliModel: pattern, modelRuntime });
+        if (result.error)
+            throw new Error(`ROSETTA_MODEL: ${result.error}`);
+        if (result.warning)
+            console.warn(`ROSETTA_MODEL: ${result.warning}`);
+        return {
+            model: result.model,
+            thinkingLevel: result.thinkingLevel,
+            source: "ROSETTA_MODEL",
+        };
+    }
+    // 2. Whatever the admin set as pi's default on this host.
+    try {
+        const settingsPath = resolvePath(getAgentDir(), "settings.json");
+        const settings = JSON.parse(await readFile(settingsPath, "utf8"));
+        if (typeof settings.defaultModel === "string" && settings.defaultModel) {
+            const result = resolveCliModel({
+                cliModel: typeof settings.defaultProvider === "string"
+                    ? `${settings.defaultProvider}/${settings.defaultModel}`
+                    : settings.defaultModel,
+                modelRuntime,
+            });
+            if (result.model) {
+                return {
+                    model: result.model,
+                    thinkingLevel: result.thinkingLevel,
+                    source: "pi defaultModel",
+                };
+            }
+        }
+    }
+    catch {
+        // No settings file, or unreadable. Fall through.
+    }
+    // 3. Anything with working credentials.
+    const available = await modelRuntime.getAvailable();
+    if (!available.length) {
+        throw new Error("No model is available. Run `pi` and `/login`, or set provider API keys, then restart.");
+    }
+    return {
+        model: available[0],
+        thinkingLevel: undefined,
+        source: "first available",
+    };
+}
+/** Explicit resources: no host prompt, parent AGENTS, packages, extensions, or global skills discovery. */
+export function createStoneLoader(stone) {
+    const root = realpathSync(stone.path);
+    const loaded = loadSkillsFromDir({
+        dir: join(stone.path, "skills"),
+        source: "project",
+    });
+    const skills = loaded.skills.filter((skill) => {
+        try {
+            return contains(root, realpathSync(skill.filePath));
+        }
+        catch {
+            return false;
+        }
+    });
+    const extensions = {
+        extensions: [],
+        errors: [],
+        runtime: createExtensionRuntime(),
+    };
+    return {
+        getExtensions: () => extensions,
+        getSkills: () => ({ skills, diagnostics: loaded.diagnostics }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgentsFiles: () => ({
+            agentsFiles: stone.context.map((file) => ({
+                path: join(stone.path, file.path),
+                content: file.content,
+            })),
+        }),
+        getSystemPrompt: () => stone.systemPrompt,
+        getSystemPromptSource: () => undefined,
+        getAppendSystemPrompt: () => [],
+        getAppendSystemPromptSources: () => [],
+        extendResources: () => { },
+        reload: async () => { }, // Resources remain fixed for the lifetime of the process.
+    };
+}