efaimo 0.1.0

package/dist/rules/skill/index.js

@@ -0,0 +1,279 @@
+import path from "node:path";
+import { scanTextForInjection } from "../injection.js";
+import { formatTokens } from "../../util/misc.js";
+const NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const STANDARD_FIELDS = new Set(["name", "description", "license", "compatibility", "metadata", "allowed-tools"]);
+function skillLabel(s) {
+    return s.name ?? path.basename(path.dirname(s.file));
+}
+const s101 = {
+    id: "S101",
+    title: "frontmatter does not match the spec",
+    surface: "skill",
+    check({ skill }) {
+        const findings = [];
+        const label = skillLabel(skill);
+        const push = (severity, message, fixHint) => findings.push({ ruleId: "S101", severity, title: "frontmatter does not match the spec", message, target: label, fixHint });
+        if (skill.parseError) {
+            push("error", `${skill.file}: ${skill.parseError}`, "SKILL.md must start with a --- YAML frontmatter block");
+            if (!skill.frontmatterRaw)
+                return findings;
+        }
+        const name = skill.frontmatter.name;
+        if (typeof name !== "string" || !name.trim()) {
+            push("error", "required field `name` is missing", "add `name:` matching the skill directory name");
+        }
+        else {
+            if (!NAME_RE.test(name)) {
+                push("error", `name "${name}" is invalid (spec: lowercase a-z, 0-9, hyphens; no leading/trailing/double hyphen)`);
+            }
+            if (name.length > 64)
+                push("error", `name is ${name.length} chars (spec max 64)`);
+            const dirName = path.basename(skill.dir);
+            if (name !== dirName) {
+                // A release tarball or default clone lands in "<name>-0.1.0" or
+                // "<name>-main"; that is packaging, not the author's naming, so it
+                // must not fail the skill (or --strict) with a spurious error.
+                const suffix = dirName.startsWith(`${name}-`) ? dirName.slice(name.length + 1) : undefined;
+                const archiveLike = suffix !== undefined &&
+                    /^(v?\d+(\.\d+)*([-.][0-9A-Za-z.]+)?|main|master|trunk|[0-9a-f]{7,40})$/.test(suffix);
+                push(archiveLike ? "info" : "warn", `name "${name}" does not match its directory name "${dirName}" (agentskills.io spec expects them to match)`, archiveLike
+                    ? "looks like an unpacked archive or clone directory; install the skill under a directory named after it"
+                    : "rename the directory or the skill; hosts key skills by directory");
+            }
+        }
+        const desc = skill.frontmatter.description;
+        if (typeof desc !== "string" || !desc.trim()) {
+            push("error", "required field `description` is missing", "hosts select skills by description; without one the skill never triggers");
+        }
+        else if (desc.length > 1024) {
+            push("error", `description is ${desc.length} chars (spec max 1024)`);
+        }
+        const compat = skill.frontmatter.compatibility;
+        if (typeof compat === "string" && compat.length > 500) {
+            push("warn", `compatibility is ${compat.length} chars (spec max 500)`);
+        }
+        const allowedTools = skill.frontmatter["allowed-tools"];
+        if (allowedTools !== undefined && typeof allowedTools !== "string") {
+            push("warn", "`allowed-tools` must be a space-separated string per the spec (found a non-string value)");
+        }
+        const metadata = skill.frontmatter.metadata;
+        if (metadata !== undefined) {
+            if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+                push("warn", "`metadata` must be a map of string keys to string values");
+            }
+            else {
+                const nonString = Object.entries(metadata).filter(([, v]) => typeof v !== "string");
+                if (nonString.length)
+                    push("info", `metadata values should be strings (${nonString.map(([k]) => k).join(", ")})`);
+            }
+        }
+        const unknown = Object.keys(skill.frontmatter).filter((k) => !STANDARD_FIELDS.has(k));
+        for (const k of unknown.slice(0, 4)) {
+            push("info", `non-standard frontmatter field \`${k}\` (portable fields: ${[...STANDARD_FIELDS].join(", ")})`);
+        }
+        return findings;
+    },
+};
+const s102 = {
+    id: "S102",
+    title: "weak trigger description",
+    surface: "skill",
+    check({ skill }) {
+        const desc = skill.description?.trim();
+        if (!desc)
+            return []; // S101 already errors
+        const findings = [];
+        const label = skillLabel(skill);
+        if (desc.length < 20) {
+            findings.push({
+                ruleId: "S102",
+                severity: "warn",
+                title: "weak trigger description",
+                message: `description is only ${desc.length} chars; too thin for hosts to match against tasks`,
+                target: label,
+                fixHint: "state what the skill does AND when to use it, with concrete trigger words",
+            });
+        }
+        else if (!/\buse\b|\bwhen\b|\bfor\b|\bhelps?\b/i.test(desc)) {
+            findings.push({
+                ruleId: "S102",
+                severity: "info",
+                title: "weak trigger description",
+                message: "description never says when to use the skill; hosts select skills by matching descriptions to tasks",
+                target: label,
+                fixHint: 'add a "use when ..." clause with the words users actually type',
+            });
+        }
+        return findings;
+    },
+};
+const s103 = {
+    id: "S103",
+    title: "trigger collision in skill set",
+    surface: "skill",
+    check({ skill, set }) {
+        // Only emit from the first skill to avoid duplicate pair reports.
+        if (set.skills.length < 2 || set.skills[0] !== skill)
+            return [];
+        const findings = [];
+        const entries = set.skills
+            .filter((s) => s.description)
+            .map((s) => ({ label: skillLabel(s), tokens: new Set(normalize(s.description)) }));
+        for (let i = 0; i < entries.length && findings.length < 5; i++) {
+            for (let j = i + 1; j < entries.length && findings.length < 5; j++) {
+                const a = entries[i];
+                const b = entries[j];
+                const inter = [...a.tokens].filter((t) => b.tokens.has(t)).length;
+                const union = new Set([...a.tokens, ...b.tokens]).size;
+                if (union > 0 && inter / union > 0.55) {
+                    findings.push({
+                        ruleId: "S103",
+                        severity: "warn",
+                        title: "trigger collision in skill set",
+                        message: `skills "${a.label}" and "${b.label}" have ${Math.round((inter / union) * 100)}% overlapping descriptions; hosts may trigger the wrong one`,
+                        fixHint: "differentiate the descriptions by task and trigger words",
+                    });
+                }
+            }
+        }
+        const names = set.skills.map((s) => s.name).filter(Boolean);
+        const dupes = names.filter((n, i) => names.indexOf(n) !== i);
+        for (const d of [...new Set(dupes)]) {
+            findings.push({
+                ruleId: "S103",
+                severity: "error",
+                title: "trigger collision in skill set",
+                message: `duplicate skill name "${d}" in the set`,
+            });
+        }
+        return findings;
+    },
+};
+function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 3);
+}
+const s104 = {
+    id: "S104",
+    title: "context budget",
+    surface: "skill",
+    check({ skill, weigh }) {
+        if (!weigh)
+            return [];
+        const entry = weigh.perSkill.find((e) => e.dir === skill.dir);
+        if (!entry)
+            return [];
+        const label = skillLabel(skill);
+        const findings = [];
+        // The spec targets ~100 tokens but allows a 1024-char description (~256
+        // tokens), so only flag metadata that is genuinely heavy, and as info.
+        if (entry.metadataTokens > 260) {
+            findings.push({
+                ruleId: "S104",
+                severity: "info",
+                title: "context budget",
+                message: `metadata level is ~${formatTokens(entry.metadataTokens)} tokens; the spec targets ~100 and this loads at startup for every installed skill`,
+                target: label,
+                fixHint: "tighten name + description",
+            });
+        }
+        if (entry.bodyTokens > 5000) {
+            findings.push({
+                ruleId: "S104",
+                severity: "warn",
+                title: "context budget",
+                message: `instructions are ~${formatTokens(entry.bodyTokens)} tokens (spec recommends staying under 5k)`,
+                target: label,
+                fixHint: "move detail into references/ files loaded on demand (progressive disclosure)",
+            });
+        }
+        if (entry.bodyLines > 500) {
+            findings.push({
+                ruleId: "S104",
+                severity: "warn",
+                title: "context budget",
+                message: `SKILL.md is ${entry.bodyLines} lines (spec recommends under 500)`,
+                target: label,
+            });
+        }
+        if (entry.bodyTokens > 2500 && entry.refFileCount === 0) {
+            findings.push({
+                ruleId: "S104",
+                severity: "info",
+                title: "context budget",
+                message: "long instructions with no referenced files; consider progressive disclosure (scripts/, references/, assets/)",
+                target: label,
+            });
+        }
+        return findings;
+    },
+};
+const s105 = {
+    id: "S105",
+    title: "possible instruction injection",
+    surface: "skill",
+    check({ skill }) {
+        const label = skillLabel(skill);
+        const findings = scanTextForInjection(skill.body, { ruleId: "S105", where: `skill "${label}" body`, cap: 8 });
+        if (skill.description) {
+            findings.push(...scanTextForInjection(skill.description, {
+                ruleId: "S105",
+                where: `skill "${label}" description`,
+                cap: Math.max(0, 8 - findings.length),
+            }));
+        }
+        return findings;
+    },
+};
+const s106 = {
+    id: "S106",
+    title: "broken or escaping file references",
+    surface: "skill",
+    check({ skill }) {
+        const findings = [];
+        const label = skillLabel(skill);
+        for (const ref of skill.referencedPaths) {
+            if (findings.length >= 10)
+                break;
+            if (!ref.exists) {
+                // Only a markdown link to a missing file is unambiguously a broken
+                // reference. A backticked path is too often an example in prose, so it
+                // is not flagged (avoids false positives on well-written skills).
+                if (ref.source !== "link")
+                    continue;
+                findings.push({
+                    ruleId: "S106",
+                    severity: "error",
+                    title: "broken or escaping file references",
+                    message: `references missing file "${ref.raw}"`,
+                    target: label,
+                    fixHint: "agents will fail mid-task when they try to open it",
+                });
+            }
+            else if (ref.raw.includes("..")) {
+                findings.push({
+                    ruleId: "S106",
+                    severity: "warn",
+                    title: "broken or escaping file references",
+                    message: `reference "${ref.raw}" escapes the skill directory; skills should be self-contained`,
+                    target: label,
+                });
+            }
+            else if (ref.raw.split("/").length > 2) {
+                findings.push({
+                    ruleId: "S106",
+                    severity: "info",
+                    title: "broken or escaping file references",
+                    message: `reference "${ref.raw}" is nested ${ref.raw.split("/").length - 1} levels deep (spec suggests one level from the skill root)`,
+                    target: label,
+                });
+            }
+        }
+        return findings;
+    },
+};
+export const SKILL_RULES = [s101, s102, s103, s104, s105, s106];

package/dist/skills/parse.d.ts

@@ -0,0 +1,4 @@
+import type { SkillInfo, SkillSet } from "../core/types.js";
+export declare function parseSkillFile(file: string): SkillInfo;
+/** Resolve a path (SKILL.md file, skill dir, or a directory of skills) into a SkillSet. */
+export declare function findSkills(input: string): SkillSet;

package/dist/skills/parse.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { walkFiles } from "../util/misc.js";
+const MD_LINK_RE = /\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+// Only backticked strings that look like a real intra-skill path: a directory
+// separator, no glob star. A bare filename in prose (`package.json`, `*.py`) is
+// an instruction, not a file the skill loads.
+const BACKTICK_PATH_RE = /`([^`\s*]*\/[^`\s*]*\.(?:md|txt|py|js|ts|mjs|json|yaml|yml|sh|csv|html))`/g;
+export function parseSkillFile(file) {
+    const dir = path.dirname(file);
+    const base = {
+        dir,
+        file,
+        frontmatter: {},
+        frontmatterRaw: "",
+        body: "",
+        bodyLines: 0,
+        referencedPaths: [],
+        files: [],
+    };
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (e) {
+        return { ...base, parseError: `cannot read file: ${e.message}` };
+    }
+    let body = raw;
+    if (/^---\r?\n/.test(raw)) {
+        const end = raw.slice(4).search(/^---\s*$/m);
+        if (end !== -1) {
+            base.frontmatterRaw = raw.slice(4, 4 + end);
+            body = raw.slice(4 + end).replace(/^---\s*\r?\n?/, "");
+            try {
+                const parsed = YAML.parse(base.frontmatterRaw);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    base.frontmatter = parsed;
+                }
+                else {
+                    base.parseError = "frontmatter is not a YAML mapping";
+                }
+            }
+            catch (e) {
+                base.parseError = `frontmatter YAML parse error: ${e.message}`;
+            }
+        }
+        else {
+            base.parseError = "frontmatter opened with --- but never closed";
+        }
+    }
+    else {
+        base.parseError = "missing YAML frontmatter (file must start with ---)";
+    }
+    base.body = body;
+    base.bodyLines = body.split(/\r?\n/).length;
+    if (typeof base.frontmatter.name === "string")
+        base.name = base.frontmatter.name;
+    if (typeof base.frontmatter.description === "string")
+        base.description = base.frontmatter.description;
+    const seen = new Set();
+    for (const [re, source] of [
+        [MD_LINK_RE, "link"],
+        [BACKTICK_PATH_RE, "code"],
+    ]) {
+        re.lastIndex = 0;
+        let m;
+        while ((m = re.exec(body))) {
+            const rawPath = m[1];
+            if (/^[a-z][a-z0-9+.-]*:/i.test(rawPath) || // http:, mailto:, etc.
+                rawPath.startsWith("#") ||
+                rawPath.startsWith("/") ||
+                rawPath.includes("*") || // a glob, not a file
+                /^[A-Za-z]:[\\/]/.test(rawPath)) {
+                continue;
+            }
+            const cleaned = rawPath.split("#")[0];
+            if (!cleaned || seen.has(cleaned))
+                continue;
+            seen.add(cleaned);
+            const resolved = path.resolve(dir, cleaned);
+            base.referencedPaths.push({ raw: cleaned, resolved, exists: fs.existsSync(resolved), source });
+        }
+    }
+    for (const f of walkFiles(dir, { maxDepth: 4 })) {
+        try {
+            base.files.push({ path: f, bytes: fs.statSync(f).size });
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return base;
+}
+/** Resolve a path (SKILL.md file, skill dir, or a directory of skills) into a SkillSet. */
+export function findSkills(input) {
+    const abs = path.resolve(input);
+    const stat = fs.statSync(abs);
+    if (stat.isFile()) {
+        return { root: path.dirname(abs), skills: [parseSkillFile(abs)] };
+    }
+    const direct = path.join(abs, "SKILL.md");
+    if (fs.existsSync(direct)) {
+        return { root: abs, skills: [parseSkillFile(direct)] };
+    }
+    const skills = [];
+    for (const f of walkFiles(abs, { maxDepth: 3 })) {
+        if (path.basename(f) === "SKILL.md")
+            skills.push(parseSkillFile(f));
+    }
+    skills.sort((a, b) => a.file.localeCompare(b.file));
+    return { root: abs, skills };
+}

package/dist/targets/clientConfigs.d.ts

@@ -0,0 +1,17 @@
+import type { ResolvedTarget } from "./resolve.js";
+export interface ClientServerEntry {
+    name: string;
+    target: Extract<ResolvedTarget, {
+        kind: "stdio" | "http";
+    }>;
+}
+export interface ClientConfigResult {
+    entries: ClientServerEntry[];
+    /** Config files that were found and parsed. */
+    sources: string[];
+    /** Paths that were checked but absent. */
+    missing: string[];
+}
+export declare const SUPPORTED_CLIENTS: readonly ["claude-code", "claude-desktop", "cursor", "vscode"];
+export type SupportedClient = (typeof SUPPORTED_CLIENTS)[number];
+export declare function loadClientServers(client: string, cwd?: string): ClientConfigResult;

package/dist/targets/clientConfigs.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const SUPPORTED_CLIENTS = ["claude-code", "claude-desktop", "cursor", "vscode"];
+export function loadClientServers(client, cwd = process.cwd()) {
+    const home = os.homedir();
+    const candidates = [];
+    switch (client) {
+        case "claude-code":
+            candidates.push({ file: path.join(cwd, ".mcp.json"), pick: (j) => topLevel(j, "mcpServers") }, { file: path.join(home, ".claude.json"), pick: (j) => claudeUserConfig(j, cwd) });
+            break;
+        case "claude-desktop": {
+            const file = process.platform === "win32"
+                ? path.join(process.env.APPDATA ?? path.join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json")
+                : process.platform === "darwin"
+                    ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+                    : path.join(home, ".config", "Claude", "claude_desktop_config.json");
+            candidates.push({ file, pick: (j) => topLevel(j, "mcpServers") });
+            break;
+        }
+        case "cursor":
+            candidates.push({ file: path.join(cwd, ".cursor", "mcp.json"), pick: (j) => topLevel(j, "mcpServers") }, { file: path.join(home, ".cursor", "mcp.json"), pick: (j) => topLevel(j, "mcpServers") });
+            break;
+        case "vscode":
+            candidates.push({ file: path.join(cwd, ".vscode", "mcp.json"), pick: (j) => topLevel(j, "servers") });
+            break;
+        default:
+            throw new Error(`unknown client "${client}" (supported: ${SUPPORTED_CLIENTS.join(", ")})`);
+    }
+    const result = { entries: [], sources: [], missing: [] };
+    const seen = new Set();
+    for (const { file, pick } of candidates) {
+        if (!fs.existsSync(file)) {
+            result.missing.push(file);
+            continue;
+        }
+        let json;
+        try {
+            json = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            result.missing.push(`${file} (unparseable JSON)`);
+            continue;
+        }
+        const servers = pick(json);
+        if (!servers) {
+            result.missing.push(`${file} (no server map found)`);
+            continue;
+        }
+        result.sources.push(file);
+        for (const [name, valueRaw] of Object.entries(servers)) {
+            if (seen.has(name))
+                continue;
+            const target = entryToTarget(name, valueRaw, client);
+            if (target) {
+                seen.add(name);
+                result.entries.push({ name, target });
+            }
+        }
+    }
+    return result;
+}
+function topLevel(j, key) {
+    if (j && typeof j === "object" && key in j) {
+        const v = j[key];
+        if (v && typeof v === "object")
+            return v;
+    }
+    return undefined;
+}
+function samePath(a, b) {
+    const ra = path.resolve(a);
+    const rb = path.resolve(b);
+    // Windows paths are case-insensitive and the drive letter case varies between
+    // process.cwd() (uppercase) and stored config keys (often lowercase).
+    return process.platform === "win32" ? ra.toLowerCase() === rb.toLowerCase() : ra === rb;
+}
+function claudeUserConfig(j, cwd) {
+    const merged = {};
+    const top = topLevel(j, "mcpServers");
+    if (top)
+        Object.assign(merged, top);
+    const projects = topLevel(j, "projects");
+    if (projects) {
+        for (const [proj, conf] of Object.entries(projects)) {
+            if (samePath(proj, cwd)) {
+                const projServers = topLevel(conf, "mcpServers");
+                if (projServers)
+                    Object.assign(merged, projServers);
+            }
+        }
+    }
+    return Object.keys(merged).length ? merged : undefined;
+}
+function entryToTarget(name, raw, client) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const v = raw;
+    const label = `${client}:${name}`;
+    if (typeof v.url === "string") {
+        const headers = v.headers && typeof v.headers === "object" ? v.headers : undefined;
+        return { kind: "http", url: v.url, label, headers };
+    }
+    if (typeof v.command === "string") {
+        const args = Array.isArray(v.args) ? v.args.map(String) : [];
+        const env = v.env && typeof v.env === "object" ? v.env : undefined;
+        return { kind: "stdio", command: v.command, args, label, env };
+    }
+    return undefined;
+}

package/dist/targets/repoScan.d.ts

@@ -0,0 +1,2 @@
+import type { RepoScan } from "../core/types.js";
+export declare function scanRepo(root: string): RepoScan;

package/dist/targets/resolve.d.ts

@@ -0,0 +1,28 @@
+export type ResolvedTarget = {
+    kind: "stdio";
+    command: string;
+    args: string[];
+    label: string;
+    env?: Record<string, string>;
+} | {
+    kind: "http";
+    url: string;
+    label: string;
+    headers?: Record<string, string>;
+} | {
+    kind: "skillset";
+    path: string;
+    label: string;
+} | {
+    kind: "repo";
+    path: string;
+    label: string;
+};
+export interface ResolveOptions {
+    forceStdio?: boolean;
+    forceSkill?: boolean;
+    forceRepo?: boolean;
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+}
+export declare function resolveTarget(input: string, opts?: ResolveOptions): ResolvedTarget;

package/dist/targets/resolve.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseCommandString, walkFiles } from "../util/misc.js";
+export function resolveTarget(input, opts = {}) {
+    if (opts.forceStdio) {
+        const { command, args } = parseCommandString(input);
+        if (!command)
+            throw new Error(`empty stdio command: "${input}"`);
+        return { kind: "stdio", command, args, label: input, env: opts.env };
+    }
+    if (/^https?:\/\//i.test(input)) {
+        return { kind: "http", url: input, label: input, headers: opts.headers };
+    }
+    const abs = path.resolve(input);
+    if (fs.existsSync(abs)) {
+        const stat = fs.statSync(abs);
+        if (opts.forceSkill)
+            return { kind: "skillset", path: abs, label: input };
+        if (opts.forceRepo)
+            return { kind: "repo", path: abs, label: input };
+        if (stat.isFile()) {
+            if (abs.toLowerCase().endsWith(".md"))
+                return { kind: "skillset", path: abs, label: input };
+            throw new Error(`"${input}" is a file but not a SKILL.md; pass a skill file, a directory, a URL, or a stdio command (use --stdio to force command mode)`);
+        }
+        if (hasSkillFile(abs))
+            return { kind: "skillset", path: abs, label: input };
+        return { kind: "repo", path: abs, label: input };
+    }
+    // --skill / --repo assert a filesystem path. If it does not exist, that is an
+    // error, never a stdio command to spawn: a read-only flag must not exec.
+    if (opts.forceSkill || opts.forceRepo) {
+        throw new Error(`"${input}" does not exist (pass an existing ${opts.forceSkill ? "skill" : "repo"} path)`);
+    }
+    const { command, args } = parseCommandString(input);
+    if (!command)
+        throw new Error(`cannot resolve target: "${input}"`);
+    return { kind: "stdio", command, args, label: input, env: opts.env };
+}
+function hasSkillFile(dir) {
+    if (fs.existsSync(path.join(dir, "SKILL.md")))
+        return true;
+    for (const f of walkFiles(dir, { maxDepth: 3 })) {
+        if (path.basename(f) === "SKILL.md")
+            return true;
+    }
+    return false;
+}

package/dist/testing/anthropicRunner.d.ts

@@ -0,0 +1,6 @@
+import type { Runner } from "./harness.js";
+/**
+ * The live runner. Used only by `efaimo test --live`, because every call spends
+ * tokens on the caller's ANTHROPIC_API_KEY.
+ */
+export declare function anthropicRunner(apiKey: string): Runner;

package/dist/testing/anthropicRunner.js

@@ -0,0 +1,33 @@
+/**
+ * The live runner. Used only by `efaimo test --live`, because every call spends
+ * tokens on the caller's ANTHROPIC_API_KEY.
+ */
+export function anthropicRunner(apiKey) {
+    return async (req) => {
+        const res = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({
+                model: req.model,
+                max_tokens: 1024,
+                ...(req.system ? { system: req.system } : {}),
+                messages: [{ role: "user", content: req.user }],
+            }),
+            redirect: "error",
+            signal: AbortSignal.timeout(60000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`anthropic API ${res.status}: ${body.slice(0, 160)}`);
+        }
+        const json = (await res.json());
+        return (json.content ?? [])
+            .filter((b) => b.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("");
+    };
+}