@oscharko-dev/keiko-model-gateway 0.2.0

package/dist/openai-embedding-adapter.d.ts

@@ -0,0 +1,46 @@
+import type { OutboundHttpEgressConfig } from "./types.js";
+export interface OpenAIEmbeddingRequest {
+    readonly endpoint: string;
+    readonly apiKey: string;
+    readonly apiKeyHeaderName?: string;
+    readonly modelId: string;
+    readonly input: string;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly fetchImpl?: typeof fetch;
+    readonly egress?: OutboundHttpEgressConfig | undefined;
+}
+export interface OpenAIEmbeddingSuccess {
+    readonly vector: Float32Array;
+    readonly modelId: string;
+    readonly modelRevision?: string;
+}
+export interface OpenAIEmbeddingBatchRequest {
+    readonly endpoint: string;
+    readonly apiKey: string;
+    readonly apiKeyHeaderName?: string;
+    readonly modelId: string;
+    readonly inputs: readonly string[];
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly fetchImpl?: typeof fetch;
+    readonly egress?: OutboundHttpEgressConfig | undefined;
+}
+export type OpenAIEmbeddingBatchOutcome = {
+    readonly ok: true;
+    readonly value: readonly OpenAIEmbeddingSuccess[];
+} | {
+    readonly ok: false;
+    readonly kind: OpenAIEmbeddingErrorKind;
+};
+export type OpenAIEmbeddingOutcome = {
+    readonly ok: true;
+    readonly value: OpenAIEmbeddingSuccess;
+} | {
+    readonly ok: false;
+    readonly kind: OpenAIEmbeddingErrorKind;
+};
+export type OpenAIEmbeddingErrorKind = "wrong-header" | "rate-limited" | "unsupported-model" | "timeout" | "cancelled" | "transport" | "proxy-unreachable" | "proxy-auth-required" | "proxy-egress-failed" | "proxy-blocked-by-policy" | "tls-ca-failure" | "invalid-response";
+export declare function requestOpenAIEmbedding(request: OpenAIEmbeddingRequest): Promise<OpenAIEmbeddingOutcome>;
+export declare function requestOpenAIEmbeddingBatch(request: OpenAIEmbeddingBatchRequest): Promise<OpenAIEmbeddingBatchOutcome>;
+//# sourceMappingURL=openai-embedding-adapter.d.ts.map

package/dist/openai-embedding-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-embedding-adapter.d.ts","sourceRoot":"","sources":["../src/openai-embedding-adapter.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;CACxD;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAQD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;CACxD;AAED,MAAM,MAAM,2BAA2B,GAEnC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAE,GACxE;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAA;CAAE,CAAC;AAEpE,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAA;CAAE,CAAC;AAEpE,MAAM,MAAM,wBAAwB,GAChC,cAAc,GACd,cAAc,GACd,mBAAmB,GACnB,SAAS,GACT,WAAW,GACX,WAAW,GACX,mBAAmB,GACnB,qBAAqB,GACrB,qBAAqB,GACrB,yBAAyB,GACzB,gBAAgB,GAChB,kBAAkB,CAAC;AAoLvB,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,sBAAsB,CAAC,CAYjC;AAuHD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,2BAA2B,CAAC,CAetC"}

package/dist/openai-embedding-adapter.js

@@ -0,0 +1,271 @@
+// OpenAI-compatible embeddings adapter. Builds on globalThis.fetch only (no SDK
+// dependency), mirroring openai-adapter.ts. Surfaces only structural status
+// information; the raw provider body never escapes this module.
+import { apiKeyHeaderValue } from "./config.js";
+import { gatewayFetch, OutboundHttpEgressError, readJsonCapped, } from "./http.js";
+const OUTBOUND_EMBEDDING_KINDS = {
+    PROXY_UNREACHABLE: "proxy-unreachable",
+    PROXY_AUTH_REQUIRED: "proxy-auth-required",
+    PROXY_EGRESS_FAILED: "proxy-egress-failed",
+    PROXY_BLOCKED_BY_POLICY: "proxy-blocked-by-policy",
+    TLS_CA_FAILURE: "tls-ca-failure",
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumberArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "number");
+}
+function extractFirstEmbedding(payload) {
+    const data = payload.data;
+    if (!Array.isArray(data) || data.length === 0) {
+        return null;
+    }
+    const first = data[0];
+    if (!isRecord(first)) {
+        return null;
+    }
+    const embedding = first.embedding;
+    if (!isNumberArray(embedding) || embedding.length === 0) {
+        return null;
+    }
+    return embedding;
+}
+function parseEmbeddingShape(payload) {
+    if (!isRecord(payload)) {
+        return null;
+    }
+    const embedding = extractFirstEmbedding(payload);
+    if (embedding === null) {
+        return null;
+    }
+    const model = typeof payload.model === "string" ? payload.model : undefined;
+    const modelRevision = typeof payload.model_revision === "string" ? payload.model_revision : undefined;
+    return {
+        embedding,
+        ...(model !== undefined ? { model } : {}),
+        ...(modelRevision !== undefined ? { modelRevision } : {}),
+    };
+}
+function joinUrl(endpoint) {
+    const trimmed = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+    return `${trimmed}/embeddings`;
+}
+function headerName(name) {
+    if (name === undefined || name.trim().length === 0) {
+        return "authorization";
+    }
+    return name.toLowerCase();
+}
+function classifyStatus(status) {
+    if (status === 401 || status === 403)
+        return "wrong-header";
+    if (status === 429)
+        return "rate-limited";
+    if (status === 404)
+        return "unsupported-model";
+    if (status >= 400)
+        return "transport";
+    return null;
+}
+// Distinguishes our own internal-timeout abort from a caller-driven cancellation. If our
+// internal `timeoutSignal` is aborted, it's a timeout. Otherwise, if the caller's signal is
+// aborted (passed via `callerSignal`), it's a user cancellation. Anything else is a
+// transport error. Without this distinction, callers cannot tell whether their user
+// pressed Cancel or the server hung. #192 Copilot finding.
+function classifyDispatchError(error, timeoutSignal, callerSignal) {
+    if (callerSignal?.aborted === true)
+        return "cancelled";
+    if (error instanceof OutboundHttpEgressError)
+        return OUTBOUND_EMBEDDING_KINDS[error.code];
+    if (timeoutSignal.aborted)
+        return "timeout";
+    if (error instanceof DOMException && error.name === "TimeoutError")
+        return "timeout";
+    // A bare AbortError without either of our signals being aborted is a transport error
+    // (e.g. the fetch impl tore down its own internal controller). Mapping it to `cancelled`
+    // would misattribute the failure to the caller — #192 Copilot follow-up finding.
+    return "transport";
+}
+function buildRequest(request) {
+    const name = headerName(request.apiKeyHeaderName);
+    // Reuse the shared Bearer-prefixing helper from config.ts so this transport handles the
+    // same `bearer ` / `x-litellm-key` / `api-key` cases the chat adapter handles, including
+    // already-prefixed inputs. #192 Copilot finding.
+    const headers = {
+        "content-type": "application/json",
+        [name]: apiKeyHeaderValue(name, request.apiKey),
+    };
+    const body = JSON.stringify({ model: request.modelId, input: request.input });
+    const timeoutSignal = AbortSignal.timeout(request.timeoutMs ?? 30_000);
+    const signal = request.signal !== undefined ? AbortSignal.any([timeoutSignal, request.signal]) : timeoutSignal;
+    return {
+        url: joinUrl(request.endpoint),
+        headers,
+        body,
+        signal,
+        timeoutSignal,
+        callerSignal: request.signal,
+    };
+}
+async function discardBody(response) {
+    try {
+        await readJsonCapped(response);
+    }
+    catch {
+        // ignore — body discarded intentionally
+    }
+}
+async function dispatch(built, fetchImpl, egress) {
+    try {
+        return await gatewayFetch(built.url, {
+            method: "POST",
+            headers: built.headers,
+            body: built.body,
+            signal: built.signal,
+            ...(fetchImpl !== undefined ? { fetchImpl } : {}),
+            ...(egress !== undefined ? { egress } : {}),
+        });
+    }
+    catch (error) {
+        return classifyDispatchError(error, built.timeoutSignal, built.callerSignal);
+    }
+}
+async function decodeSuccess(response, request) {
+    let payload;
+    try {
+        payload = await readJsonCapped(response);
+    }
+    catch {
+        return { ok: false, kind: "invalid-response" };
+    }
+    const shape = parseEmbeddingShape(payload);
+    if (shape === null) {
+        return { ok: false, kind: "invalid-response" };
+    }
+    const vector = Float32Array.from(shape.embedding);
+    const modelId = shape.model ?? request.modelId;
+    const value = shape.modelRevision !== undefined
+        ? { vector, modelId, modelRevision: shape.modelRevision }
+        : { vector, modelId };
+    return { ok: true, value };
+}
+export async function requestOpenAIEmbedding(request) {
+    const built = buildRequest(request);
+    const dispatched = await dispatch(built, request.fetchImpl, request.egress);
+    if (typeof dispatched === "string") {
+        return { ok: false, kind: dispatched };
+    }
+    if (!dispatched.ok) {
+        const kind = classifyStatus(dispatched.status) ?? "transport";
+        await discardBody(dispatched);
+        return { ok: false, kind };
+    }
+    return decodeSuccess(dispatched, request);
+}
+// ─── Array-batch transport (#189 GRD-004) ────────────────────────────────────
+function buildBatchRequest(request) {
+    const name = headerName(request.apiKeyHeaderName);
+    const headers = {
+        "content-type": "application/json",
+        [name]: apiKeyHeaderValue(name, request.apiKey),
+    };
+    // OpenAI-compatible body: `input` is the array. Identical envelope to the scalar path
+    // except the array value, so the same gateway/TLS/egress handling applies.
+    const body = JSON.stringify({ model: request.modelId, input: request.inputs });
+    const timeoutSignal = AbortSignal.timeout(request.timeoutMs ?? 30_000);
+    const signal = request.signal !== undefined ? AbortSignal.any([timeoutSignal, request.signal]) : timeoutSignal;
+    return {
+        url: joinUrl(request.endpoint),
+        headers,
+        body,
+        signal,
+        timeoutSignal,
+        callerSignal: request.signal,
+    };
+}
+// Resolve the slot index for one `data[]` entry, or -1 if its index is missing, non-integer,
+// out of range, or already filled (duplicate).
+function batchSlotIndex(item, count, slots) {
+    const index = typeof item.index === "number" ? item.index : -1;
+    if (!Number.isInteger(index) || index < 0 || index >= count)
+        return -1;
+    return slots[index] === undefined ? index : -1;
+}
+function buildBatchSuccess(item, embedding, ctx) {
+    const modelId = (typeof item.model === "string" ? item.model : undefined) ?? ctx.topModel ?? ctx.requestModelId;
+    return {
+        vector: Float32Array.from(embedding),
+        modelId,
+        ...(ctx.topRevision !== undefined ? { modelRevision: ctx.topRevision } : {}),
+    };
+}
+// Validate one `data[]` entry and place it at its declared `index`. Returns false on any
+// malformed/duplicate/out-of-range item so the caller can fail the whole batch.
+function placeBatchItem(item, ctx, slots) {
+    if (!isRecord(item))
+        return false;
+    const index = batchSlotIndex(item, ctx.count, slots);
+    if (index < 0)
+        return false;
+    const embedding = item.embedding;
+    if (!isNumberArray(embedding) || embedding.length === 0)
+        return false;
+    slots[index] = buildBatchSuccess(item, embedding, ctx);
+    return true;
+}
+function buildBatchContext(payload, request) {
+    return {
+        count: request.inputs.length,
+        topModel: typeof payload.model === "string" ? payload.model : undefined,
+        topRevision: typeof payload.model_revision === "string" ? payload.model_revision : undefined,
+        requestModelId: request.modelId,
+    };
+}
+async function decodeBatchSuccess(response, request) {
+    let payload;
+    try {
+        payload = await readJsonCapped(response);
+    }
+    catch {
+        return { ok: false, kind: "invalid-response" };
+    }
+    if (!isRecord(payload) || !Array.isArray(payload.data)) {
+        return { ok: false, kind: "invalid-response" };
+    }
+    const ctx = buildBatchContext(payload, request);
+    if (payload.data.length !== ctx.count) {
+        return { ok: false, kind: "invalid-response" };
+    }
+    // Place each item at its declared `index` so the result is strictly aligned to `inputs`
+    // regardless of provider ordering. Any missing/duplicate/out-of-range index → invalid.
+    const slots = new Array(ctx.count);
+    for (const item of payload.data) {
+        if (!placeBatchItem(item, ctx, slots)) {
+            return { ok: false, kind: "invalid-response" };
+        }
+    }
+    const value = [];
+    for (const slot of slots) {
+        if (slot === undefined)
+            return { ok: false, kind: "invalid-response" };
+        value.push(slot);
+    }
+    return { ok: true, value };
+}
+export async function requestOpenAIEmbeddingBatch(request) {
+    if (request.inputs.length === 0) {
+        return { ok: true, value: [] };
+    }
+    const built = buildBatchRequest(request);
+    const dispatched = await dispatch(built, request.fetchImpl, request.egress);
+    if (typeof dispatched === "string") {
+        return { ok: false, kind: dispatched };
+    }
+    if (!dispatched.ok) {
+        const kind = classifyStatus(dispatched.status) ?? "transport";
+        await discardBody(dispatched);
+        return { ok: false, kind };
+    }
+    return decodeBatchSuccess(dispatched, request);
+}

package/dist/promptEnhancer/__tests__/_support.d.ts

@@ -0,0 +1,15 @@
+import { type ClarificationOrAssumption, type EnhancedPromptId, type GroundingNeed, type OutputSchemaDescriptor, type PromptCriticality, type PromptDomain, type PromptEnhancementProfileId, type PromptRiskClass, type PromptTaskAnalysis, type PromptTaskClass } from "@oscharko-dev/keiko-contracts";
+export interface AnalysisOverrides {
+    readonly taskClass?: PromptTaskClass;
+    readonly domain?: PromptDomain;
+    readonly criticality?: PromptCriticality;
+    readonly groundingNeed?: GroundingNeed;
+    readonly outputSchema?: OutputSchemaDescriptor;
+    readonly missingContext?: readonly ClarificationOrAssumption[];
+    readonly riskFlags?: readonly PromptRiskClass[];
+    readonly recommendedProfile?: PromptEnhancementProfileId;
+    readonly requestId?: string;
+}
+export declare function makeAnalysis(overrides?: AnalysisOverrides): PromptTaskAnalysis;
+export declare function testPromptId(value?: string): EnhancedPromptId;
+//# sourceMappingURL=_support.d.ts.map

package/dist/promptEnhancer/__tests__/_support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_support.d.ts","sourceRoot":"","sources":["../../../src/promptEnhancer/__tests__/_support.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,yBAAyB,EAC9B,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACrB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IACzC,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,sBAAsB,CAAC;IAC/C,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IAChD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,0BAA0B,CAAC;IACzD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAiBD,wBAAgB,YAAY,CAAC,SAAS,GAAE,iBAAsB,GAAG,kBAAkB,CAOlF;AAED,wBAAgB,YAAY,CAAC,KAAK,SAAgB,GAAG,gBAAgB,CAEpE"}

package/dist/promptEnhancer/__tests__/_support.js

@@ -0,0 +1,28 @@
+// Shared test helpers for the Prompt Enhancer module tests. Excluded from coverage by the vitest
+// config (`**/_support.ts`); not a test file.
+import { asEnhancedPromptId, asPromptEnhancementRequestId, PROMPT_ENHANCER_SCHEMA_VERSION, } from "@oscharko-dev/keiko-contracts";
+const BASE_ANALYSIS = {
+    schemaVersion: PROMPT_ENHANCER_SCHEMA_VERSION,
+    taskClass: "factual-qa",
+    taskClassConfidence: "moderate",
+    domain: "general",
+    criticality: "standard",
+    groundingNeed: { kind: "none", volatile: false, signals: [] },
+    outputSchema: { format: "unspecified", structured: false, hints: [] },
+    missingContext: [],
+    riskFlags: [],
+    recommendedProfile: "precise",
+    normalizedInputLength: 16,
+    signals: [],
+};
+export function makeAnalysis(overrides = {}) {
+    const { requestId, ...rest } = overrides;
+    return {
+        ...BASE_ANALYSIS,
+        ...rest,
+        requestId: asPromptEnhancementRequestId(requestId ?? "test-request"),
+    };
+}
+export function testPromptId(value = "test-prompt") {
+    return asEnhancedPromptId(value);
+}

package/dist/promptEnhancer/__tests__/fixtures.d.ts

@@ -0,0 +1,8 @@
+import { type PromptEnhancementProfileId, type PromptEnhancementRequest } from "@oscharko-dev/keiko-contracts";
+export interface ProfileFixture {
+    readonly name: string;
+    readonly expectedProfile: PromptEnhancementProfileId;
+    readonly request: PromptEnhancementRequest;
+}
+export declare const PROFILE_FIXTURES: readonly ProfileFixture[];
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/promptEnhancer/__tests__/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../../src/promptEnhancer/__tests__/fixtures.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,0BAA0B,CAAC;IACrD,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;CAC5C;AAqBD,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAsDrD,CAAC"}

package/dist/promptEnhancer/__tests__/fixtures.js

@@ -0,0 +1,58 @@
+// Profile-specific fixtures for the Prompt Enhancer planner/generator (Issue #1310 deliverable 3).
+//
+// One representative request per generation profile (fast, precise, research, creative, technical,
+// safety-critical, agentic). Each request is a natural prompt whose deterministic analyzer
+// classification selects the named profile, so the fixtures exercise the real analyze → plan → generate
+// path rather than forcing a profile. `expectedProfile` is asserted by `fixtures.test.ts`.
+//
+// This file lives under `__tests__/` so it is excluded from coverage instrumentation; it is test data,
+// not production code.
+import { asPromptEnhancementRequestId, PROMPT_ENHANCER_SCHEMA_VERSION, } from "@oscharko-dev/keiko-contracts";
+function makeRequest(id, text, options = {}) {
+    return {
+        schemaVersion: PROMPT_ENHANCER_SCHEMA_VERSION,
+        requestId: asPromptEnhancementRequestId(id),
+        input: {
+            text,
+            hasConnectedContext: options.hasConnectedContext,
+        },
+        missingInformationStrategy: options.missingInformationStrategy ?? "clarify",
+    };
+}
+export const PROFILE_FIXTURES = [
+    {
+        name: "fast: light editing",
+        expectedProfile: "fast",
+        request: makeRequest("fixture-fast", "Proofread this paragraph and fix any grammar mistakes."),
+    },
+    {
+        name: "precise: factual question",
+        expectedProfile: "precise",
+        request: makeRequest("fixture-precise", "What is the capital of Australia and roughly when did it become the capital?"),
+    },
+    {
+        name: "research: grounded overview",
+        expectedProfile: "research",
+        request: makeRequest("fixture-research", "Provide a comprehensive overview of advances in solid-state battery technology, with citations."),
+    },
+    {
+        name: "creative: short story",
+        expectedProfile: "creative",
+        request: makeRequest("fixture-creative", "Write a short story about a lighthouse keeper who befriends a whale."),
+    },
+    {
+        name: "technical: code generation",
+        expectedProfile: "technical",
+        request: makeRequest("fixture-technical", "Write a function in TypeScript that merges two sorted arrays into one sorted array. Return JSON describing the result."),
+    },
+    {
+        name: "safety-critical: medical advice",
+        expectedProfile: "safety-critical",
+        request: makeRequest("fixture-safety-critical", "I have a headache and a fever. What medication should I take and what dose is safe?"),
+    },
+    {
+        name: "agentic: tool automation",
+        expectedProfile: "agentic",
+        request: makeRequest("fixture-agentic", "As an agent, automate my onboarding workflow: call the API to create accounts and take actions on my behalf."),
+    },
+];

package/dist/promptEnhancer/__tests__/grounding-fixtures.d.ts

@@ -0,0 +1,11 @@
+import { type GroundingStrategy, type PromptEnhancementRequest } from "@oscharko-dev/keiko-contracts";
+export interface GroundingFixture {
+    readonly name: string;
+    readonly category: "factual" | "current" | "rag" | "enterprise" | "code" | "self-contained" | "unsupported-evidence";
+    readonly expectedStrategy: GroundingStrategy;
+    readonly expectsRagHints: boolean;
+    readonly expectedRequired: boolean;
+    readonly request: PromptEnhancementRequest;
+}
+export declare const GROUNDING_FIXTURES: readonly GroundingFixture[];
+//# sourceMappingURL=grounding-fixtures.d.ts.map

package/dist/promptEnhancer/__tests__/grounding-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding-fixtures.d.ts","sourceRoot":"","sources":["../../../src/promptEnhancer/__tests__/grounding-fixtures.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EACb,SAAS,GACT,SAAS,GACT,KAAK,GACL,YAAY,GACZ,MAAM,GACN,gBAAgB,GAChB,sBAAsB,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,iBAAiB,CAAC;IAC7C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;CAC5C;AAeD,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EAsFzD,CAAC"}

package/dist/promptEnhancer/__tests__/grounding-fixtures.js

@@ -0,0 +1,84 @@
+// Grounding-plan fixtures for the Prompt Enhancer (Issue #1311 deliverable 3).
+//
+// Natural prompts whose deterministic analysis (#1309) drives a specific grounding strategy, covering
+// the six plan types named in the Expected Verification (no-grounding, supplied-context-only,
+// local-knowledge, repository-context, hybrid, external-research-required) plus the deliverable
+// categories: factual/current prompts, RAG prompts, enterprise-data prompts, and an
+// unsupported-evidence case. Each fixture exercises the real analyze -> plan -> generate path.
+//
+// This file lives under `__tests__/` so it is excluded from coverage instrumentation; it is test data.
+import { asPromptEnhancementRequestId, PROMPT_ENHANCER_SCHEMA_VERSION, } from "@oscharko-dev/keiko-contracts";
+function makeRequest(id, text, hasConnectedContext) {
+    return {
+        schemaVersion: PROMPT_ENHANCER_SCHEMA_VERSION,
+        requestId: asPromptEnhancementRequestId(id),
+        input: { text, hasConnectedContext },
+        missingInformationStrategy: "clarify",
+    };
+}
+export const GROUNDING_FIXTURES = [
+    {
+        name: "self-contained: code generation needs no grounding",
+        category: "self-contained",
+        expectedStrategy: "no-grounding",
+        expectsRagHints: false,
+        expectedRequired: false,
+        request: makeRequest("grd-none", "Write a function to reverse a singly linked list."),
+    },
+    {
+        name: "rag: answer strictly from the provided text",
+        category: "rag",
+        expectedStrategy: "supplied-context-only",
+        expectsRagHints: true,
+        expectedRequired: true,
+        request: makeRequest("grd-supplied", "Based on the provided text, answer which mitigations the report recommends."),
+    },
+    {
+        name: "enterprise: look up an answer in the connected document store",
+        category: "enterprise",
+        expectedStrategy: "local-knowledge",
+        expectsRagHints: true,
+        expectedRequired: true,
+        request: makeRequest("grd-local", "Using the document knowledge base, look up our onboarding steps and list them."),
+    },
+    {
+        name: "code: debug a failure against the repository context",
+        category: "code",
+        expectedStrategy: "repository-context",
+        expectsRagHints: false,
+        expectedRequired: true,
+        request: makeRequest("grd-repo", "Debug why this function returns the wrong result when the input array is empty."),
+    },
+    {
+        name: "factual research: comprehensive overview with citations (hybrid)",
+        category: "factual",
+        expectedStrategy: "hybrid",
+        expectsRagHints: true,
+        expectedRequired: true,
+        request: makeRequest("grd-hybrid", "Provide a comprehensive overview of advances in solid-state battery technology, with citations."),
+    },
+    {
+        name: "decision-support: optional hybrid planning with parametric fallback",
+        category: "factual",
+        expectedStrategy: "hybrid",
+        expectsRagHints: false,
+        expectedRequired: false,
+        request: makeRequest("grd-hybrid-optional", "Help me decide whether to expand into the European market, weighing the main trade-offs."),
+    },
+    {
+        name: "current: recency-sensitive question requires external research",
+        category: "current",
+        expectedStrategy: "external-research-required",
+        expectsRagHints: false,
+        expectedRequired: true,
+        request: makeRequest("grd-current", "What are the latest developments in the EU AI Act as of today?"),
+    },
+    {
+        name: "unsupported-evidence: RAG question whose answer may be absent from context",
+        category: "unsupported-evidence",
+        expectedStrategy: "supplied-context-only",
+        expectsRagHints: true,
+        expectedRequired: true,
+        request: makeRequest("grd-unsupported", "Based on the provided text, what was the company's exact revenue in 1850?"),
+    },
+];

package/dist/promptEnhancer/candidates.d.ts

@@ -0,0 +1,32 @@
+import { type EnhancedPrompt, type PromptCandidateRejectionReason, type PromptEnhancementProfileId, type PromptTaskAnalysis, type RawPromptInput } from "@oscharko-dev/keiko-contracts";
+import { type PromptEnhancementPlan } from "./planner.js";
+export interface PromptCandidate {
+    readonly candidateId: string;
+    readonly profile: PromptEnhancementProfileId;
+    readonly plan: PromptEnhancementPlan;
+    readonly prompt: EnhancedPrompt;
+}
+export interface RejectedCandidate {
+    readonly candidateId: string;
+    readonly profile: PromptEnhancementProfileId;
+    readonly reason: Extract<PromptCandidateRejectionReason, "duplicate-candidate" | "safety-floor-not-preserved">;
+}
+export interface PromptCandidateSet {
+    readonly candidates: readonly PromptCandidate[];
+    readonly rejected: readonly RejectedCandidate[];
+}
+export interface GeneratePromptCandidatesArgs {
+    readonly analysis: PromptTaskAnalysis;
+    readonly input: RawPromptInput;
+    readonly candidateCount: number;
+    readonly profilePreference?: PromptEnhancementProfileId | undefined;
+}
+/**
+ * Generate a bounded, ordered set of distinct, safety-preserving Enhanced Prompt candidates. Pure.
+ *
+ * Candidates are produced by planning the analysis under each profile in the slate, deduplicating by
+ * the actual selected profile (so a forced escalation does not produce repeats), rejecting any candidate
+ * that would relax the baseline safety floor, and capping the result at `candidateCount`.
+ */
+export declare function generatePromptCandidates(args: GeneratePromptCandidatesArgs): PromptCandidateSet;
+//# sourceMappingURL=candidates.d.ts.map

package/dist/promptEnhancer/candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/candidates.ts"],"names":[],"mappings":"AAoBA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,8BAA8B,EACnC,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAyB,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAIjF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC;AAID,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAC;IAC7C,QAAQ,CAAC,MAAM,EAAE,OAAO,CACtB,8BAA8B,EAC9B,qBAAqB,GAAG,4BAA4B,CACrD,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IAEjC,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IAEhD,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAE/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;CACrE;AAgDD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,kBAAkB,CA8C/F"}