@ggui-ai/negotiator 0.1.0-rc.1

package/dist/negotiate.js

@@ -0,0 +1,161 @@
+/**
+ * Negotiator — top-level orchestrator over the public storage +
+ * decision-engine seams.
+ *
+ * Pipeline:
+ *   1. RAG search (per-scope + optional shared pool) via
+ *      {@link ragSearch} — composes `EmbeddingProvider.embed` +
+ *      `VectorStore.query` from `@ggui-ai/mcp-server-core`.
+ *   2. Read session state (optional injectable).
+ *   3. Fast-path for exact blueprint hits — skip the decision LLM.
+ *   4. Otherwise call {@link makeDecision} with the RAG candidates and
+ *      session stack; fold the picked blueprint's pool provenance into
+ *      the return value.
+ *
+ * Timing logs (stable format — consumed by benchmarks):
+ *   [negotiate] embedding: Xms | search: Xms | candidates: N
+ *   [negotiate] candidate: <id8> | <description> | hash=<h16>
+ *   [negotiate] FAST PATH: blueprint=<id8> hash=<h12> | LLM decision: 0ms | total: Xms
+ *   [negotiate] LLM PATH: action=X blueprint=<id8> hash=<h12> | LLM decision: Xms | total: Xms
+ *
+ * ### Public surface + semver weight
+ *
+ * Exported:
+ *   - `negotiate(deps, input)` — runtime orchestrator.
+ *   - `NegotiateDeps` — injection shape (embedding / vectors / llm +
+ *     optional session-state reader + optional progress callback).
+ *   - `NegotiateInput` — agent signal + config.
+ *   - `NegotiateConfig` — minimum fields the orchestrator actually
+ *     reads. Pool selection is expressed as `includeSharedPool:
+ *     boolean` rather than a `poolMode` enum, so callers decide
+ *     shared-pool inclusion explicitly at each call site.
+ *   - `NegotiateResult` — the decision result returned to callers.
+ *
+ * ### Why this package, not `mcp-server-core`
+ *
+ * `mcp-server-core` locks storage/runtime seams MCP server
+ * implementers bind against (`EmbeddingProvider`, `VectorStore`,
+ * `Negotiator`). `negotiate()` is a *composition* over those seams —
+ * decision-engine semantics, not a new seam. Adding it to
+ * `mcp-server-core` would drag the LLM prompts + tool-schemas into a
+ * package whose job is to stay minimal and runtime-agnostic.
+ */
+import { ragSearch } from './rag-search.js';
+import { makeDecision } from './decision.js';
+/** Empty session state for cold starts and benchmarks. */
+const EMPTY_SESSION = {
+    stack: [],
+    conversationHistory: [],
+};
+/**
+ * Orchestrate one negotiation call — RAG search, session read, fast
+ * path, decision LLM. See module docstring for the pipeline outline.
+ */
+export async function negotiate(deps, input) {
+    const { agent, config } = input;
+    const negotiateStart = Date.now();
+    deps.onProgress?.('negotiating', 'Analyzing request...');
+    // Step 1: RAG search (per-app + optional shared pool in parallel).
+    // `embedding` + `vectors` are optional. When either is missing,
+    // ragSearch is a no-op (returns empty options + 0 latency); the
+    // decision LLM runs against zero candidates and falls back to
+    // "create" via its standard branching. OSS without RAG infrastructure
+    // gets useful negotiation from the decision LLM alone.
+    const queryText = agent.prompt ?? JSON.stringify(agent.data ?? {});
+    const emptyResult = { options: [], embeddingLatencyMs: 0, searchLatencyMs: 0 };
+    const ragDeps = deps.embedding !== undefined && deps.vectors !== undefined
+        ? { embedding: deps.embedding, vectors: deps.vectors }
+        : undefined;
+    const [appResult, sharedResult] = await Promise.all([
+        ragDeps
+            ? ragSearch(ragDeps, { prompt: queryText, scope: config.appId })
+            : Promise.resolve(emptyResult),
+        ragDeps && config.includeSharedPool
+            ? ragSearch(ragDeps, { prompt: queryText, scope: 'shared' })
+            : Promise.resolve(emptyResult),
+    ]);
+    const ragResult = {
+        options: [...appResult.options, ...sharedResult.options],
+        embeddingLatencyMs: Math.max(appResult.embeddingLatencyMs, sharedResult.embeddingLatencyMs),
+        searchLatencyMs: Math.max(appResult.searchLatencyMs, sharedResult.searchLatencyMs),
+    };
+    // eslint-disable-next-line no-console
+    console.log(`[negotiate] embedding: ${ragResult.embeddingLatencyMs}ms | search: ${ragResult.searchLatencyMs}ms | candidates: ${ragResult.options.length}`);
+    for (const opt of ragResult.options) {
+        // eslint-disable-next-line no-console
+        console.log(`[negotiate] candidate: ${opt.blueprintId?.slice(-8) ?? 'none'} | ${opt.description.slice(0, 80)} | hash=${opt.contractHash?.slice(0, 16) ?? 'none'}`);
+    }
+    deps.onProgress?.('blueprint_search', ragResult.options.length > 0
+        ? `Found ${ragResult.options.length} blueprint candidate${ragResult.options.length > 1 ? 's' : ''}`
+        : 'No blueprints found');
+    // Step 2: Read session state (falls back to EMPTY_SESSION).
+    const sessionState = deps.readSessionState
+        ? ((await deps.readSessionState(config.sessionId)) ?? EMPTY_SESSION)
+        : EMPTY_SESSION;
+    // Step 3: Fast-path for high-confidence exact matches — skip decision LLM.
+    const exactOpt = ragResult.options.find((opt) => opt.description.includes('exact'));
+    if (exactOpt) {
+        const stackHasSameType = sessionState.stack.some((item) => item.prompt && agent.prompt && item.prompt === agent.prompt);
+        const action = stackHasSameType ? 'update' : 'create';
+        const totalMs = Date.now() - negotiateStart;
+        // eslint-disable-next-line no-console
+        console.log(`[negotiate] FAST PATH: blueprint=${exactOpt.blueprintId?.slice(-8)} hash=${exactOpt.contractHash?.slice(0, 12) ?? 'none'} | LLM decision: 0ms | total: ${totalMs}ms`);
+        deps.onProgress?.('deciding', 'Exact match found — fast path');
+        // The agent's prompt is the outer-pipeline intent (`intent` is not
+        // a contract field). Fallback contract is the empty contract — the
+        // four-spec surface is omitted entirely (no props, no actions, no
+        // streams, no context).
+        const fallbackContract = {};
+        return {
+            decision: {
+                action,
+                reasoning: `Exact blueprint match (high confidence). ${action === 'update' ? 'Updating existing view.' : 'Creating new view.'}`,
+                blueprintId: exactOpt.blueprintId,
+                contract: exactOpt.contract ?? fallbackContract,
+            },
+            alternatives: [],
+            storedContractHash: exactOpt.contractHash,
+            storedPoolSource: exactOpt.poolSource,
+            embeddingLatencyMs: ragResult.embeddingLatencyMs,
+            searchLatencyMs: ragResult.searchLatencyMs,
+            decisionLatencyMs: 0,
+        };
+    }
+    // Step 4: Build decision input + call the LLM.
+    const decisionInput = {
+        agentData: agent.data,
+        agentPrompt: agent.prompt,
+        agentContext: agent.context,
+        agentTools: agent.agentTools,
+        ...(agent.gadgets
+            ? { gadgets: agent.gadgets }
+            : {}),
+        sessionState,
+        blueprintCandidates: ragResult.options.map((opt) => ({
+            blueprintId: opt.blueprintId ?? opt.id,
+            description: opt.description,
+            contract: opt.contract,
+            similarity: parseFloat(opt.description.match(/similarity: (\d+)%/)?.[1] ?? '0') / 100,
+            verdict: (opt.description.includes('exact') ? 'exact' : 'partial'),
+        })),
+    };
+    deps.onProgress?.('deciding', 'Choosing the best UI approach...');
+    const decisionStart = Date.now();
+    const { decision, alternatives } = await makeDecision(decisionInput, deps.llm);
+    const decisionLatencyMs = Date.now() - decisionStart;
+    const totalMs = Date.now() - negotiateStart;
+    const pickedBlueprint = decision.blueprintId
+        ? ragResult.options.find((opt) => (opt.blueprintId ?? opt.id) === decision.blueprintId)
+        : undefined;
+    // eslint-disable-next-line no-console
+    console.log(`[negotiate] LLM PATH: action=${decision.action} blueprint=${decision.blueprintId?.slice(-8) ?? 'none'} hash=${pickedBlueprint?.contractHash?.slice(0, 12) ?? 'none'} | LLM decision: ${decisionLatencyMs}ms | total: ${totalMs}ms`);
+    return {
+        decision,
+        alternatives,
+        storedContractHash: pickedBlueprint?.contractHash,
+        storedPoolSource: pickedBlueprint?.poolSource,
+        embeddingLatencyMs: ragResult.embeddingLatencyMs,
+        searchLatencyMs: ragResult.searchLatencyMs,
+        decisionLatencyMs,
+    };
+}

package/dist/normalize-schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Deterministic repair of the invalid JSON Schema `type` spellings an
+ * LLM occasionally emits in a synthesized contract. Runs inside
+ * `buildContract` (before the `dataContractSchema` validation gate) so
+ * the dominant synth-decline class — a `type` value outside the seven
+ * JSON Schema primitives — is structurally eliminated rather than left
+ * to a repair retry.
+ *
+ * Pure, recursive, total: a schema that is already valid passes
+ * through unchanged — every mapping fires only on a value NOT in the
+ * valid set. Recursion descends only into sub-schema positions, so
+ * data-value positions (`default`, `const`, `enum`, `examples`) are
+ * left verbatim — a `default` of `{type: "list"}` is user data, not a
+ * schema, and must not be rewritten.
+ */
+/**
+ * Recursively normalize a JSON Schema, repairing invalid `type`
+ * values. Non-object input (booleans, primitives) passes through —
+ * `additionalProperties: false` and the like are valid as-is.
+ */
+export declare function normalizeSchema(schema: unknown): unknown;
+//# sourceMappingURL=normalize-schema.d.ts.map

package/dist/normalize-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-schema.d.ts","sourceRoot":"","sources":["../src/normalize-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAkJH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CA2BxD"}

package/dist/normalize-schema.js

@@ -0,0 +1,191 @@
+/**
+ * Deterministic repair of the invalid JSON Schema `type` spellings an
+ * LLM occasionally emits in a synthesized contract. Runs inside
+ * `buildContract` (before the `dataContractSchema` validation gate) so
+ * the dominant synth-decline class — a `type` value outside the seven
+ * JSON Schema primitives — is structurally eliminated rather than left
+ * to a repair retry.
+ *
+ * Pure, recursive, total: a schema that is already valid passes
+ * through unchanged — every mapping fires only on a value NOT in the
+ * valid set. Recursion descends only into sub-schema positions, so
+ * data-value positions (`default`, `const`, `enum`, `examples`) are
+ * left verbatim — a `default` of `{type: "list"}` is user data, not a
+ * schema, and must not be rewritten.
+ */
+/** The seven JSON Schema primitive type names. */
+const VALID_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'array',
+    'object',
+    'null',
+]);
+/** Unambiguous non-canonical type spellings → canonical primitive. */
+const TYPE_ALIASES = {
+    list: 'array',
+    tuple: 'array',
+    sequence: 'array',
+    dict: 'object',
+    map: 'object',
+    record: 'object',
+    hash: 'object',
+    str: 'string',
+    text: 'string',
+    char: 'string',
+    int: 'integer',
+    long: 'integer',
+    short: 'integer',
+    float: 'number',
+    double: 'number',
+    decimal: 'number',
+    num: 'number',
+    numeric: 'number',
+    bool: 'boolean',
+};
+/** Type words that mean "no constraint" — the `type` key is dropped. */
+const DROP_TYPES = new Set(['any', 'unknown', 'mixed', 'void']);
+/** Object keys whose value is itself a single schema. */
+const SCHEMA_VALUED_KEYS = new Set([
+    'items',
+    'additionalProperties',
+    'not',
+    'contains',
+    'propertyNames',
+]);
+/** Object keys whose value is a map of name → schema. */
+const SCHEMA_MAP_KEYS = new Set([
+    'properties',
+    'patternProperties',
+    '$defs',
+    'definitions',
+]);
+/** Object keys whose value is an array of schemas. */
+const SCHEMA_ARRAY_KEYS = new Set([
+    'allOf',
+    'anyOf',
+    'oneOf',
+    'prefixItems',
+]);
+/**
+ * Infer the base type of an `enum`-constrained field from its value
+ * list. Mixed / empty / non-array → `string` (the safe default, and
+ * the overwhelmingly common enum shape).
+ */
+function inferEnumBaseType(enumSibling) {
+    if (!Array.isArray(enumSibling) || enumSibling.length === 0) {
+        return 'string';
+    }
+    if (enumSibling.every((v) => typeof v === 'string'))
+        return 'string';
+    if (enumSibling.every((v) => typeof v === 'number'))
+        return 'number';
+    if (enumSibling.every((v) => typeof v === 'boolean'))
+        return 'boolean';
+    return 'string';
+}
+/**
+ * Map one `type` value to a canonical primitive, or `undefined` when
+ * the `type` key should be dropped entirely (an absent `type` is valid
+ * JSON Schema — it simply imposes no constraint).
+ *
+ * `enumSibling` is the schema's `enum` array, used to pick the base
+ * type when the LLM wrote the (invalid) `type: "enum"`.
+ */
+function normalizeTypeValue(value, enumSibling) {
+    if (typeof value === 'string') {
+        const lower = value.toLowerCase();
+        if (VALID_TYPES.has(lower))
+            return lower;
+        if (lower === 'enum')
+            return inferEnumBaseType(enumSibling);
+        if (DROP_TYPES.has(lower))
+            return undefined;
+        const alias = TYPE_ALIASES[lower];
+        if (alias !== undefined)
+            return alias;
+        // Unrecognized garbage — drop the constraint rather than guess.
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        // Union type (`["string", "null"]`). The protocol contract schema
+        // accepts only a single string; recover the first valid non-null
+        // member, dropping the nullable arm.
+        for (const member of value) {
+            if (typeof member === 'string') {
+                const norm = normalizeTypeValue(member, enumSibling);
+                if (norm !== undefined && norm !== 'null')
+                    return norm;
+            }
+        }
+        return 'string';
+    }
+    // `type` was a number / object / boolean — meaningless; drop it.
+    return undefined;
+}
+/** Normalize a map of name → schema (e.g. `properties`). */
+function normalizeSchemaMap(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return value;
+    }
+    const out = {};
+    for (const [name, sub] of Object.entries(value)) {
+        out[name] = coerceToSchema(sub);
+    }
+    return out;
+}
+/**
+ * Coerce a value found in a schema-expecting position into a schema
+ * object. An LLM sometimes writes the shorthand `items: "number"`
+ * where JSON Schema requires `items: {type: "number"}` — expand it
+ * (`"number"` → `{type: "number"}`, an unrecognized string → `{}`,
+ * the unconstrained schema). A boolean (`additionalProperties: false`)
+ * is a valid schema-position value and passes through; anything else
+ * recurses through {@link normalizeSchema}.
+ */
+function coerceToSchema(value) {
+    if (typeof value === 'string') {
+        const t = normalizeTypeValue(value, undefined);
+        return t === undefined ? {} : { type: t };
+    }
+    return normalizeSchema(value);
+}
+/**
+ * Recursively normalize a JSON Schema, repairing invalid `type`
+ * values. Non-object input (booleans, primitives) passes through —
+ * `additionalProperties: false` and the like are valid as-is.
+ */
+export function normalizeSchema(schema) {
+    if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+        return schema;
+    }
+    const obj = schema;
+    const out = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (key === 'type') {
+            const fixed = normalizeTypeValue(value, obj['enum']);
+            if (fixed !== undefined)
+                out[key] = fixed;
+            continue;
+        }
+        if (SCHEMA_VALUED_KEYS.has(key)) {
+            out[key] = coerceToSchema(value);
+        }
+        else if (SCHEMA_MAP_KEYS.has(key)) {
+            out[key] = normalizeSchemaMap(value);
+        }
+        else if (SCHEMA_ARRAY_KEYS.has(key)) {
+            out[key] = Array.isArray(value)
+                ? value.map((s) => coerceToSchema(s))
+                : value;
+        }
+        else {
+            // Data-value position (`default`, `const`, `enum`, `examples`,
+            // `required`, `description`, …) — leave verbatim.
+            out[key] = value;
+        }
+    }
+    return out;
+}

package/dist/pure.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure helpers — zero I/O, zero AWS dependencies.
+ *
+ *   - `inferInteractionMode(text)` — keyword-priority mapper from free
+ *     text (category / pattern / prompt) to a categorical interaction
+ *     label. Used for telemetry / RAG hinting only; NOT part of the
+ *     `DataContract` wire surface. Deterministic; default `'display'`.
+ *   - `inferJsonSchemaType(tsType)` — TypeScript-style type-string
+ *     mapper to the JSON Schema type union. Deterministic.
+ */
+/**
+ * Categorical interaction-mode label used by `inferInteractionMode` for
+ * telemetry / RAG hinting. NOT a `DataContract` field — the four typed
+ * specs (propsSpec / actionSpec / contextSpec / streamSpec) describe
+ * the wire surface exhaustively, so interaction mode is a derived
+ * heuristic, never part of the contract.
+ */
+export type InteractionMode = 'display' | 'collect' | 'converse' | 'broadcast' | 'flow';
+/**
+ * Infer interaction mode from any text (category, pattern, or prompt).
+ * Consolidated keyword matcher — all call sites use the same function.
+ *
+ * Used by rag-search and external benchmark runners for routing /
+ * telemetry. Deterministic; no I/O. Matches the first rule in priority
+ * order, defaulting to 'display'.
+ */
+export declare function inferInteractionMode(text: string): InteractionMode;
+/** Map TypeScript-style type strings to JSON Schema types. */
+export declare function inferJsonSchemaType(tsType: string): 'string' | 'number' | 'boolean' | 'array' | 'object';
+//# sourceMappingURL=pure.d.ts.map

package/dist/pure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure.d.ts","sourceRoot":"","sources":["../src/pure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;AAExF;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAOlE;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAOxG"}

package/dist/pure.js

@@ -0,0 +1,43 @@
+/**
+ * Pure helpers — zero I/O, zero AWS dependencies.
+ *
+ *   - `inferInteractionMode(text)` — keyword-priority mapper from free
+ *     text (category / pattern / prompt) to a categorical interaction
+ *     label. Used for telemetry / RAG hinting only; NOT part of the
+ *     `DataContract` wire surface. Deterministic; default `'display'`.
+ *   - `inferJsonSchemaType(tsType)` — TypeScript-style type-string
+ *     mapper to the JSON Schema type union. Deterministic.
+ */
+/**
+ * Infer interaction mode from any text (category, pattern, or prompt).
+ * Consolidated keyword matcher — all call sites use the same function.
+ *
+ * Used by rag-search and external benchmark runners for routing /
+ * telemetry. Deterministic; no I/O. Matches the first rule in priority
+ * order, defaulting to 'display'.
+ */
+export function inferInteractionMode(text) {
+    const t = text.toLowerCase();
+    if (t.includes('form') || t.includes('survey') || t.includes('input') || t.includes('collect') || t.includes('sign up') || t.includes('contact'))
+        return 'collect';
+    if (t.includes('chat') || t.includes('conversation') || t.includes('messaging') || t.includes('talk'))
+        return 'converse';
+    if (t.includes('dashboard') || t.includes('monitor') || t.includes('live') || t.includes('feed') || t.includes('real-time'))
+        return 'broadcast';
+    if (t.includes('wizard') || t.includes('onboarding') || t.includes('checkout') || t.includes('stepper') || t.includes('multi-step') || t.includes('flow') || t.includes('step'))
+        return 'flow';
+    return 'display';
+}
+/** Map TypeScript-style type strings to JSON Schema types. */
+export function inferJsonSchemaType(tsType) {
+    const t = tsType.toLowerCase();
+    if (t.includes('string'))
+        return 'string';
+    if (t.includes('number') || t.includes('int') || t.includes('float'))
+        return 'number';
+    if (t.includes('boolean') || t.includes('bool'))
+        return 'boolean';
+    if (t.includes('array') || t.includes('[]'))
+        return 'array';
+    return 'object';
+}

package/dist/rag-search.d.ts

@@ -0,0 +1,73 @@
+/**
+ * RAG Search — embedding-similarity blueprint retrieval over the
+ * public `@ggui-ai/mcp-server-core` storage seam.
+ *
+ * Given agent `prompt` + a tenant `scope` (typically appId, or the
+ * literal `"shared"` for the global catalog), this helper:
+ *
+ *   1. Embeds the prompt via {@link EmbeddingProvider.embed}.
+ *   2. Queries the {@link VectorStore} for the top-K nearest neighbors
+ *      (server-side cosine, scope-partitioned — no cross-tenant leak).
+ *   3. Filters by minimum score, biases private (per-app registered
+ *      UIs) over shared (generated pool) at the same score band, and
+ *      projects each hit into a {@link NegotiatorOption}.
+ *
+ * Two pipeline paths emerge from the confidence band:
+ *   - **High confidence** (`score >= HIGH_CONFIDENCE_THRESHOLD`): the
+ *     hit is marked `exact`. Upstream callers (V3 `negotiate()`) can
+ *     short-circuit the decision LLM entirely.
+ *   - **Medium confidence** (`score >= RETRIEVAL_MIN_SCORE` and below
+ *     the exact threshold): marked `partial`. Upstream passes these to
+ *     the decision LLM as candidates.
+ *
+ * ### Public-seam contract
+ *
+ * This function reads only the public `VectorStore` surface (scalar
+ * metadata). Consumers that still hold the rich `EmbeddingStorage`
+ * shape bridge via
+ * `@ggui-cloud/aws-adapters.embeddingStorageToVectorStore`, which
+ * encodes array-valued fields (`props`, `callbacks`, `sourceTools`)
+ * as JSON strings inside `metadata`. Any `VectorStore` implementation
+ * that stores fresh writes through `writeRagVector` (see
+ * `mcp-servers/ggui-protocol/src/adapters/vector-store.ts`) uses the
+ * same encoding — so existing caches, fresh writes, and community
+ * `VectorStore` backends all collide on the same retrieval key.
+ *
+ * ### Scope
+ *
+ * No AWS bindings, no LLM dependency. Pure composition over the two
+ * public seams. The one-LLM-call `makeDecision()` step is separate.
+ */
+import type { EmbeddingProvider, VectorStore } from '@ggui-ai/mcp-server-core';
+import type { NegotiatorOption } from './types.js';
+/** RAG search result with per-stage timing. */
+export interface RagSearchResult {
+    options: NegotiatorOption[];
+    embeddingLatencyMs: number;
+    searchLatencyMs: number;
+}
+/** Dependencies — both public seams from `@ggui-ai/mcp-server-core`. */
+export interface RagSearchDeps {
+    embedding: EmbeddingProvider;
+    vectors: VectorStore;
+}
+export interface RagSearchInput {
+    /** Natural-language query text. Embedded as-is. */
+    prompt: string;
+    /**
+     * Scope / tenant partition. Typically `appId` for per-app indexes
+     * or the literal `"shared"` for the global catalog. Passed straight
+     * through to `VectorStore.query`; the scope is the tenant boundary,
+     * so a query never crosses into another tenant's index.
+     */
+    scope: string;
+    /** Override the k-NN cut-off (default 10). */
+    maxCandidates?: number;
+}
+/**
+ * Search the vector index for blueprints matching `prompt` within
+ * `scope`. See the module docstring for the confidence-band pipeline
+ * and encoding contract.
+ */
+export declare function ragSearch(deps: RagSearchDeps, input: RagSearchInput): Promise<RagSearchResult>;
+//# sourceMappingURL=rag-search.d.ts.map

package/dist/rag-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rag-search.d.ts","sourceRoot":"","sources":["../src/rag-search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EACV,iBAAiB,EAEjB,WAAW,EACZ,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,+CAA+C;AAC/C,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,OAAO,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAWD;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC,eAAe,CAAC,CAwC1B"}