@tpsdev-ai/flair-mcp 0.53.0 → 0.54.1

package/dist/adapter-tools.js

@@ -0,0 +1,381 @@
+/**
+ * Stdio adapter bindings (flair#1580).
+ *
+ * The tool SET is derived from STDIO_TOOL_DESCRIPTORS. This module only
+ * supplies FlairClient HTTP handlers — one per stdio descriptor. A new
+ * descriptor with no handler (or a handler with no descriptor) fails at
+ * registration, so the surfaces cannot drift by omission.
+ */
+import { STDIO_TOOL_DESCRIPTORS, toStdioMcpToolDef, } from "@tpsdev-ai/flair-tool-descriptors";
+import { buildCatchupRequest, summarizeCatchup } from "./catchup.js";
+import { classifyError } from "./errors.js";
+import { jsonSchemaToZodShape } from "./json-schema-zod.js";
+import { deriveActivity } from "./presence.js";
+import { buildRecordUsageBody, citationIds, withCiteNudge } from "./usage.js";
+import { buildSkillSearchBody, buildSkillStoreBody, formatSkillCatalog, isSkillRecord, projectSkillSearchResponse, stripInternalMemoryFields, } from "./skills.js";
+function errorResult(err, flairUrl) {
+    return { content: [{ type: "text", text: classifyError(err, flairUrl) }], isError: true };
+}
+const memory_search = async ({ query, limit }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const results = await flair.memory.search(query, { limit: limit ?? 5 });
+        if (results.length === 0) {
+            return { content: [{ type: "text", text: "No relevant memories found." }] };
+        }
+        const text = results
+            .map((r, i) => {
+            const date = r.createdAt ? r.createdAt.slice(0, 10) : "";
+            const idStr = r.id ? `id:${r.id}` : "";
+            const meta = [date, r.type, idStr].filter(Boolean).join(", ");
+            return `${i + 1}. ${r.content}${meta ? ` (${meta})` : ""}`;
+        })
+            .join("\n");
+        return { content: [{ type: "text", text: withCiteNudge(text) }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const memory_store = async ({ content, type, durability, tags, visibility, usedMemoryIds }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const result = await flair.memory.write(content, {
+            type: (type ?? "session"),
+            durability: (durability ?? "standard"),
+            tags,
+            visibility: visibility,
+            dedup: true,
+            dedupThreshold: 0.95,
+            usedMemoryIds: citationIds(usedMemoryIds),
+        });
+        const deduplicated = result.deduplicated === true;
+        const matchedId = result.matchedId;
+        const effectiveVisibility = result.visibility;
+        const preview = content.length > 120 ? content.slice(0, 120) + "..." : content;
+        const tagStr = tags && tags.length > 0 ? tags.join(", ") : "none";
+        const lines = [
+            `Memory stored (id: ${result.id})`,
+            `Preview: ${preview}`,
+            `Size: ${content.length} chars`,
+            `Tags: ${tagStr}`,
+            `Type: ${type ?? "session"}, Durability: ${durability ?? "standard"}, Visibility: ${effectiveVisibility ?? "(server default)"}`,
+        ];
+        if (deduplicated && matchedId) {
+            lines.push("", `Note: similar to existing memory id=${matchedId} — both are kept. ` +
+                `If this was meant to UPDATE that memory rather than add a new one, use memory_update instead.`);
+        }
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            structuredContent: { deduplicated, id: result.id, written: true, ...(deduplicated ? { matchedId } : {}) },
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const memory_update = async ({ id, content, preserveHistory, usedMemoryIds }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const result = await flair.memory.update(id, content, {
+            preserveHistory,
+            usedMemoryIds: citationIds(usedMemoryIds),
+        });
+        const text = preserveHistory
+            ? `Memory updated: new version stored (id: ${result.id}), supersedes ${id}.`
+            : `Memory updated (id: ${id}).`;
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: { id: result.id, supersedes: preserveHistory ? id : undefined, written: true },
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const memory_get = async ({ id }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const mem = await flair.memory.get(id);
+        if (!mem)
+            return { content: [{ type: "text", text: `Memory ${id} not found.` }] };
+        return { content: [{ type: "text", text: `${mem.content}\n\n(type: ${mem.type}, durability: ${mem.durability}, created: ${mem.createdAt})` }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const memory_delete = async ({ id }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        await flair.memory.delete(id);
+        return { content: [{ type: "text", text: `Memory ${id} deleted.` }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const relationship_store = async ({ subject, predicate, object, confidence, validFrom, validTo, source }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const result = await flair.relationship.write({ subject, predicate, object, confidence, validFrom, validTo, source });
+        const confStr = confidence !== undefined ? ` (confidence: ${confidence})` : "";
+        return {
+            content: [{ type: "text", text: `Relationship recorded: ${subject} → ${predicate} → ${object}${confStr} (id: ${result.id})` }],
+            structuredContent: { id: result.id, subject, predicate, object, written: true },
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const bootstrap = async ({ maxTokens, currentTask, channel, surface, subjects }, { flair, heartbeat, rememberTask }) => {
+    if (currentTask)
+        rememberTask(currentTask);
+    heartbeat(deriveActivity({ channel, surface }));
+    try {
+        const result = await flair.bootstrap({ maxTokens, currentTask, channel, surface, subjects });
+        if (!result.context) {
+            return { content: [{ type: "text", text: "No context available." }] };
+        }
+        return { content: [{ type: "text", text: withCiteNudge(result.context) }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const soul_set = async ({ key, value }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        await flair.soul.set(key, value);
+        return { content: [{ type: "text", text: `Soul entry '${key}' set.` }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const soul_get = async ({ key }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const entry = await flair.soul.get(key);
+        if (!entry)
+            return { content: [{ type: "text", text: `No soul entry for '${key}'.` }] };
+        return { content: [{ type: "text", text: entry.value }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const flair_workspace_set = async ({ ref, label, provider, task, phase, summary }, { flair, agentId, heartbeat }) => {
+    heartbeat();
+    try {
+        const body = {
+            id: `${agentId}:${ref}`,
+            ref,
+            provider: provider ?? "mcp",
+            timestamp: new Date().toISOString(),
+        };
+        if (label)
+            body.label = label;
+        if (task)
+            body.taskId = task;
+        if (phase)
+            body.phase = phase;
+        if (summary)
+            body.summary = summary;
+        await flair.request("POST", "/WorkspaceState", body);
+        return { content: [{ type: "text", text: `Workspace state set: ref=${ref}${phase ? `, phase=${phase}` : ""} (attributed to ${agentId}).` }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const flair_orgevent = async ({ kind, summary, detail, scope, targets }, { flair, agentId, heartbeat }) => {
+    heartbeat();
+    try {
+        const body = { kind, summary };
+        if (detail)
+            body.detail = detail;
+        if (scope)
+            body.scope = scope;
+        if (targets && targets.length > 0)
+            body.targetIds = targets;
+        const result = await flair.request("POST", "/OrgEvent", body);
+        const targetStr = targets && targets.length > 0 ? ` → ${targets.join(", ")}` : "";
+        const idStr = result?.id ? ` (id: ${result.id})` : "";
+        return { content: [{ type: "text", text: `OrgEvent published: kind=${kind}${targetStr} (attributed to ${agentId})${idStr}.` }] };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const flair_catchup = async (args, { flair, agentId, heartbeat }) => {
+    heartbeat();
+    try {
+        // Owner-scope by construction: the request path is built from the CALLER's
+        // own agentId (identity), never a tool argument — `args` is consulted only
+        // for after/limit/ack. There is deliberately no agentId/participantId
+        // parameter, so a caller cannot name another feed (the server also refuses
+        // a cross-agent read with 403).
+        const request = buildCatchupRequest(agentId, args);
+        if (request.ackPosition) {
+            // Advance-on-ack (monotonic, re-ack safe) BEFORE the read, so a caller
+            // draining page N while acking page N-1 reads page N — and an ack never
+            // hides an event that was in the same response.
+            await flair.request("POST", request.ackPath, { position: request.ackPosition });
+        }
+        const page = await flair.request("GET", request.getPath);
+        const { text, structuredContent } = summarizeCatchup(page, request.ackPosition);
+        return { content: [{ type: "text", text }], structuredContent };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const record_usage = async ({ memoryId, memoryIds, attribution }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const body = buildRecordUsageBody({ memoryId, memoryIds, attribution });
+        if (!body) {
+            return {
+                content: [{ type: "text", text: "record_usage requires memoryId or memoryIds." }],
+                isError: true,
+            };
+        }
+        const result = await flair.request("POST", "/RecordUsage", body);
+        const text = result?.recorded === true ? "Usage recorded." : "Usage request accepted.";
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: { recorded: result?.recorded === true },
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const skill_store = async ({ content, trigger, name, description, tags }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const { id, body } = buildSkillStoreBody({
+            agentId: flair.agentId,
+            content,
+            trigger,
+            name,
+            description,
+            tags,
+            claimedClient: flair.claimedClient,
+        });
+        const result = await flair.request("PUT", `/Memory/${id}`, body);
+        const writtenId = typeof result?.id === "string" && result.id.length > 0 ? result.id : id;
+        const preview = content.length > 120 ? content.slice(0, 120) + "..." : content;
+        const lines = [
+            `Skill stored (id: ${writtenId})`,
+            `Preview: ${preview}`,
+            name ? `Name: ${name}` : undefined,
+            trigger ? `Trigger: ${trigger}` : undefined,
+        ].filter((line) => line != null);
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            structuredContent: { id: writtenId, written: true },
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const skill_search = async ({ task, limit }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const raw = await flair.request("POST", "/SemanticSearch", buildSkillSearchBody({ task, limit: limit ?? 5 }));
+        const projected = projectSkillSearchResponse(raw);
+        if (!projected || typeof projected !== "object" || !Array.isArray(projected.results)) {
+            return { content: [{ type: "text", text: "No matching skills found." }] };
+        }
+        const results = projected.results;
+        return {
+            content: [{ type: "text", text: formatSkillCatalog(results) }],
+            structuredContent: { results },
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+const skill_get = async ({ id }, { flair, heartbeat }) => {
+    heartbeat();
+    try {
+        const mem = await flair.memory.get(id);
+        if (!mem || !isSkillRecord(mem)) {
+            return { content: [{ type: "text", text: `Skill ${id} not found.` }] };
+        }
+        const record = stripInternalMemoryFields(mem);
+        const trigger = typeof record.trigger === "string" && record.trigger.length > 0 ? record.trigger : "";
+        const text = [
+            record.content,
+            "",
+            `(id: ${record.id}${trigger ? `, trigger: ${trigger}` : ""}, tags: ${Array.isArray(record.tags) ? record.tags.join(", ") : "skill"}, created: ${record.createdAt ?? ""})`,
+        ].join("\n");
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: record,
+        };
+    }
+    catch (err) {
+        return errorResult(err, flair.url);
+    }
+};
+/** FlairClient bindings keyed by descriptor name — the adapter-side impl map. */
+export const STDIO_TOOL_HANDLERS = {
+    memory_search,
+    memory_store,
+    memory_update,
+    memory_get,
+    memory_delete,
+    relationship_store,
+    bootstrap,
+    soul_set,
+    soul_get,
+    flair_workspace_set,
+    flair_orgevent,
+    flair_catchup,
+    record_usage,
+    skill_store,
+    skill_search,
+    skill_get,
+};
+export function stdioHandlerNames() {
+    return Object.keys(STDIO_TOOL_HANDLERS).sort();
+}
+/**
+ * Register every stdio descriptor on the MCP server. The advertised set is
+ * STDIO_TOOL_DESCRIPTORS — not a hand-written per-tool literal list.
+ */
+export function registerStdioTools(server, ctx) {
+    const registered = [];
+    const missing = [];
+    for (const d of STDIO_TOOL_DESCRIPTORS) {
+        const handler = STDIO_TOOL_HANDLERS[d.name];
+        if (!handler) {
+            missing.push(d.name);
+            continue;
+        }
+        const def = toStdioMcpToolDef(d);
+        const shape = jsonSchemaToZodShape(def.inputSchema);
+        const cb = async (args) => handler(args, ctx);
+        if (d.annotations) {
+            server.tool(d.name, def.description, shape, d.annotations, cb);
+        }
+        else {
+            server.tool(d.name, def.description, shape, cb);
+        }
+        registered.push(d.name);
+    }
+    if (missing.length > 0) {
+        throw new Error(`stdio adapter missing FlairClient bindings for descriptors: ${missing.join(", ")}`);
+    }
+    const extra = Object.keys(STDIO_TOOL_HANDLERS).filter((n) => !registered.includes(n)).sort();
+    if (extra.length > 0) {
+        throw new Error(`stdio adapter bindings have no stdio descriptor: ${extra.join(", ")}`);
+    }
+    return registered;
+}

package/dist/catchup.d.ts

@@ -0,0 +1,58 @@
+/**
+ * catchup.ts — pure helpers for the flair_catchup stdio binding (flair#1583).
+ *
+ * Owner-scope is enforced BY CONSTRUCTION: the participantId in the request
+ * path is always the caller's own agentId (from `FLAIR_AGENT_ID` / the signed
+ * identity), never a tool argument. The descriptor advertises no `agentId` /
+ * `participantId` property, so there is nothing to name another agent's feed
+ * with — and the server independently refuses a cross-agent read (403). This
+ * module is HTTP-/Harper-free (plain helpers + types) so the flair-mcp
+ * package stays FlairClient-only.
+ */
+/**
+ * `GET /OrgEventCatchup/{participantId}` response shape
+ * (resources/OrgEventCatchup.ts). `position` is stamped onto every event
+ * (see org-event-catchup-lib.ts `withEventPosition`), and is what a caller
+ * passes back as `ack` once it has processed the event.
+ */
+export interface CatchupPage {
+    events?: Array<Record<string, unknown>> | null;
+    /** Resolved exclusive cursor this page was read after. */
+    after?: string | null;
+    /** Cursor to continue a drain — the last event's position (or `after` when the page is empty). */
+    nextAfter?: string | null;
+    /** Durable watermark at read time (null when the caller has none yet). */
+    watermark?: string | null;
+    hasMore?: boolean;
+    pageSize?: number;
+}
+export interface CatchupArgs {
+    after?: unknown;
+    limit?: unknown;
+    ack?: unknown;
+}
+export interface CatchupRequest {
+    /** Owner-scoped base path — the caller's own participantId. */
+    path: string;
+    /** GET path (base + optional query). */
+    getPath: string;
+    /** POST path for the ack (same owner-scoped base). */
+    ackPath: string;
+    /** Non-empty ack position, or null when the caller did not ack. */
+    ackPosition: string | null;
+}
+/**
+ * Build the owner-scoped catchup request from tool args. `participantId` is
+ * ALWAYS `agentId` — the args cannot redirect it.
+ */
+export declare function buildCatchupRequest(agentId: string, args: CatchupArgs): CatchupRequest;
+export interface CatchupSummary {
+    text: string;
+    structuredContent: Record<string, unknown>;
+}
+/**
+ * Project a catchup page into the caller-facing text summary plus the
+ * structured echo (the machine-readable payload). Never throws on a
+ * malformed/absent page — it degrades to "no new events".
+ */
+export declare function summarizeCatchup(page: CatchupPage | undefined, acked: string | null): CatchupSummary;

package/dist/catchup.js

@@ -0,0 +1,85 @@
+/**
+ * catchup.ts — pure helpers for the flair_catchup stdio binding (flair#1583).
+ *
+ * Owner-scope is enforced BY CONSTRUCTION: the participantId in the request
+ * path is always the caller's own agentId (from `FLAIR_AGENT_ID` / the signed
+ * identity), never a tool argument. The descriptor advertises no `agentId` /
+ * `participantId` property, so there is nothing to name another agent's feed
+ * with — and the server independently refuses a cross-agent read (403). This
+ * module is HTTP-/Harper-free (plain helpers + types) so the flair-mcp
+ * package stays FlairClient-only.
+ */
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+/**
+ * Build the owner-scoped catchup request from tool args. `participantId` is
+ * ALWAYS `agentId` — the args cannot redirect it.
+ */
+export function buildCatchupRequest(agentId, args) {
+    const path = `/OrgEventCatchup/${encodeURIComponent(agentId)}`;
+    const params = new URLSearchParams();
+    const after = nonEmptyString(args.after);
+    if (after)
+        params.set("after", after);
+    if (typeof args.limit === "number" && Number.isFinite(args.limit)) {
+        params.set("limit", String(Math.trunc(args.limit)));
+    }
+    const query = params.toString();
+    return {
+        path,
+        getPath: query ? `${path}?${query}` : path,
+        ackPath: path,
+        ackPosition: nonEmptyString(args.ack),
+    };
+}
+/**
+ * Project a catchup page into the caller-facing text summary plus the
+ * structured echo (the machine-readable payload). Never throws on a
+ * malformed/absent page — it degrades to "no new events".
+ */
+export function summarizeCatchup(page, acked) {
+    const events = Array.isArray(page?.events) ? page?.events : [];
+    const after = page?.after ?? null;
+    const nextAfter = page?.nextAfter ?? after;
+    const watermark = page?.watermark ?? null;
+    const hasMore = page?.hasMore === true;
+    const pageSize = page?.pageSize;
+    const header = events.length === 0
+        ? `Catchup: no new events after ${after ?? "(your watermark)"}.`
+        : `Catchup: ${events.length} event(s) after ${after ?? "(your watermark)"}${hasMore ? " (more available)" : ""}.`;
+    const lines = events.map((event, index) => {
+        const kind = typeof event.kind === "string" ? event.kind : "?";
+        const summary = typeof event.summary === "string" ? event.summary : "";
+        const id = typeof event.id === "string" ? `id:${event.id}` : "";
+        const position = typeof event.position === "string" ? `position:${event.position}` : "";
+        const targets = Array.isArray(event.targetIds) && event.targetIds.length > 0
+            ? `targets:${event.targetIds.join(",")}`
+            : "";
+        const meta = [id, position, targets].filter(Boolean).join(", ");
+        return `${index + 1}. [${kind}] ${summary}${meta ? ` (${meta})` : ""}`;
+    });
+    const cursorLines = [];
+    if (nextAfter)
+        cursorLines.push(`nextAfter: ${nextAfter}`);
+    if (acked)
+        cursorLines.push(`acked: ${acked}`);
+    if (nextAfter) {
+        cursorLines.push(hasMore
+            ? `More available — page again with after="${nextAfter}", then ack="${nextAfter}" once drained.`
+            : `Ack with ack="${nextAfter}" once you have processed these events to advance your watermark.`);
+    }
+    const body = [header, ...lines, ...(cursorLines.length > 0 ? ["", ...cursorLines] : [])].join("\n");
+    const structuredContent = {
+        events,
+        after,
+        nextAfter,
+        watermark,
+        hasMore,
+    };
+    if (typeof pageSize === "number")
+        structuredContent.pageSize = pageSize;
+    if (acked)
+        structuredContent.acked = acked;
+    return { text: body, structuredContent };
+}

package/dist/errors.d.ts

@@ -0,0 +1 @@
+export declare function classifyError(err: unknown, flairUrl: string): string;

package/dist/errors.js

@@ -0,0 +1,39 @@
+import { FlairError, formatKeyLookup, inspectKeyLookup } from "@tpsdev-ai/flair-client";
+import { readEnvOrUnset } from "./env-guard.js";
+export function classifyError(err, flairUrl) {
+    if (err instanceof FlairError) {
+        const { status, body } = err;
+        if (status === 400)
+            return `validation_error: ${body}`;
+        if (status === 401 || status === 403) {
+            // flair#1271: name the agent, the paths that were looked in, and the
+            // remedy. A cached-miss / wrong-HOME 401 is not a daemon-restart hint.
+            const lookup = err.keyLookup ?? {
+                ...inspectKeyLookup(readEnvOrUnset("FLAIR_AGENT_ID") ?? "", readEnvOrUnset("FLAIR_KEY_PATH")),
+                signed: false,
+                authMethod: "none",
+            };
+            return `auth_error: ${body}\n${formatKeyLookup(lookup)}`;
+        }
+        if (status === 413)
+            return `payload_too_large: ${body}`;
+        if (status === 429)
+            return "rate_limited — retry after a moment";
+        if (status >= 500)
+            return `server_error (retriable): ${body}`;
+        return `http_error (${status}): ${body}`;
+    }
+    if (err instanceof Error) {
+        if (err.name.includes("Abort") || err.name.includes("Timeout")) {
+            return "timeout — the server took too long. This often happens with large content that requires embedding. Try shorter content or retry.";
+        }
+        if (err instanceof TypeError && err.message.includes("fetch")) {
+            return `connection_error (retriable): could not reach Flair at ${flairUrl}. Is it running?\n` +
+                `(Diagnostics:\n` +
+                `  - 'curl ${flairUrl}/Health' — if this responds 200 or 401, daemon is up + this is an auth issue not a connection one.\n` +
+                `  - 'launchctl list | grep flair' (macOS) or 'systemctl status flair' (Linux).)`;
+        }
+        return `unexpected_error: ${err.message}`;
+    }
+    return `unexpected_error: ${String(err)}`;
+}

package/dist/index.d.ts

@@ -2,7 +2,7 @@
 /**
  * Flair MCP Server — persistent memory for Claude Code and any MCP client.
  *
- * Tools:
+ * Tools (derived from @tpsdev-ai/flair-tool-descriptors — flair#1580):
  *   - memory_search  — semantic search across memories
  *   - memory_store   — save a memory with type + durability
  *   - memory_update  — update an existing memory by ID (dedup-bypassed)
@@ -14,6 +14,7 @@
  *   - soul_get       — get a personality/context entry
  *   - flair_workspace_set — write own WorkspaceState (Office Space coordination)
  *   - flair_orgevent      — publish an OrgEvent attributed to self (no forging)
+ *   - flair_catchup       — drain + ack self's own OrgEventCatchup feed (owner-scoped)
  *   - record_usage        — report that recalled memories were actually used (flair#1147)
  *   - skill_store         — write a skill-tagged memory (trigger + procedure)
  *   - skill_search        — catalog skills that apply to a task (not the procedure)
@@ -42,5 +43,5 @@
  * — the silent `npx -y @tpsdev-ai/flair-mcp` failure. The shim checks the Node
  * version FIRST, then dynamically imports this module and calls runMcp().
  */
-export declare function classifyError(err: unknown, flairUrl: string): string;
+export { classifyError } from "./errors.js";
 export declare function runMcp(): Promise<void>;