wyrm-mcp 7.2.0 → 7.2.2

package/dist/handlers/recall.js

@@ -1,218 +1,11 @@
-/**
- * Recall domain — ToolSpec contract v2 (v7 F3 T026, hot-path extraction).
- *
- * wyrm_recall, moved VERBATIM from the index.ts dispatch switch +
- * buildAllTools(). Hybrid (FTS ⊕ vectors, RRF) when a vector store is
- * configured, lexical otherwise — exactly the 6.x routing. The access-decay
- * UPDATE moved with the handler (the ctx.raw() verbatim-SQL seam).
- *
- * T019 renderer: the result list is the canonical structured body; the 6.x
- * prose derives from it (ASCII default — the kind emoji moved off the default
- * text, spec §6 reformat).
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later — dual-licensed; commercial terms: ghosts.lk@proton.me. See LICENSE.
- */
-import { TOOL_ANNOTATIONS } from '../tool-annotations.js';
-import { renderResult, withGlyph } from '../render.js';
-import { memoryUri, resourceLink } from './resources.js';
-export const recallToolSpecs = [
-    {
-        name: "wyrm_recall",
-        description: "Use before starting any non-trivial task - what do we know about this? Pull up relevant lessons learned, proven patterns, anti-patterns, and reasoning traces from past work. Hybrid lexical+semantic retrieval, fully local, no LLM. Mark what you recalled as useful (or not) with wyrm_feedback.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                // v7 F3 (T026): property prose compressed to fund the hot-path
-                // outputSchemas under the 8K default-surface pin (T022/T025 trade).
-                projectPath: { type: "string" },
-                query: { type: "string", description: "The task or problem" },
-                kind: {
-                    type: "string",
-                    enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"],
-                },
-                limit: { type: "number", description: "Default 10" },
-                minConfidence: { type: "number", description: "0-1 (default 0)" },
-                // v7 F4 (T034): 'full' (default) inlines the complete result bodies;
-                // 'link' ALSO appends a wyrm://memory/{id} resource_link per result for
-                // resource-capable clients. Either way the full body rides — the link
-                // is additive, never a substitution (no data loss).
-                detail: { type: "string", enum: ["full", "link"], description: "Default full" },
-            },
-            required: ["projectPath", "query"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string" },
-                count: { type: "integer" },
-                results: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            id: { type: "integer" },
-                            kind: { type: "string" },
-                            relevance: { type: "number" },
-                            problem: { type: "string" },
-                            // FEATHERWEIGHT review (major): constraints/why_it_worked/outcome/
-                            // reuse_success_count carry the fix rationale + the negative-
-                            // learning signal. They ride the body undeclared (declaring them
-                            // here would push the default ListTools surface OVER the §7.1 8K
-                            // pin). Losslessness under WYRM_CHANNEL=structured is instead
-                            // guaranteed by recall being exemptStructured (handler below): its
-                            // FULL per-result prose always rides the text channel, so the
-                            // rationale never depends on a consumer preserving undeclared
-                            // structured fields.
-                            validated_fix: { type: ["string", "null"] },
-                            confidence: { type: "number" },
-                            reuse_count: { type: "integer" },
-                        },
-                        required: ["id", "kind", "relevance", "problem", "confidence", "reuse_count"],
-                    },
-                },
-            },
-            required: ["query", "count", "results"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_recall,
-        aliases: [],
-        handler: async (args, { store, raw, memory, vectors, clientSupportsResources }) => {
-            const { projectPath: rcPath, query: rcQuery, kind: rcKind, limit: rcLimit, minConfidence: rcMinConf, detail: rcDetail } = args;
-            const rcProject = store.getProject(rcPath);
-            if (!rcProject)
-                return { content: [{ type: "text", text: `Project not found: ${rcPath}` }], isError: true };
-            // Hybrid (FTS ⊕ vectors, RRF) when a vector store is available; lexical otherwise.
-            const rcOpts = { kind: rcKind, limit: rcLimit ?? 10, minConfidence: rcMinConf };
-            const results = vectors()
-                ? await memory.recallHybrid(rcProject.id, rcQuery, rcOpts)
-                : memory.recall(rcProject.id, rcQuery, rcOpts);
-            // Track access for memory decay
-            if (results.length > 0) {
-                const ids = results.map(r => r.artifact.id);
-                const placeholders = ids.map(() => '?').join(',');
-                raw().prepare(`UPDATE memory_artifacts SET last_accessed_at = datetime('now'), access_count = access_count + 1 WHERE id IN (${placeholders})`).run(...ids);
-            }
-            // FEATHERWEIGHT #5 — number & null hygiene (default, lossless):
-            //  (a) `relevance` is an internal RRF/FTS ranking score in [0,1] the
-            //      consumer only ever reads as an ORDER and renders as an integer %
-            //      (text channel: `(relevance*100).toFixed(0)`). Its raw form carries
-            //      up to 17 significant digits of float noise (0.9992261132463348)
-            //      that no consumer compares on. Rounding to 4 dp (0.0001 resolution —
-            //      100× finer than the integer-% display and far below any tie the
-            //      sort could surface) drops only excess precision, never a value a
-            //      consumer distinguishes. `confidence` is rounded the same way (it is
-            //      stored ≤2 dp; the round is a no-op on clean rows and a safety clamp
-            //      on any future sub-percent float).
-            //  (b) `constraints`/`validated_fix`/`why_it_worked` are `string | null`.
-            //      A null is the ABSENCE of that rationale — it carries no information,
-            //      and the text derivation already guards each with a truthy check
-            //      (`if (a.validated_fix) …`), so an absent key reads identically to a
-            //      null one for every consumer. Omitting the key when null is lossless
-            //      null-elision (a present non-null value is ALWAYS kept). `outcome`,
-            //      `reuse_count`, `reuse_success_count` are non-null by construction
-            //      (enum default 'neutral' / integer counters) and ride unchanged.
-            const round4 = (n) => Math.round(n * 10000) / 10000;
-            const body = {
-                query: rcQuery,
-                count: results.length,
-                results: results.map((r) => {
-                    const a = r.artifact;
-                    const result = {
-                        id: a.id,
-                        kind: a.kind,
-                        relevance: round4(r.relevance_score),
-                        problem: a.problem,
-                        outcome: a.outcome,
-                        // round4(null) === 0 in JS, which would present an UNKNOWN
-                        // confidence as a meaningful 0%. The `confidence` column is `REAL
-                        // DEFAULT 1.0` but NOT NULL-constrained (migrations.ts), so a
-                        // synced/foreign row can carry null; preserve it rather than
-                        // coerce. round4 only ever drops excess float precision (lossless).
-                        confidence: a.confidence == null ? a.confidence : round4(a.confidence),
-                        reuse_count: a.reuse_count,
-                        reuse_success_count: a.reuse_success_count,
-                    };
-                    // Lossless null-elision: include the rationale fields only when they
-                    // carry a value (a null = no rationale = nothing to transmit; the text
-                    // derivation already guards each with a truthy check, so an absent key
-                    // reads identically to a null one for every consumer).
-                    if (a.constraints != null)
-                        result.constraints = a.constraints;
-                    if (a.validated_fix != null)
-                        result.validated_fix = a.validated_fix;
-                    if (a.why_it_worked != null)
-                        result.why_it_worked = a.why_it_worked;
-                    return result;
-                }),
-            };
-            const rendered = renderResult(body, (b, g) => {
-                if (b.count === 0) {
-                    return withGlyph(g.brand, `No relevant memory found for: "${b.query}"`) +
-                        `\n\nUse \`wyrm_remember\` to store knowledge as you work.`;
-                }
-                let text = withGlyph(g.brand, `**Memory Recall** -- "${b.query}" (${b.count} found)`) + '\n\n';
-                for (const a of b.results) {
-                    text += `### ${a.kind} (ID: ${a.id}) -- relevance ${(a.relevance * 100).toFixed(0)}%\n`;
-                    text += `**Problem:** ${a.problem}\n`;
-                    if (a.constraints)
-                        text += `**Constraints:** ${a.constraints}\n`;
-                    if (a.validated_fix)
-                        text += `**Solution:** ${a.validated_fix}\n`;
-                    if (a.why_it_worked)
-                        text += `**Why:** ${a.why_it_worked}\n`;
-                    if (a.outcome === 'negative')
-                        text += withGlyph(g.warn, `_This approach failed -- see solution for what to do instead_`) + '\n';
-                    // Mirror the structured-body null guard (FW follow-up second-round):
-                    // a synced/foreign row can carry a null confidence (`REAL DEFAULT 1.0`
-                    // but NOT NULL-constrained in migrations.ts). null * 100 === 0 in JS
-                    // would render an UNKNOWN confidence as a meaningful "0%" on the text
-                    // channel — the SAME invented-value bug the minors commit fixed in the
-                    // structured body, but on recall's dominant (exemptStructured) channel.
-                    // Render "unknown" so unknown ≠ 0%.
-                    const confStr = a.confidence == null ? 'unknown' : `${(a.confidence * 100).toFixed(0)}%`;
-                    text += `_Confidence: ${confStr} | Used ${a.reuse_count}x | Success rate: ${a.reuse_count > 0 ? ((a.reuse_success_count / a.reuse_count) * 100).toFixed(0) + '%' : 'not yet used'}_\n\n`;
-                }
-                text += `_Use \`wyrm_feedback\` to record whether these were helpful._`;
-                return text;
-            }, {
-                // FEATHERWEIGHT review (major): recall's per-result rationale lives in
-                // body fields NOT declared in outputSchema (declaring them would push
-                // the default ListTools surface over the §7.1 8K pin). A strict harness
-                // that trims structuredContent to declared properties under
-                // WYRM_CHANNEL=structured would therefore drop the fix rationale + the
-                // negative-learning signal — UNLESS the text channel keeps carrying the
-                // full prose. So recall is exemptStructured: its complete per-result
-                // detail (problem/constraints/validated_fix/why_it_worked/outcome) rides
-                // the text channel on EVERY channel policy, never collapsing to a one-
-                // line header. Losslessness is then independent of consumer schema-
-                // trimming — the hard-gate-5 contract.
-                exemptStructured: true,
-            });
-            // v7 F4 (T034): resourceLink affordance. The full result bodies ALWAYS
-            // ride above (the detail=full FALLBACK is the default and is never
-            // dropped — no data loss for any client). ADDITIONALLY, append one
-            // wyrm://memory/{id} resource_link per result so a resource-capable client
-            // can re-fetch the canonical artifact on demand without re-running recall.
-            // The gate is EITHER honest signal that the client can resolve a link:
-            //   • the caller explicitly asked (detail='link') — an explicit request IS
-            //     the client telling us it understands wyrm:// links; OR
-            //   • the client advertised experimental.resources at initialize.
-            // detail='full' (the default) NEVER appends links — it is the resource-less
-            // fallback, the full inline body and nothing dangling. Either way the body
-            // is unchanged; the link is purely additive, so no client loses data and a
-            // resource-less client (no opt-in, no advertised capability) gets no link
-            // it cannot resolve. The links append to content[] AFTER the text block, so
-            // content[0].text + structuredContent are byte-identical to the base return.
-            const wantsLinks = rcDetail === 'link' || (rcDetail !== 'full' && !!clientSupportsResources?.());
-            if (wantsLinks && body.count > 0) {
-                const links = body.results.map((r) => resourceLink(memoryUri(r.id), `memory #${r.id} (${r.kind})`, {
-                    description: r.problem.slice(0, 120),
-                    mimeType: 'application/json',
-                }));
-                return { ...rendered, content: [...rendered.content, ...links] };
-            }
-            return rendered;
-        },
-    },
-];
-//# sourceMappingURL=recall.js.map
+import{TOOL_ANNOTATIONS as x}from"../tool-annotations.js";import{renderResult as j,withGlyph as u}from"../render.js";import{memoryUri as q,resourceLink as P}from"./resources.js";const U=[{name:"wyrm_recall",description:"Use before starting any non-trivial task - what do we know about this? Pull up relevant lessons learned, proven patterns, anti-patterns, and reasoning traces from past work. Hybrid lexical+semantic retrieval, fully local, no LLM. Mark what you recalled as useful (or not) with wyrm_feedback.",inputSchema:{type:"object",properties:{projectPath:{type:"string"},query:{type:"string",description:"The task or problem"},kind:{type:"string",enum:["reasoning_trace","lesson","pattern","anti_pattern","heuristic"]},limit:{type:"number",description:"Default 10"},minConfidence:{type:"number",description:"0-1 (default 0)"},detail:{type:"string",enum:["full","link"],description:"Default full"}},required:["projectPath","query"]},outputSchema:{type:"object",properties:{query:{type:"string"},count:{type:"integer"},results:{type:"array",items:{type:"object",properties:{id:{type:"integer"},kind:{type:"string"},relevance:{type:"number"},problem:{type:"string"},validated_fix:{type:["string","null"]},confidence:{type:"number"},reuse_count:{type:"integer"}},required:["id","kind","relevance","problem","confidence","reuse_count"]}}},required:["query","count","results"]},annotations:x.wyrm_recall,aliases:[],handler:async(y,{store:_,raw:w,memory:l,vectors:h,clientSupportsResources:k})=>{const{projectPath:d,query:i,kind:b,limit:v,minConfidence:$,detail:p}=y,c=_.getProject(d);if(!c)return{content:[{type:"text",text:`Project not found: ${d}`}],isError:!0};const f={kind:b,limit:v??10,minConfidence:$},o=h()?await l.recallHybrid(c.id,i,f):l.recall(c.id,i,f);if(o.length>0){const r=o.map(n=>n.artifact.id),e=r.map(()=>"?").join(",");w().prepare(`UPDATE memory_artifacts SET last_accessed_at = datetime('now'), access_count = access_count + 1 WHERE id IN (${e})`).run(...r)}const m=r=>Math.round(r*1e4)/1e4,s={query:i,count:o.length,results:o.map(r=>{const e=r.artifact,n={id:e.id,kind:e.kind,relevance:m(r.relevance_score),problem:e.problem,outcome:e.outcome,confidence:e.confidence==null?e.confidence:m(e.confidence),reuse_count:e.reuse_count,reuse_success_count:e.reuse_success_count};return e.constraints!=null&&(n.constraints=e.constraints),e.validated_fix!=null&&(n.validated_fix=e.validated_fix),e.why_it_worked!=null&&(n.why_it_worked=e.why_it_worked),n})},a=j(s,(r,e)=>{if(r.count===0)return u(e.brand,`No relevant memory found for: "${r.query}"`)+"\n\nUse `wyrm_remember` to store knowledge as you work.";let n=u(e.brand,`**Memory Recall** -- "${r.query}" (${r.count} found)`)+`
+
+`;for(const t of r.results){n+=`### ${t.kind} (ID: ${t.id}) -- relevance ${(t.relevance*100).toFixed(0)}%
+`,n+=`**Problem:** ${t.problem}
+`,t.constraints&&(n+=`**Constraints:** ${t.constraints}
+`),t.validated_fix&&(n+=`**Solution:** ${t.validated_fix}
+`),t.why_it_worked&&(n+=`**Why:** ${t.why_it_worked}
+`),t.outcome==="negative"&&(n+=u(e.warn,"_This approach failed -- see solution for what to do instead_")+`
+`);const g=t.confidence==null?"unknown":`${(t.confidence*100).toFixed(0)}%`;n+=`_Confidence: ${g} | Used ${t.reuse_count}x | Success rate: ${t.reuse_count>0?(t.reuse_success_count/t.reuse_count*100).toFixed(0)+"%":"not yet used"}_
+
+`}return n+="_Use `wyrm_feedback` to record whether these were helpful._",n},{exemptStructured:!0});if((p==="link"||p!=="full"&&!!k?.())&&s.count>0){const r=s.results.map(e=>P(q(e.id),`memory #${e.id} (${e.kind})`,{description:e.problem.slice(0,120),mimeType:"application/json"}));return{...a,content:[...a.content,...r]}}return a}}];export{U as recallToolSpecs};

package/dist/handlers/registry.js

@@ -1,167 +1 @@
-/**
- * Tool-handler registry (v7 A2; upgraded to the ToolSpec contract v2 in
- * v7 F3 T018). Domain modules export `ToolSpec[]` — ONE object per tool
- * carrying {name, description, inputSchema, outputSchema, annotations,
- * examples, aliases, handler} — and this registry derives from those specs:
- *
- *  (a) the DISPATCH map (`handlerRegistry`): the CallTool dispatcher consults
- *      it BEFORE the legacy `switch (name)` in index.ts, so an extracted tool
- *      is served from here while every tool still in the switch keeps its
- *      exact original path. Domains migrate in, one green-suite commit at a
- *      time, until the switch is empty (T036).
- *
- *  (b) the ADVERTISED wire entries (`registryToolDefs`): merged with
- *      buildAllTools() in the ListTools handler, then canonicalized by
- *      `buildStableToolList` — a byte-stable, deterministically ordered list
- *      (stable tool order, stable key order, no Date/random anywhere in the
- *      serialization; locked by tests/listtools-byte-stability.test.ts).
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later
- */
-import { goalToolSpecs } from './goals.js';
-import { captureToolSpecs } from './capture.js';
-import { recallToolSpecs } from './recall.js';
-import { searchToolSpecs } from './search.js';
-import { failureToolSpecs } from './failure.js';
-import { questToolSpecs } from './quest.js';
-import { sessionToolSpecs } from './session.js';
-import { reviewToolSpecs } from './review.js';
-import { runToolSpecs } from './run.js';
-import { declaredOutputSchemas } from './output-schemas.js';
-// v7 F4 (T036): the drained non-hot domains — every formerly switch-resident
-// tool, lifted VERBATIM into per-domain ToolSpec modules behind the broad
-// DispatcherContext slice. These complete the monolith drain (quest #80):
-// buildAllTools() + the 142-case switch are deleted; index.ts ≤1,000 lines.
-import { projectToolSpecs } from './project.js';
-import { eventsToolSpecs } from './events.js';
-import { skillToolSpecs } from './skill.js';
-import { datalakeToolSpecs } from './datalake.js';
-import { entityToolSpecs } from './entity.js';
-import { intelligenceToolSpecs } from './intelligence.js';
-import { orchestrationToolSpecs } from './orchestration.js';
-import { cloudToolSpecs } from './cloud.js';
-import { companionToolSpecs } from './companion.js';
-import { syncopsToolSpecs } from './syncops.js';
-import { presenceToolSpecs } from './presence.js';
-import { causalityToolSpecs } from './causality.js';
-import { symbolsToolSpecs } from './symbols.js';
-import { invoicingToolSpecs } from './invoicing.js';
-import { auditToolSpecs } from './audit.js';
-import { shareToolSpecs } from './share.js';
-import { agentToolSpecs } from './agent.js';
-import { mcpclientToolSpecs } from './mcpclient.js';
-/**
- * Every ToolSpec from every migrated domain. A domain's specs are typed
- * against its narrow context slice; they widen to ToolSpec<HandlerContext>
- * here by structural contravariance (HandlerContext implements every slice).
- * v7 F3 (T026): + the seven hot-path domains (capture write funnel, recall,
- * search incl. constellation, failure, quest, session+prime, review).
- */
-export const toolSpecs = [
-    ...goalToolSpecs,
-    ...captureToolSpecs,
-    ...recallToolSpecs,
-    ...searchToolSpecs,
-    ...failureToolSpecs,
-    ...questToolSpecs,
-    ...sessionToolSpecs,
-    ...reviewToolSpecs,
-    // v7 F3 (T027): the run loop — wyrm_run is a NEW first-class tool (the
-    // 32nd survivor), not an extraction; see handlers/run.ts + survivors.ts.
-    ...runToolSpecs,
-    // v7 F4 (T036): the drained non-hot domains (quest #80). Typed against the
-    // broad DispatcherContext slice; they widen to ToolSpec<HandlerContext> here
-    // by the same structural contravariance (DispatcherContext extends
-    // HandlerContext). index.ts wires `dispatcherCtx` once and the registry
-    // dispatches every name from this list — the switch is gone.
-    ...projectToolSpecs,
-    ...eventsToolSpecs,
-    ...skillToolSpecs,
-    ...datalakeToolSpecs,
-    ...entityToolSpecs,
-    ...intelligenceToolSpecs,
-    ...orchestrationToolSpecs,
-    ...cloudToolSpecs,
-    ...companionToolSpecs,
-    ...syncopsToolSpecs,
-    ...presenceToolSpecs,
-    ...causalityToolSpecs,
-    ...symbolsToolSpecs,
-    ...invoicingToolSpecs,
-    ...auditToolSpecs,
-    ...shareToolSpecs,
-    ...agentToolSpecs,
-    ...mcpclientToolSpecs,
-];
-/** Tool-name → handler, derived from the specs (never built by hand). */
-export const handlerRegistry = new Map(toolSpecs.map((spec) => [spec.name, spec.handler]));
-/**
- * Advertised ListTools entries for every registry-resident tool, derived from
- * the SAME ToolSpec objects that carry the handlers — surface and behavior
- * cannot drift. Annotations are deliberately NOT emitted here: the ListTools
- * pipeline merges them centrally via annotateTools() (tool-annotations.ts)
- * for switch- and registry-resident tools alike, and each ToolSpec.annotations
- * is locked to be the same registry entry by tests/toolspec-registry.test.ts.
- */
-export function registryToolDefs() {
-    return toolSpecs.map((spec) => ({
-        name: spec.name,
-        description: spec.description,
-        inputSchema: spec.inputSchema,
-        ...(spec.outputSchema !== undefined ? { outputSchema: spec.outputSchema } : {}),
-    }));
-}
-/**
- * Attach declared outputSchemas (handlers/output-schemas.ts) to
- * switch-resident tools that already return structuredContent — T014's
- * wyrm_failure_check verdict is the first. Non-mutating; a tool that already
- * carries an outputSchema (a ToolSpec one) is left untouched.
- */
-export function applyDeclaredOutputSchemas(tools) {
-    return tools.map((tool) => {
-        const schema = declaredOutputSchemas[tool.name];
-        if (!schema || tool.outputSchema !== undefined)
-            return tool;
-        return { ...tool, outputSchema: schema };
-    });
-}
-// ── Byte-stable ListTools canonicalization (T018) ───────────────────────────
-/** Canonical top-level key order for one advertised tool entry. */
-const CANONICAL_TOOL_KEYS = ['name', 'description', 'inputSchema', 'outputSchema', 'annotations'];
-/**
- * Canonicalize the final advertised tool list so consecutive ListTools
- * serializations are BYTE-IDENTICAL (spec §7.1):
- *
- *  - stable TOOL order: sorted by name via codepoint comparison (never
- *    localeCompare — locale-dependent collation would make the bytes depend
- *    on the host environment);
- *  - stable KEY order per entry: the canonical keys above first, then any
- *    remaining keys in codepoint order (future-proof against new fields);
- *  - values are passed through UNTOUCHED: schemas/annotations are static
- *    literals whose insertion order is fixed at author time, and nothing in
- *    the pipeline derives from Date/random. (Deep key-sorting is deliberately
- *    avoided — it would rewrite inputSchema property order and break the
- *    golden-fixture schema_sha256 drift guards for zero stability gain.)
- *
- * Pure and non-mutating: same input ⇒ same output, fresh objects.
- */
-export function buildStableToolList(tools) {
-    return [...tools]
-        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
-        .map((tool) => {
-        const source = tool;
-        const out = {};
-        for (const key of CANONICAL_TOOL_KEYS) {
-            if (key in source && source[key] !== undefined)
-                out[key] = source[key];
-        }
-        const rest = Object.keys(source)
-            .filter((k) => !CANONICAL_TOOL_KEYS.includes(k) && source[k] !== undefined)
-            .sort();
-        for (const key of rest)
-            out[key] = source[key];
-        return out;
-    });
-}
-//# sourceMappingURL=registry.js.map
+import{goalToolSpecs as n}from"./goals.js";import{captureToolSpecs as s}from"./capture.js";import{recallToolSpecs as l}from"./recall.js";import{searchToolSpecs as a}from"./search.js";import{failureToolSpecs as f}from"./failure.js";import{questToolSpecs as u}from"./quest.js";import{sessionToolSpecs as S}from"./session.js";import{reviewToolSpecs as T}from"./review.js";import{runToolSpecs as d}from"./run.js";import{declaredOutputSchemas as h}from"./output-schemas.js";import{projectToolSpecs as y}from"./project.js";import{eventsToolSpecs as g}from"./events.js";import{skillToolSpecs as O}from"./skill.js";import{datalakeToolSpecs as x}from"./datalake.js";import{entityToolSpecs as k}from"./entity.js";import{intelligenceToolSpecs as b}from"./intelligence.js";import{orchestrationToolSpecs as v}from"./orchestration.js";import{cloudToolSpecs as L}from"./cloud.js";import{companionToolSpecs as j}from"./companion.js";import{syncopsToolSpecs as w}from"./syncops.js";import{presenceToolSpecs as A}from"./presence.js";import{causalityToolSpecs as C}from"./causality.js";import{symbolsToolSpecs as D}from"./symbols.js";import{invoicingToolSpecs as N}from"./invoicing.js";import{auditToolSpecs as _}from"./audit.js";import{shareToolSpecs as q}from"./share.js";import{agentToolSpecs as E}from"./agent.js";import{mcpclientToolSpecs as I}from"./mcpclient.js";const p=[...n,...s,...l,...a,...f,...u,...S,...T,...d,...y,...g,...O,...x,...k,...b,...v,...L,...j,...w,...A,...C,...D,...N,..._,...q,...E,...I],lo=new Map(p.map(o=>[o.name,o.handler]));function ao(){return p.map(o=>({name:o.name,description:o.description,inputSchema:o.inputSchema,...o.outputSchema!==void 0?{outputSchema:o.outputSchema}:{}}))}function fo(o){return o.map(t=>{const e=h[t.name];return!e||t.outputSchema!==void 0?t:{...t,outputSchema:e}})}const c=["name","description","inputSchema","outputSchema","annotations"];function uo(o){return[...o].sort((t,e)=>t.name<e.name?-1:t.name>e.name?1:0).map(t=>{const e=t,m={};for(const r of c)r in e&&e[r]!==void 0&&(m[r]=e[r]);const i=Object.keys(e).filter(r=>!c.includes(r)&&e[r]!==void 0).sort();for(const r of i)m[r]=e[r];return m})}export{fo as applyDeclaredOutputSchemas,uo as buildStableToolList,lo as handlerRegistry,ao as registryToolDefs,p as toolSpecs};