wizards 0.1.9

package/apps/runtime/dist/harness/gemini.js

@@ -0,0 +1,126 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveEnv, run } from "./env.js";
+import { failureOf, HarnessModel, runClient, } from "./model.js";
+/**
+ * Gemini CLI: headless it answers on the Google sign-in it cached, or on a key from the shell.
+ * The system prompt replaces its own (GEMINI_SYSTEM_MD); tools go over MCP through a project
+ * settings file in the call's folder, with its built-in tools switched off; the answer is asked
+ * for as JSON where a schema is wanted.
+ */
+export const GEMINI_BIN = process.env.GEMINI_BIN?.trim() || "gemini";
+const CLASSES = {
+    classifier: "gemini-2.5-flash-lite",
+    standard: "gemini-2.5-flash",
+    high: "gemini-2.5-pro",
+    highest: "gemini-2.5-pro",
+};
+/** Where the client keeps its state: its own home, else the person's. */
+const geminiHome = (env) => env.GEMINI_CLI_HOME?.trim() || join(env.HOME || homedir(), ".gemini");
+const spec = {
+    id: "gemini",
+    passThrough: /^(GEMINI_API_KEY|GOOGLE_API_KEY|GOOGLE_CLOUD_PROJECT|GOOGLE_CLOUD_LOCATION|GOOGLE_APPLICATION_CREDENTIALS|GOOGLE_GENAI_USE_VERTEXAI|GOOGLE_GENAI_USE_GCA|GEMINI_CLI_HOME)$/,
+    keyVars: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENAI_USE_VERTEXAI"],
+    // The client has no status command: a key in the environment, else the sign-in it cached.
+    async auth(env) {
+        if (env.GEMINI_API_KEY || env.GOOGLE_API_KEY || env.GOOGLE_GENAI_USE_VERTEXAI) {
+            return "api_key";
+        }
+        return existsSync(join(geminiHome(env), "oauth_creds.json")) ? "subscription" : "none";
+    },
+};
+/** The client's output as the model call wants it; the lines it logs before the JSON are skipped. */
+export function geminiAnswer(stdout) {
+    const at = stdout.search(/^\{/m);
+    if (at < 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(stdout.slice(at));
+    }
+    catch {
+        return null;
+    }
+}
+class GeminiModel extends HarnessModel {
+    provider = "gemini-cli";
+    async invoke(call) {
+        const { env, auth } = await resolveEnv(spec);
+        const systemFile = join(call.dir, "system.md");
+        writeFileSync(systemFile, call.system || "You are a helpful assistant.");
+        const core = [];
+        if (call.webSearch) {
+            core.push("google_web_search");
+        }
+        if (call.files.length) {
+            core.push("read_file");
+        }
+        mkdirSync(join(call.dir, ".gemini"), { recursive: true });
+        writeFileSync(join(call.dir, ".gemini", "settings.json"), JSON.stringify({
+            mcpServers: call.bridgeUrl
+                ? { step: { httpUrl: call.bridgeUrl, trust: true, timeout: 600_000 } }
+                : {},
+            tools: { core },
+        }));
+        const args = [
+            "-o",
+            "json",
+            "-m",
+            this.modelId,
+            "--approval-mode",
+            "yolo",
+            "--allowed-mcp-server-names",
+            call.bridgeUrl ? "step" : "none",
+        ];
+        const { stdout, stderr, code } = await runClient(GEMINI_BIN, args, {
+            cwd: call.dir,
+            env: {
+                ...env,
+                GEMINI_SYSTEM_MD: systemFile,
+                NO_COLOR: "1",
+                ...(auth === "subscription" ? { GOOGLE_GENAI_USE_GCA: "true" } : {}),
+            },
+            signal: call.signal,
+            stdin: call.prompt,
+        });
+        const result = geminiAnswer(stdout);
+        if (!result) {
+            throw failureOf(this.harness, stderr.trim() || `exit ${code}`);
+        }
+        if (result.error) {
+            throw failureOf(this.harness, result.error.code === 41 ? "not logged in" : (result.error.message ?? "error"));
+        }
+        let input = 0;
+        let cacheRead = 0;
+        let output = 0;
+        for (const model of Object.values(result.stats?.models ?? {})) {
+            input += model.tokens?.prompt ?? 0;
+            cacheRead += model.tokens?.cached ?? 0;
+            output += model.tokens?.candidates ?? 0;
+        }
+        return {
+            text: result.response ?? "",
+            usage: { input, cacheRead, output },
+            sessionId: result.session_id,
+        };
+    }
+}
+export const gemini = {
+    ...spec,
+    name: "Gemini CLI",
+    bin: GEMINI_BIN,
+    classes: CLASSES,
+    async version(env) {
+        try {
+            const { stdout } = await run(GEMINI_BIN, ["--version"], { timeout: 10_000, env });
+            return stdout.trim().split("\n").pop()?.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    },
+    // No login command: the client's own app asks for the sign-in when it has none.
+    login: { args: [], interactive: true },
+    model: (alias, effort) => new GeminiModel(gemini, alias || CLASSES.standard, effort),
+};

package/apps/runtime/dist/harness/index.js

@@ -0,0 +1,99 @@
+import { mkdirSync } from "node:fs";
+import { installCommand } from "../cli/clients.js";
+import { inherited, runtimePath } from "../cli/environment.js";
+import { layout } from "../cli/home.js";
+import { CLIENTS, vendorApp } from "../cli/machine.js";
+import { claude } from "./claude.js";
+import { codex } from "./codex.js";
+import { cursor } from "./cursor.js";
+import { forgetEnv, loginShellEnv, resolveEnv } from "./env.js";
+import { gemini } from "./gemini.js";
+export { HarnessModel, notInstalled, signedOut } from "./model.js";
+export { HARNESS_IDS } from "./types.js";
+/**
+ * The AI clients this runtime can run as a model, in the order the setup offers them. The first
+ * one installed is the one the setup recommends.
+ */
+export const HARNESSES = [codex, claude, gemini, cursor];
+export function harness(id) {
+    return HARNESSES.find((h) => h.id === id) ?? null;
+}
+/** Whether a binding's vendor names a client: `claude/sonnet`, `codex/default`. */
+export function isHarnessVendor(vendor) {
+    return HARNESSES.some((h) => h.id === vendor);
+}
+const detected = new Map();
+/** One client, as it is now; asked again after a minute — it may get installed or signed in meanwhile. */
+export async function detectHarness(id, force = false) {
+    const h = harness(id);
+    if (!h) {
+        return null;
+    }
+    const hit = detected.get(id);
+    if (!force && hit && Date.now() - hit.at < 60_000) {
+        return hit.value;
+    }
+    if (force) {
+        // The person may just have signed in or set a key in their shell.
+        forgetEnv(id);
+    }
+    const client = CLIENTS.find((c) => c.id === id);
+    let value = {
+        id,
+        name: h.name,
+        install: client ? installCommand(client, layout()) : "",
+        app: client ? vendorApp(client) : null,
+        version: null,
+        auth: "none",
+        interactiveLogin: h.login.interactive,
+        images: Boolean(h.image),
+    };
+    try {
+        const { env, auth } = await resolveEnv(h);
+        const version = await h.version(env);
+        if (version) {
+            value = { ...value, version, auth };
+        }
+    }
+    catch {
+        // not installed
+    }
+    detected.set(id, { at: Date.now(), value });
+    return value;
+}
+/** Every client this runtime knows, installed or not. */
+export function detectHarnesses(force = false) {
+    return Promise.all(HARNESSES.map((h) => detectHarness(h.id, force)));
+}
+/** The clients installed on this machine. */
+export async function installedHarnesses() {
+    return (await detectHarnesses()).filter((h) => h.version !== null);
+}
+/**
+ * What the inline terminal runs to install a client: the command the terminal setup runs, shown
+ * first. A client from npm goes into the install's own prefix with the npm of its own Node.
+ */
+export async function installSpec(id) {
+    const client = CLIENTS.find((c) => c.id === id);
+    if (!client) {
+        return null;
+    }
+    const paths = layout();
+    mkdirSync(paths.clients, { recursive: true });
+    const shell = await loginShellEnv();
+    return {
+        bin: "bash",
+        args: [
+            "-c",
+            'printf "\\033[2m$ %s\\033[0m\\n\\n" "$1"; set -o pipefail; eval "$1"',
+            "install",
+            installCommand(client, paths),
+        ],
+        env: {
+            ...inherited(process.env),
+            PATH: runtimePath(paths, { ...process.env, PATH: shell.PATH || process.env.PATH }),
+            TERM: "xterm-256color",
+            COLORTERM: "truecolor",
+        },
+    };
+}

package/apps/runtime/dist/harness/model.js

@@ -0,0 +1,267 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { nanoid } from "nanoid";
+import { env } from "../env.js";
+import { openBridge } from "../mcp/bridge.js";
+import { ModelUnavailableError } from "../model-errors.js";
+import { extensionOf, jsonInstruction, parseJsonAnswer, renderPrompt } from "./prompt.js";
+const workDir = join(env.dataDir, "harness");
+export const signedOut = (h) => `${h.name} ist auf diesem Gerät nicht angemeldet. Melde dich in den Einstellungen unter „Modelle & Konto“ an.`;
+export const notInstalled = (h) => `${h.name} ist auf diesem Gerät nicht installiert. Installiere es in den Einstellungen unter „Modelle & Konto“.`;
+export const exhausted = (h) => h.exhausted ??
+    `Das Konto, mit dem ${h.name} angemeldet ist, hat kein Guthaben oder Kontingent mehr.`;
+/** The failure a client reports, as the person should read it. */
+export function failureOf(h, detail) {
+    if (/credit balance|billing|too low|usage limit|quota|insufficient|rate.?limit|\b429\b/i.test(detail)) {
+        return new ModelUnavailableError(exhausted(h));
+    }
+    if (/authenticat|log ?in|logged in|oauth|credential|unauthori[sz]ed|\b401\b|api key/i.test(detail)) {
+        return new ModelUnavailableError(signedOut(h));
+    }
+    return new Error(`${h.name}: ${detail}`.slice(0, 500));
+}
+/** Runs a client once with the prompt on stdin; a client that is not there raises ENOENT. */
+export function runClient(bin, args, opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, {
+            cwd: opts.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            signal: opts.signal,
+            env: opts.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = (stderr + String(chunk)).slice(-4000);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve({ stdout, stderr, code }));
+        child.stdin.on("error", () => {
+            // The client went away before reading the prompt; `close` reports it.
+        });
+        child.stdin.end(opts.stdin ?? "");
+    });
+}
+/** The last line of an output that is a JSON object. */
+export function lastJson(stdout) {
+    for (const line of stdout.trim().split("\n").reverse()) {
+        try {
+            const value = JSON.parse(line);
+            if (value && typeof value === "object") {
+                return value;
+            }
+        }
+        catch {
+            // not it
+        }
+    }
+    return null;
+}
+export class HarnessModel {
+    specificationVersion = "v3";
+    modelId;
+    supportedUrls = {};
+    /** Whether the client validates structured output against the schema itself. */
+    nativeSchema = false;
+    effort;
+    harness;
+    executors = new Map();
+    constructor(harness, alias, effort) {
+        this.harness = harness;
+        this.modelId = alias;
+        this.effort = effort;
+    }
+    /** The tools a call may name, by the names the agent gives them: the client runs them over the bridge. */
+    attach(tools) {
+        for (const [name, tool] of Object.entries(tools)) {
+            const t = tool;
+            if (typeof t?.execute === "function") {
+                this.executors.set(name, t);
+                if (t.id) {
+                    this.executors.set(t.id, t);
+                }
+            }
+        }
+    }
+    async doGenerate(options) {
+        const dir = join(workDir, nanoid(10));
+        mkdirSync(dir, { recursive: true });
+        const { system, prompt, files, warnings } = renderPrompt(options.prompt, dir);
+        const bridged = [];
+        let webSearch = false;
+        for (const tool of options.tools ?? []) {
+            if (tool.type !== "function") {
+                warnings.push({ type: "unsupported", feature: `tool ${tool.name}` });
+                continue;
+            }
+            // The client searches with its own tool; naming `web_search` is what switches it on.
+            if (tool.name === "web_search") {
+                webSearch = true;
+                continue;
+            }
+            const executor = this.executors.get(tool.name);
+            if (!executor?.execute) {
+                warnings.push({
+                    type: "unsupported",
+                    feature: `tool ${tool.name}`,
+                    details: "no executor",
+                });
+                continue;
+            }
+            bridged.push({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                execute: (input) => executor.execute(input),
+                toModelOutput: executor.toModelOutput,
+            });
+        }
+        for (const key of ["temperature", "topP", "topK", "seed", "stopSequences"]) {
+            if (options[key] !== undefined) {
+                warnings.push({ type: "unsupported", feature: key });
+            }
+        }
+        const structured = options.responseFormat?.type === "json";
+        const schema = structured && options.responseFormat?.type === "json"
+            ? (options.responseFormat.schema ?? null)
+            : null;
+        const bridge = bridged.length ? openBridge(bridged) : null;
+        try {
+            const answer = await this.invoke({
+                dir,
+                system: structured && !this.nativeSchema
+                    ? [system, jsonInstruction(schema)].filter(Boolean).join("\n\n")
+                    : system,
+                prompt,
+                files,
+                bridgeUrl: bridge?.url ?? null,
+                schema: this.nativeSchema ? schema : null,
+                webSearch,
+                effort: this.effort,
+                signal: options.abortSignal,
+            });
+            const u = answer.usage ?? {};
+            const cacheRead = u.cacheRead ?? 0;
+            const cacheWrite = u.cacheWrite ?? 0;
+            const input = u.input ?? 0;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: structured ? JSON.stringify(parseJsonAnswer(answer.text)) : answer.text,
+                    },
+                ],
+                finishReason: { unified: "stop", raw: answer.stopReason },
+                usage: {
+                    inputTokens: {
+                        total: input,
+                        noCache: Math.max(0, input - cacheRead - cacheWrite),
+                        cacheRead,
+                        cacheWrite,
+                    },
+                    outputTokens: { total: u.output ?? 0, text: u.output ?? 0, reasoning: undefined },
+                    raw: u,
+                },
+                providerMetadata: { [this.provider]: answer.meta ?? {} },
+                response: { id: answer.sessionId, modelId: this.modelId },
+                warnings,
+            };
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                throw new ModelUnavailableError(notInstalled(this.harness));
+            }
+            throw err;
+        }
+        finally {
+            bridge?.close();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    /** The answer as one piece: the client prints it when it is done. */
+    async doStream(options) {
+        const result = await this.doGenerate(options);
+        const text = result.content.find((c) => c.type === "text");
+        const parts = [
+            { type: "stream-start", warnings: result.warnings },
+            { type: "response-metadata", ...result.response },
+            { type: "text-start", id: "0" },
+            { type: "text-delta", id: "0", delta: text?.type === "text" ? text.text : "" },
+            { type: "text-end", id: "0" },
+            {
+                type: "finish",
+                usage: result.usage,
+                finishReason: result.finishReason,
+                providerMetadata: result.providerMetadata,
+            },
+        ];
+        return {
+            stream: new ReadableStream({
+                start(controller) {
+                    for (const part of parts) {
+                        controller.enqueue(part);
+                    }
+                    controller.close();
+                },
+            }),
+        };
+    }
+}
+/** A client that makes images on the person's sign-in: one client run per image. */
+export class HarnessImageModel {
+    specificationVersion = "v3";
+    modelId;
+    maxImagesPerCall = 1;
+    harness;
+    constructor(harness, alias) {
+        this.harness = harness;
+        this.modelId = alias;
+    }
+    async doGenerate(options) {
+        const dir = join(workDir, nanoid(10));
+        mkdirSync(dir, { recursive: true });
+        const warnings = [];
+        const files = [];
+        for (const file of options.files ?? []) {
+            if (file.type !== "file") {
+                warnings.push({ type: "unsupported", feature: "image url" });
+                continue;
+            }
+            const path = join(dir, `ref-${files.length + 1}.${extensionOf(file.mediaType)}`);
+            writeFileSync(path, typeof file.data === "string" ? Buffer.from(file.data, "base64") : file.data);
+            files.push(path);
+        }
+        for (const key of ["size", "seed", "mask"]) {
+            if (options[key] !== undefined) {
+                warnings.push({ type: "unsupported", feature: key });
+            }
+        }
+        try {
+            const image = await this.invoke({
+                dir,
+                prompt: options.prompt ?? "",
+                files,
+                aspectRatio: options.aspectRatio,
+                signal: options.abortSignal,
+            });
+            return {
+                images: [image],
+                warnings,
+                response: { timestamp: new Date(), modelId: this.modelId, headers: undefined },
+            };
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                throw new ModelUnavailableError(notInstalled(this.harness));
+            }
+            throw err;
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+}

package/apps/runtime/dist/harness/prompt.js

@@ -0,0 +1,121 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** The extension a saved attachment gets, so the client reads it as what it is. */
+export function extensionOf(mediaType, filename) {
+    const own = filename?.match(/\.([a-z0-9]{1,5})$/i)?.[1];
+    if (own) {
+        return own.toLowerCase();
+    }
+    const sub = mediaType.split("/")[1] ?? "bin";
+    return { jpeg: "jpg", "svg+xml": "svg", plain: "txt", markdown: "md" }[sub] ?? sub;
+}
+/**
+ * The conversation as a client takes it: one system prompt and one prompt on stdin. A single
+ * user message goes as it is; a longer thread is written out with its speakers, and the client
+ * is asked to answer its last message. Attachments are saved to `dir` and named in the prompt.
+ */
+export function renderPrompt(messages, dir) {
+    const warnings = [];
+    const files = [];
+    const system = [];
+    const turns = [];
+    const saveFile = (input) => {
+        // A file's content comes tagged: { type: "data", data } | { type: "url", url } | { type: "text", text }.
+        const tagged = input.data;
+        const data = tagged && typeof tagged === "object" && typeof tagged.type === "string"
+            ? tagged.type === "url"
+                ? tagged.url
+                : tagged.type === "text"
+                    ? Buffer.from(tagged.text ?? "", "utf8")
+                    : tagged.data
+            : input.data;
+        const part = { ...input, data };
+        if (part.data instanceof URL) {
+            return `[Attachment at ${part.data.href} (${part.mediaType})]`;
+        }
+        if (typeof part.data !== "string" && !(part.data instanceof Uint8Array)) {
+            warnings.push({ type: "unsupported", feature: "file parts" });
+            return `[Attachment: ${part.filename ?? part.mediaType}]`;
+        }
+        if (!dir) {
+            warnings.push({ type: "unsupported", feature: "file parts" });
+            return `[Attachment: ${part.filename ?? part.mediaType}]`;
+        }
+        const path = join(dir, `${files.length + 1}.${extensionOf(part.mediaType, part.filename)}`);
+        const bytes = typeof part.data === "string" ? Buffer.from(part.data, "base64") : part.data;
+        writeFileSync(path, bytes);
+        files.push(path);
+        return `[Attached file — open it to read it: ${path}]`;
+    };
+    for (const m of messages) {
+        if (m.role === "system") {
+            system.push(m.content);
+            continue;
+        }
+        const text = m.content
+            .map((part) => {
+            switch (part.type) {
+                case "text":
+                    return part.text;
+                case "file":
+                    return saveFile(part);
+                case "reasoning":
+                    return "";
+                case "tool-call":
+                    return `[Called ${part.toolName} with ${JSON.stringify(part.input)}]`;
+                case "tool-result": {
+                    const out = part.output;
+                    const value = out.type === "text" || out.type === "error-text"
+                        ? String(out.value)
+                        : out.type === "json" || out.type === "error-json"
+                            ? JSON.stringify(out.value)
+                            : out.type === "execution-denied"
+                                ? `denied${out.reason ? `: ${out.reason}` : ""}`
+                                : JSON.stringify(out.value ?? out);
+                    return `[Result of ${part.toolName}: ${value}]`;
+                }
+                default:
+                    return "";
+            }
+        })
+            .filter(Boolean)
+            .join("\n");
+        turns.push({ role: m.role, text });
+    }
+    const prompt = turns.length === 1 && turns[0].role === "user"
+        ? turns[0].text
+        : turns
+            .map((t) => `${t.role === "user" ? "User" : t.role === "tool" ? "Tool" : "Assistant"}:\n${t.text}`)
+            .join("\n\n");
+    if (turns.length > 1) {
+        system.push("The prompt holds the conversation so far, each message headed by its speaker. Answer the last message as the assistant — the answer only, no speaker label.");
+    }
+    return { system: system.join("\n\n"), prompt, files, warnings };
+}
+/** What a client without a schema option is told so its answer parses. */
+export function jsonInstruction(schema) {
+    return [
+        "Answer with one JSON value only — no prose, no code fence — that matches this JSON Schema:",
+        JSON.stringify(schema ?? { type: "object" }),
+    ].join("\n");
+}
+/** A client's answer as JSON: the fences and prose some wrap around it are taken off. */
+export function parseJsonAnswer(text) {
+    const trimmed = text.trim();
+    const unfenced = trimmed
+        .replace(/^\s*```(?:json)?\s*/i, "")
+        .replace(/\s*```\s*$/, "")
+        .trim();
+    try {
+        return JSON.parse(unfenced);
+    }
+    catch {
+        // Prose around the value: take the outermost object or array.
+        const start = unfenced.search(/[{[]/);
+        const end = Math.max(unfenced.lastIndexOf("}"), unfenced.lastIndexOf("]"));
+        if (start >= 0 && end > start) {
+            return JSON.parse(unfenced.slice(start, end + 1));
+        }
+        throw new Error("The answer is not JSON.");
+    }
+}