hippo-memory 1.60.0 → 1.62.0

package/dist/mcp/recall-tools.js

@@ -0,0 +1,320 @@
+// Read-side tool handlers: hippo_recall, hippo_assemble, hippo_drill and hippo_context.
+import * as path from 'path';
+import { fitBudget } from '../search/finalize.js';
+import { dropHeldCopies, duplicateKey, storedTextKeys } from '../same-text.js';
+import { retrieve as apiRetrieve, drillDown as apiDrillDown, assemble as apiAssemble, getContext as apiGetContext, buildSuppressionSummary } from '../api.js';
+import { autoDetectContext } from '../context-auto.js';
+import { resolveProjectIdentity } from '../project-identity.js';
+import { appendAuditEvent, auditQueryFields } from '../audit.js';
+import { detectAnchoring, hashQueryText, biasHintEnabled, buildSessionKey, getOrCreateRing, appendRecall, snapshotRing, } from '../recall-history.js';
+import { detectAvailabilityBias } from '../availability.js';
+import { openHippoDb, closeHippoDb } from '../db.js';
+import { estimateTokens } from '../token-ledger.js';
+import { assembleCost, assembleText, drillCost, drillText } from '../context-render.js';
+import { mcpActor, isJsonString, isJsonBoolean } from './protocol.js';
+import { sessionRecallHistoryMcp, lastRecalledIds, resolveClientKey } from './session-state.js';
+import { formatContinuityBlock, formatMemories, memoryCost, memoriesReserve, snapshotPiece, handoffPiece, trailPiece, contextCost, tailSection, planningSection, } from './format.js';
+function parseRecallArgs(args, defaultBudget) {
+    const query = String(args.query || '');
+    const budget = Number(args.budget) || defaultBudget;
+    const includeContinuity = Boolean(args.include_continuity);
+    const explicitScope = isJsonString(args.scope) && args.scope.length > 0
+        ? args.scope
+        : undefined;
+    const freshTailCountArg = Number(args.fresh_tail_count);
+    const freshTailCount = Number.isFinite(freshTailCountArg) && freshTailCountArg > 0
+        ? freshTailCountArg
+        : undefined;
+    const freshTailSessionId = isJsonString(args.fresh_tail_session_id) && args.fresh_tail_session_id.length > 0
+        ? args.fresh_tail_session_id
+        : undefined;
+    const summarizeOverflow = isJsonBoolean(args.summarize_overflow)
+        ? args.summarize_overflow
+        : undefined;
+    // Number-coerce, never typeof-check: "abc" must reach api.retrieve and fail as invalid_scorer_window, the same code HTTP returns.
+    const scorerWindow = args.scorer_window === undefined
+        ? undefined
+        : Number(args.scorer_window);
+    // session_id drives the goal-stack boost inside api.retrieve; same trim and 256-char cap as fresh_tail_session_id.
+    const sessionIdRaw = isJsonString(args.session_id) ? args.session_id.trim() : '';
+    const sessionId = sessionIdRaw.length > 0 && sessionIdRaw.length <= 256
+        ? sessionIdRaw
+        : undefined;
+    const recallExtra = {};
+    if (freshTailCount !== undefined)
+        recallExtra.freshTailCount = freshTailCount;
+    if (freshTailSessionId !== undefined)
+        recallExtra.freshTailSessionId = freshTailSessionId;
+    if (summarizeOverflow !== undefined)
+        recallExtra.summarizeOverflow = summarizeOverflow;
+    if (scorerWindow !== undefined)
+        recallExtra.scorerWindow = scorerWindow;
+    if (sessionId !== undefined)
+        recallExtra.sessionId = sessionId;
+    return { query, budget, includeContinuity, explicitScope, sessionId, recallExtra };
+}
+/** Builds the showRanked callback that renders the list MCP shows and parks the render in `out`. */
+function recallPresenter(budget, includeContinuity, anchorRing, queryHash, out) {
+    return ({ ranked, pool, droppedByScope }, apiResult) => {
+        // Sections are paid in print order, ahead of the memories and after the heading; one that does not fit is dropped whole.
+        let left = budget - memoriesReserve(budget);
+        const pays = (piece) => {
+            const tokens = estimateTokens(piece);
+            if (tokens > left)
+                return false;
+            left -= tokens;
+            return true;
+        };
+        const planPiece = planningSection(apiResult);
+        const showPlan = planPiece !== '' && pays(planPiece);
+        const tailRows = apiResult.results.filter((r) => r.isFreshTail || r.isSummary);
+        const showTail = tailRows.length > 0 && pays(tailSection(tailRows));
+        const continuityPiece = includeContinuity && apiResult.continuity ? `\n\n${formatContinuityBlock(apiResult.continuity)}` : '';
+        const showContinuity = continuityPiece !== '' && pays(continuityPiece);
+        // J1, J2 and C5: the hints and Cutoff block describe the list MCP shows, not the window band in apiResult.
+        const render = (cut) => {
+            const list = dropHeldCopies(cut, (r) => r.entry); // after every cut, so a merged row cut here never hides its sources
+            const anchoring = anchorRing ? detectAnchoring(snapshotRing(anchorRing), queryHash, list[0]?.entry.id ?? null) : null;
+            const availability = biasHintEnabled('availability')
+                ? detectAvailabilityBias({
+                    topK: list.map((r) => ({ id: r.entry.id, created: r.entry.created })),
+                    pool: pool.map((e) => ({ id: e.id, created: e.created })),
+                })
+                : null;
+            const shownIds = new Set(list.map((r) => r.entry.id));
+            const shownKeys = storedTextKeys(list.map((r) => r.entry));
+            const tail = showTail
+                ? dropHeldCopies(tailRows.filter((r) => !shownIds.has(r.id) && !shownKeys.has(duplicateKey(r.content))), (r) => r)
+                : [];
+            const s = buildSuppressionSummary({
+                totalCandidates: pool.length + droppedByScope,
+                droppedPreRank: droppedByScope + cut.length - list.length, // the bucket CLI and API recall put hidden copies in
+                droppedByBudget: Math.max(0, pool.length - cut.length), // an upper bound: rows that never matched count too
+                summarySubstitutionsAdded: tail.filter((r) => r.isSummary).length,
+                freshTailAdded: tail.filter((r) => r.isFreshTail && !r.isSummary).length,
+                suppressedByInterference: anchoring?.reason === 'memory_dominance' ? 1 : 0,
+            });
+            // Anchoring is the stronger pull, so it prints first; the Cutoff block sits above the list, where the agent reads it.
+            let text = anchoring ? `## Anchoring hint\n${anchoring.summary}\n[anchored_on: ${anchoring.memoryId}]\n\n---\n\n` : '';
+            if (availability)
+                text += `## Availability bias\n${availability.summary}\n\n---\n\n`;
+            if (showPlan)
+                text += planPiece;
+            const cutoffClauses = [];
+            if (s.droppedByBudget > 0)
+                cutoffClauses.push(`${s.droppedByBudget} dropped to fit limit`);
+            if (s.droppedPreRank > 0)
+                cutoffClauses.push(`${s.droppedPreRank} filtered pre-rank`);
+            if (s.summarySubstitutionsAdded > 0)
+                cutoffClauses.push(`${s.summarySubstitutionsAdded} summary substitutions added`);
+            if (s.freshTailAdded > 0)
+                cutoffClauses.push(`${s.freshTailAdded} fresh-tail added`);
+            if (s.suppressedByInterference > 0)
+                cutoffClauses.push(`${s.suppressedByInterference} suppressed by interference`);
+            if (cutoffClauses.length > 0) {
+                text += `## Cutoff\nShowing ${list.length} of ${s.totalCandidates} candidates; ${cutoffClauses.join('; ')}.\n\n---\n\n`;
+            }
+            // The window band's fresh-tail and summary rows follow the ranked list, or the MCP fields go unanswered.
+            text += formatMemories(list) + tailSection(tail) + (showContinuity ? continuityPiece : '');
+            return { anchoring, availability, text, list };
+        };
+        let results = fitBudget(ranked, Math.max(0, left), 1, memoryCost);
+        let rendered = render(results);
+        // The hints, Cutoff block and heading vary with the list, so the lowest-ranked entry goes until the whole response fits.
+        while (results.length > 1 && estimateTokens(rendered.text) > budget) {
+            results = results.slice(0, -1);
+            rendered = render(results);
+        }
+        out.rendered = rendered;
+        return rendered.list.map((r) => r.entry.id);
+    };
+}
+function appendRecallAudit(hippoRoot, event) {
+    const dbForAudit = openHippoDb(hippoRoot);
+    try {
+        appendAuditEvent(dbForAudit, event);
+    }
+    finally {
+        closeHippoDb(dbForAudit);
+    }
+}
+function auditRecallHints(call, query, anchorRing, queryHash, rendered) {
+    const { hippoRoot, tenantId, ctx } = call;
+    const { anchoring: mcpAnchoringHint, availability: mcpAvailabilityHint, list: shown } = rendered;
+    if (biasHintEnabled('anchoring')) {
+        if (anchorRing) {
+            // Appended after the final detect: anchoredOn feeds the cooldown for the next recall on this session.
+            appendRecall(anchorRing, queryHash, shown[0]?.entry.id ?? null, mcpAnchoringHint?.memoryId);
+            if (mcpAnchoringHint?.reason === 'memory_dominance') {
+                appendRecallAudit(hippoRoot, {
+                    tenantId,
+                    actor: ctx?.actor ?? 'mcp',
+                    op: 'recall_anchor_detected_memory_dominance',
+                    targetId: mcpAnchoringHint.memoryId,
+                    metadata: {
+                        memory_id: mcpAnchoringHint.memoryId,
+                        query_count: mcpAnchoringHint.queryCount ?? null,
+                    },
+                });
+            }
+            else if (mcpAnchoringHint?.reason === 'query_repeat') {
+                appendRecallAudit(hippoRoot, {
+                    tenantId,
+                    actor: ctx?.actor ?? 'mcp',
+                    op: 'recall_anchor_detected_query_repeat',
+                    targetId: mcpAnchoringHint.memoryId,
+                    metadata: { memory_id: mcpAnchoringHint.memoryId },
+                });
+            }
+        }
+        else {
+            // Telemetry: caller had no sessionId so ring tracking skipped.
+            // Per the recall-audit convention at api.ts:854, use SHA-256/16
+            // for prompt hashing (NOT hashQueryText which is FNV-1a 32-bit
+            // for recall matching; brute-force trivial for low-entropy
+            // queries). Codex round-2 P2 catch.
+            appendRecallAudit(hippoRoot, {
+                tenantId,
+                actor: ctx?.actor ?? 'mcp',
+                op: 'recall_anchor_skipped_no_session',
+                targetId: undefined,
+                metadata: auditQueryFields(query),
+            });
+        }
+    }
+    if (mcpAvailabilityHint) {
+        appendRecallAudit(hippoRoot, {
+            tenantId,
+            actor: ctx?.actor ?? 'mcp',
+            op: 'recall_availability_detected',
+            metadata: {
+                recent_fraction: mcpAvailabilityHint.recentFraction,
+                older_passed_over: mcpAvailabilityHint.olderCandidatesPassedOver,
+                returned_count: mcpAvailabilityHint.returnedCount,
+            },
+        });
+    }
+}
+export async function runRecallTool(call) {
+    const { ctx, hippoRoot, config, tenantId } = call;
+    const { query, budget, includeContinuity, explicitScope, sessionId, recallExtra } = parseRecallArgs(call.args, config.defaultBudget);
+    const apiCtx = {
+        hippoRoot,
+        tenantId,
+        actor: mcpActor(ctx),
+    };
+    const anchorRing = biasHintEnabled('anchoring') && sessionId
+        ? getOrCreateRing(sessionRecallHistoryMcp, buildSessionKey(tenantId, sessionId))
+        : null;
+    const queryHash = hashQueryText(query);
+    const out = {};
+    // RecallContractError throws reach the MCP caller raw, as mcp-recall-fresh-tail-policy.test.ts pins.
+    await apiRetrieve(apiCtx, {
+        query,
+        limit: 50,
+        scope: explicitScope,
+        includeContinuity,
+        mode: config.physics?.enabled !== false ? 'physics' : 'hybrid',
+        // The hint is computed below over the list MCP shows; the window band's copy would emit its audit row twice.
+        suppressAvailabilityHint: true,
+        keepHeldCopies: true,
+        ...recallExtra,
+        showRanked: recallPresenter(budget, includeContinuity, anchorRing, queryHash, out),
+    });
+    if (!out.rendered)
+        throw new Error('hippo_recall: api.retrieve returned without calling showRanked');
+    lastRecalledIds.set(resolveClientKey(ctx), out.rendered.list.map((r) => r.entry.id));
+    auditRecallHints(call, query, anchorRing, queryHash, out.rendered);
+    return out.rendered.text;
+}
+export function runAssembleTool({ args, ctx, hippoRoot, tenantId }) {
+    const sessionId = String(args.session_id || '');
+    if (!sessionId)
+        return 'No session_id provided.';
+    const budget = Number(args.budget);
+    const freshTailCount = Number(args.fresh_tail_count);
+    const summarizeOlder = args.summarize_older !== false;
+    const apiCtx = {
+        hippoRoot,
+        tenantId,
+        actor: mcpActor(ctx),
+    };
+    const explicitScope = isJsonString(args.scope) && args.scope.length > 0
+        ? args.scope
+        : undefined;
+    const assembleExtra = {};
+    if (Number.isFinite(budget) && budget > 0)
+        assembleExtra.budget = budget;
+    if (Number.isFinite(freshTailCount) && freshTailCount >= 0)
+        assembleExtra.freshTailCount = freshTailCount;
+    if (explicitScope !== undefined)
+        assembleExtra.scope = explicitScope;
+    const r = apiAssemble(apiCtx, sessionId, {
+        summarizeOlder,
+        ...assembleExtra,
+        cost: assembleCost(sessionId),
+    });
+    return assembleText(r);
+}
+export function runDrillTool({ args, ctx, hippoRoot, tenantId }) {
+    const summaryId = String(args.summary_id || '');
+    if (!summaryId)
+        return 'No summary_id provided.';
+    const limit = Number(args.limit);
+    const budget = Number(args.budget);
+    // The inputSchema rejects a depth outside 1..10 before this runs, so no silent clamp hides the cap.
+    const depth = args.depth === undefined ? undefined : Number(args.depth);
+    const apiCtx = {
+        hippoRoot,
+        tenantId,
+        actor: mcpActor(ctx),
+    };
+    const drillExtra = {};
+    if (Number.isFinite(limit) && limit > 0)
+        drillExtra.limit = limit;
+    if (Number.isFinite(budget) && budget > 0)
+        drillExtra.budget = budget;
+    if (depth !== undefined)
+        drillExtra.depth = depth;
+    const r = apiDrillDown(apiCtx, summaryId, { ...drillExtra, cost: drillCost });
+    if ('failure' in r) {
+        // v1.6.4: only not_drillable is caller-actionable. not_found
+        // intentionally collapses cross-tenant + scope-blocked + missing
+        // (codex round 3 P1: distinguishing scope_blocked would leak
+        // private-row existence on this surface).
+        if (r.failure === 'not_drillable') {
+            return `Id ${summaryId} is a leaf row, not a level-2+ summary; nothing to drill into.`;
+        }
+        return `No drillable summary at id=${summaryId}.`;
+    }
+    return drillText(r);
+}
+export async function runContextTool({ args, ctx, hippoRoot, config, tenantId }) {
+    const budget = args.budget === undefined
+        ? config.defaultContextBudget
+        : Number(args.budget);
+    if (!Number.isFinite(budget) || budget < 0)
+        return 'budget must be a non-negative number.';
+    if (budget === 0)
+        return '';
+    if (budget < memoriesReserve(budget))
+        return ''; // not even the heading fits, so nothing prints, as at budget 0
+    const exactScope = isJsonString(args.scope) && args.scope.length > 0
+        ? args.scope
+        : undefined;
+    // The served store names the project (an HTTP daemon runs from anywhere); the global root names none, so stdio falls back to its launch cwd.
+    const storeProject = resolveProjectIdentity(path.dirname(path.resolve(hippoRoot))).name;
+    const result = await apiGetContext({ hippoRoot, tenantId, actor: mcpActor(ctx) }, {
+        q: autoDetectContext(),
+        budget,
+        exactScope,
+        currentProject: storeProject !== '' ? storeProject : resolveProjectIdentity(process.cwd()).name,
+        cost: contextCost,
+    });
+    lastRecalledIds.set(resolveClientKey(ctx), result.entries.map((r) => r.entry.id));
+    return (result.activeSnapshot ? snapshotPiece(result.activeSnapshot) : '')
+        + (result.sessionHandoff ? handoffPiece(result.sessionHandoff) : '')
+        + (result.recentEvents ? trailPiece(result.recentEvents) : '')
+        + formatMemories(result.entries);
+}
+//# sourceMappingURL=recall-tools.js.map

package/dist/mcp/request.d.ts

@@ -0,0 +1,10 @@
+import { type McpContext, type McpRequest, type McpResponse } from './protocol.js';
+/**
+ * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
+ * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
+ * through this single function. Returns null for notifications (no response
+ * expected) and a McpResponse otherwise. Errors thrown by `executeTool` are
+ * the caller's problem — wrap with try/catch on the transport side.
+ */
+export declare function handleMcpRequest(req: McpRequest, ctx?: McpContext): Promise<McpResponse | null>;
+//# sourceMappingURL=request.d.ts.map

package/dist/mcp/request.js

@@ -0,0 +1,163 @@
+// Transport-agnostic request handling: tool dispatch table, tool execution and the JSON-RPC method switch.
+import { log } from '../log.js';
+import { getGlobalRoot, initGlobal } from '../shared.js';
+import { loadConfig } from '../config.js';
+import { resolveTenantId } from '../tenant.js';
+import { openHippoDb, closeHippoDb } from '../db.js';
+import { estimateTokens, recordTokenUse } from '../token-ledger.js';
+import { PACKAGE_VERSION } from '../version.js';
+import { validateToolArgs } from './tool-args.js';
+import { findHippoRoot, isJsonString, isJsonObjectRecord } from './protocol.js';
+import { TOOLS, TOOLS_BY_NAME, ARGS_CHECKED_BY_API } from './tools.js';
+import { runRecallTool, runAssembleTool, runDrillTool, runContextTool } from './recall-tools.js';
+import { runRememberTool, runOutcomeTool, runLearnTool } from './memory-tools.js';
+import { runPredictBaserateTool, runStatusTool, runConflictsTool, runResolveTool, runShareTool, runPeersTool } from './admin-tools.js';
+/**
+ * Zero-install first run (`npx -y hippo-memory mcp` with no store anywhere):
+ * create the global store instead of failing every tool call, and say so on
+ * stderr (stdout carries the protocol). `hippo init` in a project later adds
+ * a project store, which then takes precedence.
+ */
+function createGlobalStoreOnFirstRun() {
+    initGlobal();
+    const root = getGlobalRoot();
+    log.warn(`no memory store found; created the global store at ${root}. Run \`hippo init\` in a project for a project store.`);
+    return root;
+}
+// ── Token ledger (ROADMAP TE0) ──
+const MCP_TOKEN_SURFACES = new Map([
+    ['hippo_recall', 'mcp_recall'],
+    ['hippo_context', 'mcp_context'],
+]);
+/**
+ * Record the memory text a recall or context tool returned. Best-effort: a
+ * ledger failure never fails the tool call. Other tools are not recorded.
+ */
+function recordMcpTokens(toolName, output, ctx) {
+    const surface = MCP_TOKEN_SURFACES.get(toolName);
+    if (!surface || !output)
+        return;
+    try {
+        const hippoRoot = ctx?.hippoRoot ?? findHippoRoot();
+        if (!hippoRoot)
+            return;
+        const db = openHippoDb(hippoRoot);
+        try {
+            recordTokenUse(db, {
+                tenantId: ctx?.tenantId ?? resolveTenantId({}),
+                surface,
+                event: 'inject',
+                items: 0,
+                tokens: estimateTokens(output),
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+    }
+    catch (err) {
+        log.warnThenDebug('mcp-token-ledger', `token ledger write failed; the tool reply is unaffected: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ── Tool execution ──
+const TOOL_HANDLERS = new Map([
+    ['hippo_recall', runRecallTool],
+    ['hippo_assemble', runAssembleTool],
+    ['hippo_drill', runDrillTool],
+    ['hippo_predict_baserate', runPredictBaserateTool],
+    ['hippo_remember', runRememberTool],
+    ['hippo_outcome', runOutcomeTool],
+    ['hippo_context', runContextTool],
+    ['hippo_status', runStatusTool],
+    ['hippo_learn', runLearnTool],
+    ['hippo_conflicts', runConflictsTool],
+    ['hippo_resolve', runResolveTool],
+    ['hippo_share', runShareTool],
+    ['hippo_peers', runPeersTool],
+]);
+async function executeTool(name, args, ctx) {
+    // When a transport hands us a context (HTTP path), trust it: the HTTP
+    // server already resolved hippoRoot from its bound opts and tenantId
+    // from the Bearer token (or the loopback fallback). The stdio path
+    // continues to walk from cwd / fall back to the global root, and to
+    // resolve tenant from HIPPO_TENANT.
+    const hippoRoot = ctx?.hippoRoot ?? findHippoRoot() ?? createGlobalStoreOnFirstRun();
+    const config = loadConfig(hippoRoot);
+    // A5: every store read in this server returns to the caller and is
+    // tenant-isolated. Resolved once per tool call: prefer the transport's
+    // ctx.tenantId so an HTTP Bearer for tenant B doesn't drop to HIPPO_TENANT.
+    const tenantId = ctx?.tenantId ?? resolveTenantId({});
+    const handler = TOOL_HANDLERS.get(name);
+    // handleMcpRequest rejects names missing from TOOLS, so reaching here means TOOLS and this table drifted apart.
+    if (!handler)
+        throw new Error(`hippo-mcp: tool ${name} is declared but has no handler`);
+    return handler({ args, ctx, hippoRoot, config, tenantId });
+}
+// ── Request handling ──
+/**
+ * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
+ * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
+ * through this single function. Returns null for notifications (no response
+ * expected) and a McpResponse otherwise. Errors thrown by `executeTool` are
+ * the caller's problem — wrap with try/catch on the transport side.
+ */
+export async function handleMcpRequest(req, ctx) {
+    const { id, method, params } = req;
+    switch (method) {
+        case 'initialize':
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'hippo-memory', version: PACKAGE_VERSION },
+                },
+            };
+        case 'notifications/initialized':
+            return null;
+        case 'tools/list':
+            return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+        case 'tools/call': {
+            const nameValue = params?.name;
+            const toolName = isJsonString(nameValue) ? nameValue : '';
+            const tool = TOOLS_BY_NAME.get(toolName);
+            if (!tool) {
+                return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown tool: ${toolName.slice(0, 128)}` } };
+            }
+            const argumentsValue = params?.arguments;
+            if (argumentsValue !== undefined && argumentsValue !== null && !isJsonObjectRecord(argumentsValue)) {
+                return { jsonrpc: '2.0', id, error: { code: -32602, message: `${toolName}: arguments must be an object` } };
+            }
+            const toolArgs = isJsonObjectRecord(argumentsValue) ? argumentsValue : {};
+            // The MCP spec reports input validation as a tool result with isError, so the model can read it and retry.
+            const problems = validateToolArgs(tool.inputSchema, toolArgs, ARGS_CHECKED_BY_API.get(toolName));
+            if (problems.length > 0) {
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: { content: [{ type: 'text', text: `Invalid arguments for ${toolName}: ${problems.join('; ')}` }], isError: true },
+                };
+            }
+            const output = await executeTool(toolName, toolArgs, ctx);
+            recordMcpTokens(toolName, output, ctx);
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    content: [{ type: 'text', text: output || 'Done.' }],
+                },
+            };
+        }
+        default:
+            // Notifications (no id) must not receive a response
+            if (method.startsWith('notifications/'))
+                return null;
+            return {
+                jsonrpc: '2.0',
+                id,
+                error: { code: -32601, message: `Method not found: ${method}` },
+            };
+    }
+}
+//# sourceMappingURL=request.js.map

package/dist/mcp/server.d.ts

@@ -7,79 +7,8 @@
  *
  * Usage: hippo mcp (or npx hippo-memory mcp)
  */
-import { type ResolveProjectIdentityOpts } from '../project-identity.js';
-/** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
-export declare function __resetSessionRecallHistoryMcp(): void;
-/** Same bounded walk as the CLI (ends at home, so HIPPO_HOME wins over ~/.hippo); cwd/opts are the test seam. */
-export declare function findHippoRoot(cwd?: string, opts?: ResolveProjectIdentityOpts): string | null;
-interface McpRequest {
-    jsonrpc: '2.0';
-    id: number | string;
-    method: string;
-    params?: Record<string, JsonValue>;
-}
-interface McpResponse {
-    jsonrpc: '2.0';
-    id: number | string;
-    result?: unknown;
-    error?: {
-        code: number;
-        message: string;
-        data?: {
-            requestId: string;
-        };
-    };
-}
-/** JSON-RPC reply for a request that threw: typed API errors keep their text; anything else is logged and answered generically. */
-export declare function mcpErrorResponse<E>(id: McpResponse['id'], err: E, requestId?: string): McpResponse;
-export type { McpRequest, McpResponse };
-/**
- * Optional execution context threaded from a non-stdio transport. When the
- * HTTP transport in src/server.ts calls handleMcpRequest, it knows the
- * server's bound hippoRoot and the auth-resolved tenantId/actor. Passing
- * those through here lets executeTool skip the findHippoRoot() walk and
- * the env-based resolveTenantId({}) fallback — both of which would
- * otherwise produce the wrong store and the wrong tenant for HTTP callers.
- *
- * Stdio callers pass nothing; behavior stays unchanged for that path.
- */
-export interface McpContext {
-    hippoRoot: string;
-    tenantId: string;
-    actor: string;
-    /**
-     * The caller's role from the HTTP transport's auth. Absent for stdio, which
-     * is the local operator and runs as admin. Tools must use this rather than
-     * assuming admin, or a member key over HTTP-MCP would act as admin.
-     */
-    role?: 'admin' | 'member';
-    /** EI2: scope grants for the HTTP-MCP caller's key. Absent for stdio (admin, needs none). */
-    scopes?: readonly string[];
-    viaAuthResolver?: true;
-    /**
-     * Per-client key for state isolation under HTTP-MCP. For stdio: 'stdio-${pid}'
-     * (one process = one client). For HTTP-SSE / HTTP MCP: hash(bearer + remoteAddr)
-     * built by src/server.ts when constructing McpContext for the request.
-     * Optional for backwards compatibility; defaults to `${tenantId}:default`.
-     */
-    clientKey?: string;
-}
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/**
- * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
- * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
- * through this single function. Returns null for notifications (no response
- * expected) and a McpResponse otherwise. Errors thrown by `executeTool` are
- * the caller's problem — wrap with try/catch on the transport side.
- */
-export declare function handleMcpRequest(req: McpRequest, ctx?: McpContext): Promise<McpResponse | null>;
-/**
- * Wire stdin/stdout to the dispatcher. Idempotent — only the entrypoint
- * (cli.ts `hippo mcp`, or running this file directly) should call this.
- * src/server.ts imports `handleMcpRequest` without invoking this, so the
- * HTTP daemon does not steal stdin or exit when its parent closes a pipe.
- */
-export declare function startStdioLoop(): void;
+export { __resetSessionRecallHistoryMcp } from './session-state.js';
+export { findHippoRoot, mcpErrorResponse, type McpRequest, type McpResponse, type McpContext } from './protocol.js';
+export { handleMcpRequest } from './request.js';
+export { startStdioLoop } from './stdio.js';
 //# sourceMappingURL=server.d.ts.map