@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/capabilities/tool-types.d.ts

@@ -115,7 +115,7 @@ export type ToolRequestAttachment = Readonly<{
     name?: string;
     size?: number;
 }>;
-/** Minimal config-filtered tool fact projected to plugin execution only. */
+/** Minimal config-filtered tool fact; consumers project it for their own context. */
 export type ToolAvailabilityEntry = Readonly<{
     toolName: string;
     operationId: string;

package/dist/src/cli/abot.js

@@ -1,7 +1,8 @@
 import { join, resolve } from "node:path";
 import { runAddRuntimeModel } from "../../scripts/add-runtime-model.js";
 import { runInitRuntime } from "../../scripts/init-runtime.js";
-import { createModelGatewayServer, resolveModelGatewayPort, } from "../model-gateway/server.js";
+import { runConfigureLongTermMemory } from "../../scripts/configure-long-term-memory.js";
+import { createModelGatewayServer, resolveProviderAdapters, resolveModelGatewayPort, } from "../model-gateway/server.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
 import { startWebUiServer } from "../web-ui/server.js";
 import { resolveWebUiAddress } from "../web-ui/web-ui-address.js";
@@ -12,11 +13,13 @@ function printHelp() {
         "Usage:",
         "  abot init --provider <provider> --model <model-id> [options]",
         "  abot add-model --profile <profile-id> --provider <provider> --model <model-id> [options]",
+        "  abot memory <status|models|enable|disable> [options]",
         "  abot start",
         "",
         "Commands:",
         "  init       Create the first machine-local runtime configuration.",
         "  add-model  Add a provider/model profile without replacing existing ones.",
+        "  memory     Configure passive long-term memory embeddings.",
         "  start      Start the local model gateway and Web UI.",
     ].join("\n"));
 }
@@ -42,9 +45,10 @@ async function runStart(args) {
     loadDotEnvFile(join(rootDir, ".env"));
     const webAddress = resolveWebUiAddress(process.env);
     const appDir = resolve(import.meta.dirname, "../web-ui/app");
+    const providerAdapters = resolveProviderAdapters({});
     let gateway;
     try {
-        gateway = createModelGatewayServer();
+        gateway = createModelGatewayServer({ providerAdapters });
         const gatewayPort = resolveModelGatewayPort();
         gateway.listen(gatewayPort, "127.0.0.1", () => {
             console.log(`model gateway listening on http://127.0.0.1:${gatewayPort}`);
@@ -60,6 +64,7 @@ async function runStart(args) {
         host: webAddress.listenHost,
         port: webAddress.port,
         setupCommandMode: "package",
+        providerAdapters,
     });
     console.log(`Open ${webAddress.browserUrl}`);
     await new Promise((resolveExit, rejectExit) => {
@@ -94,6 +99,10 @@ export async function runAbotCli(argv = process.argv.slice(2)) {
         await runAddRuntimeModel(args, { commandMode: "package" });
         return;
     }
+    if (command === "memory") {
+        await runConfigureLongTermMemory(args, { commandMode: "package" });
+        return;
+    }
     if (command === "start") {
         await runStart(args);
         return;

package/dist/src/model-gateway/client/embeddings.d.ts

@@ -0,0 +1,3 @@
+import type { ModelGatewayEmbeddingParams, ModelGatewayEmbeddingResult } from "../types.js";
+import type { ModelGatewayClientOptions } from "./contracts.js";
+export declare function embedModelGatewayWithOptions(params: ModelGatewayEmbeddingParams, options?: ModelGatewayClientOptions): Promise<ModelGatewayEmbeddingResult>;

package/dist/src/model-gateway/client/embeddings.js

@@ -0,0 +1,48 @@
+import { traceDebug } from "../../runtime/observability/debug-logger.js";
+import { parseEmbeddingResult } from "../embeddings/validation.js";
+import { resolveClientOptions } from "./options.js";
+export async function embedModelGatewayWithOptions(params, options = {}) {
+    const clientOptions = resolveClientOptions(options);
+    const profileId = params.profileId.trim();
+    if (!profileId || params.texts.length === 0) {
+        throw new Error("model_gateway_embedding_request_invalid");
+    }
+    const requestId = params.debugRequestId?.trim() ?? "";
+    const startedAt = Date.now();
+    traceDebug("model-gateway.client", "embedding.request.start", {
+        requestId,
+        profileId,
+        inputCount: params.texts.length,
+    });
+    const response = await fetch(`${clientOptions.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        signal: params.abortSignal,
+        body: JSON.stringify({
+            profileId,
+            texts: params.texts,
+            ...(requestId ? { debugRequestId: requestId } : {}),
+            ...((params.modelPolicy ?? clientOptions.modelPolicy)
+                ? { modelPolicy: params.modelPolicy ?? clientOptions.modelPolicy }
+                : {}),
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`bridge_embedding_failed:${response.status}:${errorText || "empty error body"}`);
+    }
+    const result = parseEmbeddingResult(await response.json().catch(() => undefined), params.texts.length);
+    if (result.profileId !== profileId) {
+        throw new Error("model_gateway_embedding_profile_mismatch");
+    }
+    traceDebug("model-gateway.client", "embedding.request.completed", {
+        requestId,
+        profileId,
+        provider: result.provider,
+        model: result.model,
+        vectorCount: result.vectors.length,
+        dimensions: result.dimensions,
+        durationMs: Date.now() - startedAt,
+    });
+    return result;
+}

package/dist/src/model-gateway/client.d.ts

@@ -3,7 +3,7 @@ import { buildModelInvocationMetrics } from "./client/invocation-metrics.js";
 import { projectModelGatewayMetricMessages } from "./client/message-projection.js";
 import { getModelGatewayStreamInactivityTimeoutMs } from "./client/options.js";
 import { classifyEmptyResponse } from "./client/stream-consumer.js";
-import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult } from "./types.js";
+import type { ModelGatewayEmbeddingParams, ModelGatewayEmbeddingResult, ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult } from "./types.js";
 export type { ModelGatewayClientOptions, ModelMetricMessage };
 export { buildModelInvocationMetrics, classifyEmptyResponse, getModelGatewayStreamInactivityTimeoutMs, projectModelGatewayMetricMessages, };
 export declare function invokeModelGateway(params: InvokeModelGatewayParams): Promise<{
@@ -12,8 +12,10 @@ export declare function invokeModelGateway(params: InvokeModelGatewayParams): Pr
 }>;
 export declare function countModelGatewayInputTokens(params: ModelGatewayInputTokenCountParams): Promise<ModelGatewayInputTokenCountResult | undefined>;
 export declare function invokeRawModelGateway(params: InvokeRawModelGatewayParams): Promise<RawModelGatewayResult>;
+export declare function embedModelGateway(params: ModelGatewayEmbeddingParams): Promise<ModelGatewayEmbeddingResult>;
 export declare function createModelGatewayClient(options?: ModelGatewayClientOptions): {
     invoke: typeof invokeModelGateway;
     invokeRaw: typeof invokeRawModelGateway;
     countInputTokens: typeof countModelGatewayInputTokens;
+    embed: typeof embedModelGateway;
 };

package/dist/src/model-gateway/client.js

@@ -5,6 +5,7 @@ import { projectModelGatewayMetricMessages } from "./client/message-projection.j
 import { getModelGatewayStreamInactivityTimeoutMs } from "./client/options.js";
 import { invokeRawModelGatewayWithOptions } from "./client/raw.js";
 import { classifyEmptyResponse } from "./client/stream-consumer.js";
+import { embedModelGatewayWithOptions } from "./client/embeddings.js";
 export { buildModelInvocationMetrics, classifyEmptyResponse, getModelGatewayStreamInactivityTimeoutMs, projectModelGatewayMetricMessages, };
 export async function invokeModelGateway(params) {
     return invokeModelGatewayWithOptions(params);
@@ -15,11 +16,15 @@ export async function countModelGatewayInputTokens(params) {
 export async function invokeRawModelGateway(params) {
     return invokeRawModelGatewayWithOptions(params);
 }
+export async function embedModelGateway(params) {
+    return embedModelGatewayWithOptions(params);
+}
 export function createModelGatewayClient(options = {}) {
     const inputTokenCountCache = new Map();
     return {
         invoke: (params) => invokeModelGatewayWithOptions(params, options),
         invokeRaw: (params) => invokeRawModelGatewayWithOptions(params, options),
+        embed: (params) => embedModelGatewayWithOptions(params, options),
         countInputTokens: (params) => countModelGatewayInputTokensWithOptions(params, options, inputTokenCountCache),
     };
 }

package/dist/src/model-gateway/embeddings/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAX_MODEL_GATEWAY_EMBEDDING_BATCH_SIZE = 128;

package/dist/src/model-gateway/embeddings/constants.js

@@ -0,0 +1 @@
+export const MAX_MODEL_GATEWAY_EMBEDDING_BATCH_SIZE = 128;

package/dist/src/model-gateway/embeddings/discovery.d.ts

@@ -0,0 +1,10 @@
+import type { ModelProviderAdapterRegistry, ModelProviderEmbeddingModelCatalog } from "../providers/contracts.js";
+import type { ModelGatewayPolicyConfig } from "../types.js";
+export declare function discoverEmbeddingModels(params: {
+    providerId: string;
+    modelPolicy: ModelGatewayPolicyConfig;
+    abortSignal: AbortSignal;
+    fetchImpl?: typeof fetch;
+    providerAdapters?: ModelProviderAdapterRegistry;
+    ollamaUrl?: string;
+}): Promise<ModelProviderEmbeddingModelCatalog>;

package/dist/src/model-gateway/embeddings/discovery.js

@@ -0,0 +1,39 @@
+import { DEFAULT_OLLAMA_URL } from "../../shared/constants.js";
+import { createBuiltInModelProviderAdapterRegistry } from "../providers/registry.js";
+import { EmbeddingProviderRequestError } from "./execution.js";
+export async function discoverEmbeddingModels(params) {
+    params.abortSignal.throwIfAborted();
+    const providerId = params.providerId.trim();
+    const providerConfig = params.modelPolicy.providers?.[providerId];
+    if (!providerConfig) {
+        throw new EmbeddingProviderRequestError(400, `unknown_embedding_provider:${providerId}`);
+    }
+    const adapter = resolveAdapters(params).resolve(providerConfig.type);
+    if (!adapter.listEmbeddingModels) {
+        return Object.freeze({ supported: false, models: Object.freeze([]) });
+    }
+    const result = await adapter.listEmbeddingModels({
+        providerId,
+        providerConfig,
+        fetchImpl: bindAbortSignal(params.fetchImpl ?? fetch, params.abortSignal),
+    });
+    if (result.kind === "error") {
+        throw new EmbeddingProviderRequestError(result.statusCode, result.message);
+    }
+    return Object.freeze({
+        supported: true,
+        models: Object.freeze(normalizeModelIds(result.models)),
+    });
+}
+function resolveAdapters(params) {
+    return (params.providerAdapters ??
+        createBuiltInModelProviderAdapterRegistry({
+            ollamaUrl: params.ollamaUrl ?? process.env.OLLAMA_URL ?? DEFAULT_OLLAMA_URL,
+        }));
+}
+function bindAbortSignal(fetchImpl, abortSignal) {
+    return (input, init) => fetchImpl(input, { ...init, signal: abortSignal });
+}
+function normalizeModelIds(models) {
+    return [...new Set(models.map((model) => model.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}

package/dist/src/model-gateway/embeddings/execution.d.ts

@@ -0,0 +1,16 @@
+import type { ModelProviderAdapterRegistry } from "../providers/contracts.js";
+import type { ModelGatewayEmbeddingResult, ModelGatewayPolicyConfig } from "../types.js";
+export declare class EmbeddingProviderRequestError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+export declare function executeEmbeddingRequest(params: {
+    profileId: string;
+    texts: readonly string[];
+    modelPolicy: ModelGatewayPolicyConfig;
+    abortSignal: AbortSignal;
+    fetchImpl?: typeof fetch;
+    providerAdapters?: ModelProviderAdapterRegistry;
+    ollamaUrl?: string;
+    debugRequestId?: string;
+}): Promise<ModelGatewayEmbeddingResult>;

package/dist/src/model-gateway/embeddings/execution.js

@@ -0,0 +1,64 @@
+import { DEFAULT_OLLAMA_URL } from "../../shared/constants.js";
+import { createBuiltInModelProviderAdapterRegistry } from "../providers/registry.js";
+import { resolveEmbeddingProfile } from "./profile.js";
+import { validateEmbeddingModelFingerprint, validateEmbeddingVectors, } from "./validation.js";
+export class EmbeddingProviderRequestError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "EmbeddingProviderRequestError";
+    }
+}
+export async function executeEmbeddingRequest(params) {
+    params.abortSignal.throwIfAborted();
+    const profile = resolveEmbeddingProfile({
+        profileId: params.profileId,
+        modelPolicy: params.modelPolicy,
+    });
+    const adapter = resolveAdapters(params).resolve(profile.provider);
+    if (!adapter.embed) {
+        throw new EmbeddingProviderRequestError(501, "model_provider_embeddings_unsupported");
+    }
+    const result = await adapter.embed({
+        requestBody: {
+            profileId: profile.id,
+            texts: params.texts,
+            modelPolicy: params.modelPolicy,
+            ...(params.debugRequestId
+                ? { debugRequestId: params.debugRequestId }
+                : {}),
+        },
+        profile,
+        texts: params.texts,
+        fetchImpl: bindAbortSignal(params.fetchImpl ?? fetch, params.abortSignal),
+    });
+    if (result.kind === "error") {
+        throwProviderError(result);
+    }
+    const vectors = validateEmbeddingVectors({
+        vectors: result.vectors,
+        expectedCount: params.texts.length,
+    });
+    const modelFingerprint = validateEmbeddingModelFingerprint(result.modelFingerprint);
+    return Object.freeze({
+        profileId: profile.id,
+        provider: profile.provider,
+        model: profile.model,
+        modelFingerprint,
+        dimensions: vectors[0]?.length ?? 0,
+        vectors,
+    });
+}
+function resolveAdapters(params) {
+    return (params.providerAdapters ??
+        createBuiltInModelProviderAdapterRegistry({
+            ollamaUrl: params.ollamaUrl ?? process.env.OLLAMA_URL ?? DEFAULT_OLLAMA_URL,
+        }));
+}
+function bindAbortSignal(fetchImpl, abortSignal) {
+    return (input, init) => fetchImpl(input, { ...init, signal: abortSignal });
+}
+function throwProviderError(error) {
+    throw new EmbeddingProviderRequestError(error.statusCode, error.message);
+}

package/dist/src/model-gateway/embeddings/fingerprint.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedEmbeddingProfile } from "../types.js";
+/** Stable identity for vectors that may be compared with one another. */
+export declare function createEmbeddingModelFingerprint(profile: ResolvedEmbeddingProfile, effectiveBaseUrl: string): string;

package/dist/src/model-gateway/embeddings/fingerprint.js

@@ -0,0 +1,36 @@
+import { createHash } from "node:crypto";
+/** Stable identity for vectors that may be compared with one another. */
+export function createEmbeddingModelFingerprint(profile, effectiveBaseUrl) {
+    const digest = createHash("sha256")
+        .update(JSON.stringify({
+        providerId: profile.providerId,
+        provider: profile.provider,
+        baseUrl: normalizeBaseUrl(effectiveBaseUrl),
+        model: profile.model,
+        options: canonicalizeJson(profile.options),
+    }))
+        .digest("hex")
+        .slice(0, 24);
+    return `${profile.provider}:${profile.model}:${digest}`;
+}
+function normalizeBaseUrl(value) {
+    return value.trim().replace(/\/+$/u, "");
+}
+function canonicalizeJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalizeJson);
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => compareKeys(left, right))
+        .map(([key, entry]) => [key, canonicalizeJson(entry)]));
+}
+function compareKeys(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/model-gateway/embeddings/profile.d.ts

@@ -0,0 +1,11 @@
+import type { ModelGatewayPolicyConfig, ResolvedEmbeddingProfile } from "../types.js";
+export type EmbeddingProfileResolutionErrorCode = "embedding_profile_required" | "unknown_embedding_profile" | "unknown_embedding_provider";
+export declare class EmbeddingProfileResolutionError extends Error {
+    readonly code: EmbeddingProfileResolutionErrorCode;
+    readonly statusCode = 400;
+    constructor(code: EmbeddingProfileResolutionErrorCode, detail: string);
+}
+export declare function resolveEmbeddingProfile(params: {
+    profileId: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+}): ResolvedEmbeddingProfile;

package/dist/src/model-gateway/embeddings/profile.js

@@ -0,0 +1,37 @@
+export class EmbeddingProfileResolutionError extends Error {
+    code;
+    statusCode = 400;
+    constructor(code, detail) {
+        super(`${code}: ${detail}`);
+        this.code = code;
+        this.name = "EmbeddingProfileResolutionError";
+    }
+}
+export function resolveEmbeddingProfile(params) {
+    const profileId = readRequiredProfileId(params.profileId);
+    const configured = params.modelPolicy?.embeddingProfiles?.[profileId];
+    if (!configured) {
+        throw new EmbeddingProfileResolutionError("unknown_embedding_profile", `embedding profile ${profileId} is not available in model policy`);
+    }
+    const providerId = configured.provider.trim();
+    const providerConfig = params.modelPolicy?.providers?.[providerId];
+    if (!providerConfig) {
+        throw new EmbeddingProfileResolutionError("unknown_embedding_provider", `embedding profile ${profileId} references unavailable provider ${providerId}`);
+    }
+    return Object.freeze({
+        id: profileId,
+        label: configured.label?.trim() || profileId,
+        providerId,
+        provider: providerConfig.type,
+        providerConfig,
+        model: configured.model.trim(),
+        options: Object.freeze({ ...(configured.options ?? {}) }),
+    });
+}
+function readRequiredProfileId(value) {
+    const profileId = typeof value === "string" ? value.trim() : "";
+    if (profileId) {
+        return profileId;
+    }
+    throw new EmbeddingProfileResolutionError("embedding_profile_required", "profileId must identify a configured embedding profile");
+}

package/dist/src/model-gateway/embeddings/server-handler.d.ts

@@ -0,0 +1,3 @@
+import type { ModelGatewayEmbeddingRequest } from "../types.js";
+import type { GatewayResponse, ModelGatewayHandlerOptions, ModelGatewayInvocationContext } from "../server/contracts.js";
+export declare function createEmbeddingHandler(options?: ModelGatewayHandlerOptions): (requestBody: ModelGatewayEmbeddingRequest, response: GatewayResponse, context?: ModelGatewayInvocationContext) => Promise<void>;

package/dist/src/model-gateway/embeddings/server-handler.js

@@ -0,0 +1,89 @@
+import { traceDebug } from "../../runtime/observability/debug-logger.js";
+import { respondToGatewayHandlerError } from "../server/errors.js";
+import { sendJson } from "../server/http-response.js";
+import { MAX_MODEL_GATEWAY_EMBEDDING_BATCH_SIZE } from "./constants.js";
+import { executeEmbeddingRequest } from "./execution.js";
+export function createEmbeddingHandler(options = {}) {
+    const { fetchImpl = fetch, modelPolicy } = options;
+    return async function embeddingHandler(requestBody, response, context = {}) {
+        const abortSignal = context.abortSignal ?? new AbortController().signal;
+        try {
+            abortSignal.throwIfAborted();
+            const texts = readEmbeddingTexts(requestBody.texts);
+            const effectivePolicy = modelPolicy ?? requestBody.modelPolicy;
+            const startedAt = Date.now();
+            const result = await executeEmbeddingRequest({
+                profileId: readProfileId(requestBody.profileId),
+                texts,
+                modelPolicy: effectivePolicy ?? {},
+                abortSignal,
+                fetchImpl,
+                ...(options.providerAdapters
+                    ? { providerAdapters: options.providerAdapters }
+                    : {}),
+                ...(options.ollamaUrl ? { ollamaUrl: options.ollamaUrl } : {}),
+                ...(typeof requestBody.debugRequestId === "string"
+                    ? { debugRequestId: requestBody.debugRequestId }
+                    : {}),
+            });
+            if (abortSignal.aborted) {
+                return;
+            }
+            emitEmbeddingCompleted({
+                requestBody,
+                profileId: result.profileId,
+                provider: result.provider,
+                model: result.model,
+                vectorCount: result.vectors.length,
+                dimensions: result.dimensions,
+                durationMs: Date.now() - startedAt,
+            });
+            return sendJson(response, 200, result);
+        }
+        catch (error) {
+            respondToGatewayHandlerError({
+                error,
+                response,
+                abortSignal,
+                includeContextWindowErrors: false,
+            });
+        }
+    };
+}
+function readEmbeddingTexts(value) {
+    const texts = Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+    const hasInvalidEntry = !Array.isArray(value) ||
+        texts.length !== value.length ||
+        texts.some(isBlank);
+    if (hasInvalidEntry || texts.length === 0) {
+        throw new EmbeddingRequestValidationError("embedding_texts_required");
+    }
+    if (texts.length > MAX_MODEL_GATEWAY_EMBEDDING_BATCH_SIZE) {
+        throw new EmbeddingRequestValidationError("embedding_batch_too_large");
+    }
+    return Object.freeze([...texts]);
+}
+function isBlank(value) {
+    return value.trim().length === 0;
+}
+function emitEmbeddingCompleted(params) {
+    traceDebug("model-gateway.server", "embedding.completed", {
+        requestId: typeof params.requestBody.debugRequestId === "string"
+            ? params.requestBody.debugRequestId
+            : "",
+        profileId: params.profileId,
+        provider: params.provider,
+        model: params.model,
+        vectorCount: params.vectorCount,
+        dimensions: params.dimensions,
+        durationMs: params.durationMs,
+    });
+}
+class EmbeddingRequestValidationError extends Error {
+    statusCode = 400;
+}
+function readProfileId(value) {
+    return typeof value === "string" ? value : "";
+}

package/dist/src/model-gateway/embeddings/validation.d.ts

@@ -0,0 +1,7 @@
+import type { ModelGatewayEmbeddingResult } from "../types.js";
+export declare function validateEmbeddingVectors(params: {
+    vectors: unknown;
+    expectedCount: number;
+}): readonly (readonly number[])[];
+export declare function validateEmbeddingModelFingerprint(value: unknown): string;
+export declare function parseEmbeddingResult(value: unknown, expectedCount: number): ModelGatewayEmbeddingResult;

package/dist/src/model-gateway/embeddings/validation.js

@@ -0,0 +1,69 @@
+export function validateEmbeddingVectors(params) {
+    if (!hasExpectedVectorCount(params.vectors, params.expectedCount)) {
+        throw new Error("model_gateway_embedding_vector_count_invalid");
+    }
+    const vectors = params.vectors.map(validateVector);
+    const dimensions = vectors[0]?.length ?? 0;
+    if (dimensions === 0) {
+        throw new Error("model_gateway_embedding_vector_empty");
+    }
+    if (vectors.some((vector) => vector.length !== dimensions)) {
+        throw new Error("model_gateway_embedding_dimensions_inconsistent");
+    }
+    return Object.freeze(vectors);
+}
+export function validateEmbeddingModelFingerprint(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error("model_gateway_embedding_binding_invalid");
+    }
+    return value;
+}
+function hasExpectedVectorCount(value, expectedCount) {
+    return Array.isArray(value) && value.length === expectedCount;
+}
+export function parseEmbeddingResult(value, expectedCount) {
+    const body = readRecord(value);
+    const vectors = validateEmbeddingVectors({
+        vectors: body.vectors,
+        expectedCount,
+    });
+    const dimensions = body.dimensions;
+    if (!Number.isSafeInteger(dimensions) || dimensions !== vectors[0]?.length) {
+        throw new Error("model_gateway_embedding_dimensions_invalid");
+    }
+    const binding = readEmbeddingBinding(body);
+    return Object.freeze({
+        ...binding,
+        dimensions,
+        vectors,
+    });
+}
+function validateVector(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("model_gateway_embedding_vector_invalid");
+    }
+    const vector = value.filter((entry) => typeof entry === "number" && Number.isFinite(entry));
+    if (vector.length !== value.length) {
+        throw new Error("model_gateway_embedding_vector_non_finite");
+    }
+    return Object.freeze(vector);
+}
+function readEmbeddingBinding(body) {
+    const keys = ["profileId", "provider", "model"];
+    const values = keys.map((key) => body[key]);
+    if (values.some((value) => typeof value !== "string" || value.length === 0)) {
+        throw new Error("model_gateway_embedding_binding_invalid");
+    }
+    return {
+        profileId: values[0],
+        provider: values[1],
+        model: values[2],
+        modelFingerprint: validateEmbeddingModelFingerprint(body.modelFingerprint),
+    };
+}
+function readRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    throw new Error("model_gateway_embedding_response_invalid");
+}

package/dist/src/model-gateway/index.d.ts

@@ -1,3 +1,5 @@
-export { createModelProviderAdapterRegistry, ModelProviderAdapterResolutionError, type ModelProviderAdapter, type ModelProviderAdapterRegistry, type ModelProviderChatInvocation, type ModelProviderEventSink, type ModelProviderInvocationError, type ModelProviderInputTokenCount, type ModelProviderInputTokenCountParams, type ModelProviderInputTokenCountResult, type ModelProviderInvocationParams, type ModelProviderInvocationResult, type ModelProviderRawInvocation, } from "./provider-adapter.js";
-export { createChatHandler, createInputTokenCountHandler, createModelGatewayServer, createRawHandler, type GatewayFetch, type GatewayResponse, type ModelGatewayHandlerOptions, } from "./server.js";
-export type { ModelContextConfig, ModelFormatTokenAccountingConfig, ModelGatewayPolicyConfig, ModelGatewayProviderConfig, ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayRequest, ModelProfile, ResolvedModelInvocation, } from "./types.js";
+export { createModelProviderAdapterRegistry, ModelProviderAdapterResolutionError, type ModelProviderAdapter, type ModelProviderAdapterRegistry, type ModelProviderChatInvocation, type ModelProviderEventSink, type ModelProviderInvocationError, type ModelProviderInputTokenCount, type ModelProviderInputTokenCountParams, type ModelProviderInputTokenCountResult, type ModelProviderEmbeddingParams, type ModelProviderEmbeddingModelCatalog, type ModelProviderEmbeddingModelCatalogResult, type ModelProviderEmbeddingModelDiscoveryParams, type ModelProviderEmbeddingResult, type ModelProviderInvocationParams, type ModelProviderInvocationResult, type ModelProviderRawInvocation, } from "./provider-adapter.js";
+export { createChatHandler, createEmbeddingHandler, createInputTokenCountHandler, createModelGatewayServer, createRawHandler, type GatewayFetch, type GatewayResponse, type ModelGatewayHandlerOptions, } from "./server.js";
+export { EmbeddingProviderRequestError, executeEmbeddingRequest, } from "./embeddings/execution.js";
+export { discoverEmbeddingModels } from "./embeddings/discovery.js";
+export type { ModelContextConfig, ModelFormatTokenAccountingConfig, ModelGatewayPolicyConfig, ModelGatewayProviderConfig, ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayEmbeddingParams, ModelGatewayEmbeddingProfileConfig, ModelGatewayEmbeddingRequest, ModelGatewayEmbeddingResult, ModelGatewayRequest, ModelProfile, ResolvedModelInvocation, } from "./types.js";

package/dist/src/model-gateway/index.js

@@ -1,2 +1,4 @@
 export { createModelProviderAdapterRegistry, ModelProviderAdapterResolutionError, } from "./provider-adapter.js";
-export { createChatHandler, createInputTokenCountHandler, createModelGatewayServer, createRawHandler, } from "./server.js";
+export { createChatHandler, createEmbeddingHandler, createInputTokenCountHandler, createModelGatewayServer, createRawHandler, } from "./server.js";
+export { EmbeddingProviderRequestError, executeEmbeddingRequest, } from "./embeddings/execution.js";
+export { discoverEmbeddingModels } from "./embeddings/discovery.js";

package/dist/src/model-gateway/providers/contracts.d.ts

@@ -1,4 +1,4 @@
-import type { ModelGatewayEvent, ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
+import type { ModelGatewayEmbeddingRequest, ModelGatewayEvent, ModelGatewayProviderConfig, ModelGatewayRequest, ResolvedEmbeddingProfile, ResolvedModelInvocation } from "../types.js";
 export type ModelProviderEventSink = Readonly<{
     emit(event: ModelGatewayEvent): void;
 }>;
@@ -27,6 +27,30 @@ export type ModelProviderInputTokenMeasurement = Readonly<{
     source: "provider_input_token_count";
 }>;
 export type ModelProviderInputTokenCountResult = ModelProviderInvocationError | ModelProviderInputTokenCount;
+export type ModelProviderEmbeddingResult = ModelProviderInvocationError | Readonly<{
+    kind: "embedded";
+    vectors: readonly (readonly number[])[];
+    modelFingerprint: string;
+}>;
+export type ModelProviderEmbeddingParams = Readonly<{
+    requestBody: ModelGatewayEmbeddingRequest;
+    profile: ResolvedEmbeddingProfile;
+    texts: readonly string[];
+    fetchImpl: typeof fetch;
+}>;
+export type ModelProviderEmbeddingModelCatalog = Readonly<{
+    supported: boolean;
+    models: readonly string[];
+}>;
+export type ModelProviderEmbeddingModelDiscoveryParams = Readonly<{
+    providerId: string;
+    providerConfig: ModelGatewayProviderConfig;
+    fetchImpl: typeof fetch;
+}>;
+export type ModelProviderEmbeddingModelCatalogResult = ModelProviderInvocationError | Readonly<{
+    kind: "listed";
+    models: readonly string[];
+}>;
 export type ModelProviderInvocationParams = Readonly<{
     endpoint: "chat" | "raw";
     requestBody: ModelGatewayRequest;
@@ -47,6 +71,8 @@ export type ModelProviderInputTokenCountParams = Readonly<{
 export type ModelProviderAdapter = Readonly<{
     type: string;
     supportsImageInput: boolean;
+    embed?(params: ModelProviderEmbeddingParams): Promise<ModelProviderEmbeddingResult>;
+    listEmbeddingModels?(params: ModelProviderEmbeddingModelDiscoveryParams): Promise<ModelProviderEmbeddingModelCatalogResult>;
     countInputTokens?(params: ModelProviderInputTokenCountParams): Promise<ModelProviderInputTokenCountResult>;
     invoke(params: ModelProviderInvocationParams): Promise<ModelProviderInvocationResult>;
 }>;

package/dist/src/model-gateway/providers/ollama/adapter.js

@@ -3,6 +3,8 @@ import { buildOllamaPayload, buildOllamaRawPayload, } from "./payload.js";
 import { emitOllamaRequestProjection, emitOllamaSchemaDiagnostics, emitOllamaTiming, resolveOllamaBaseUrl, } from "./request-diagnostics.js";
 import { createOllamaStreamDiagnostics, isAbortFailure, } from "./stream-diagnostics.js";
 import { collectOllamaStream, forwardOllamaStream, } from "./stream-normalizer.js";
+import { embedWithOllama } from "./embeddings.js";
+import { listOllamaEmbeddingModels } from "./embedding-models.js";
 function readRequestId(params) {
     return typeof params.requestBody.debugRequestId === "string"
         ? params.requestBody.debugRequestId
@@ -21,6 +23,8 @@ export function createOllamaProviderAdapter(options) {
     return Object.freeze({
         type: "ollama",
         supportsImageInput: true,
+        embed: (params) => embedWithOllama(params, options.fallbackUrl),
+        listEmbeddingModels: (params) => listOllamaEmbeddingModels(params, options.fallbackUrl),
         async invoke(params) {
             const requestId = readRequestId(params);
             let removedConstraintCount = 0;