@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/model-gateway/providers/ollama/base-url.d.ts

@@ -0,0 +1 @@
+export declare function resolveConfiguredOllamaBaseUrl(configuredUrl: string | undefined, fallbackUrl: string): string;

package/dist/src/model-gateway/providers/ollama/base-url.js

@@ -0,0 +1,4 @@
+export function resolveConfiguredOllamaBaseUrl(configuredUrl, fallbackUrl) {
+    const effectiveUrl = configuredUrl?.trim() || fallbackUrl.trim();
+    return effectiveUrl.replace(/\/+$/u, "");
+}

package/dist/src/model-gateway/providers/ollama/embedding-models.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProviderEmbeddingModelCatalogResult, ModelProviderEmbeddingModelDiscoveryParams } from "../contracts.js";
+export declare function listOllamaEmbeddingModels(params: ModelProviderEmbeddingModelDiscoveryParams, fallbackUrl: string): Promise<ModelProviderEmbeddingModelCatalogResult>;

package/dist/src/model-gateway/providers/ollama/embedding-models.js

@@ -0,0 +1,31 @@
+import { resolveConfiguredOllamaBaseUrl } from "./base-url.js";
+export async function listOllamaEmbeddingModels(params, fallbackUrl) {
+    const baseUrl = resolveConfiguredOllamaBaseUrl(params.providerConfig.baseUrl, fallbackUrl);
+    const response = await params.fetchImpl(`${baseUrl}/api/tags`);
+    if (!response.ok) {
+        return {
+            kind: "error",
+            statusCode: response.status || 502,
+            message: (await response.text()) || "ollama model discovery error",
+        };
+    }
+    const body = await response.json().catch(() => undefined);
+    return Object.freeze({
+        kind: "listed",
+        models: readModelNames(body),
+    });
+}
+function readModelNames(value) {
+    const body = isRecord(value) ? value : undefined;
+    const models = Array.isArray(body?.models) ? body.models : [];
+    return models.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const name = typeof entry.name === "string" ? entry.name.trim() : "";
+        return name ? [name] : [];
+    });
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/model-gateway/providers/ollama/embeddings.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProviderEmbeddingParams, ModelProviderEmbeddingResult } from "../contracts.js";
+export declare function embedWithOllama(params: ModelProviderEmbeddingParams, fallbackUrl: string): Promise<ModelProviderEmbeddingResult>;

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

@@ -0,0 +1,43 @@
+import { createEmbeddingModelFingerprint } from "../../embeddings/fingerprint.js";
+import { validateEmbeddingVectors } from "../../embeddings/validation.js";
+import { resolveConfiguredOllamaBaseUrl } from "./base-url.js";
+export async function embedWithOllama(params, fallbackUrl) {
+    const baseUrl = resolveConfiguredOllamaBaseUrl(params.profile.providerConfig.baseUrl, fallbackUrl);
+    const response = await params.fetchImpl(`${baseUrl}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            model: params.profile.model,
+            input: params.texts,
+            ...(params.profile.options &&
+                Object.keys(params.profile.options).length > 0
+                ? { options: params.profile.options }
+                : {}),
+            ...(params.profile.providerConfig.keepAlive
+                ? { keep_alive: params.profile.providerConfig.keepAlive }
+                : {}),
+        }),
+    });
+    if (!response.ok) {
+        return {
+            kind: "error",
+            statusCode: response.status || 502,
+            message: (await response.text()) || "ollama embedding error",
+        };
+    }
+    const body = await response.json().catch(() => undefined);
+    const embeddings = readEmbeddings(body);
+    return Object.freeze({
+        kind: "embedded",
+        vectors: validateEmbeddingVectors({
+            vectors: embeddings,
+            expectedCount: params.texts.length,
+        }),
+        modelFingerprint: createEmbeddingModelFingerprint(params.profile, baseUrl),
+    });
+}
+function readEmbeddings(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value.embeddings
+        : undefined;
+}

package/dist/src/model-gateway/providers/ollama/generation-options.d.ts

@@ -1,4 +1,4 @@
-import type { ModelGatewayFormat, ResolvedModelInvocation } from "../../types.js";
+import type { ResolvedModelInvocation } from "../../types.js";
 export declare function readOptionalPositiveIntEnv(name: string): number | undefined;
 export declare function buildOllamaOptions(params: {
     baseOptions: Record<string, unknown>;
@@ -13,8 +13,6 @@ export declare function buildOllamaOptions(params: {
 export declare function deriveOllamaNumPredict(params: {
     payload: Readonly<Record<string, unknown>>;
     invocation: ResolvedModelInvocation;
-    effectiveFormat?: ModelGatewayFormat;
-    useStructuredOutputCeiling: boolean;
     outputTokenLimit?: number;
 }): number;
 export declare function resolveOllamaKeepAlive(invocation: ResolvedModelInvocation): string;

package/dist/src/model-gateway/providers/ollama/generation-options.js

@@ -1,4 +1,3 @@
-import { estimateStrictStructuredOutputTokenCeiling } from "../../structured-output/budget.js";
 import { estimateProviderEnvelopeInputTokens } from "../envelope-budget.js";
 const DEFAULT_OLLAMA_KEEP_ALIVE = "3m";
 export function readOptionalPositiveIntEnv(name) {
@@ -38,10 +37,7 @@ export function buildOllamaOptions(params) {
 export function deriveOllamaNumPredict(params) {
     const estimatedInputTokens = estimateProviderEnvelopeInputTokens(params.payload, params.invocation.profile.context.tokenEstimation);
     const physicalRemainingTokens = Math.max(1, params.invocation.profile.contextWindowTokens - estimatedInputTokens);
-    const structuredOutputCeiling = params.useStructuredOutputCeiling
-        ? estimateStrictStructuredOutputTokenCeiling(params.effectiveFormat, params.invocation.profile.context.tokenEstimation)
-        : undefined;
-    return Math.max(1, Math.min(physicalRemainingTokens, structuredOutputCeiling ?? physicalRemainingTokens, params.outputTokenLimit ?? physicalRemainingTokens));
+    return Math.max(1, Math.min(physicalRemainingTokens, params.outputTokenLimit ?? physicalRemainingTokens));
 }
 export function resolveOllamaKeepAlive(invocation) {
     const configured = invocation.profile.providerConfig?.keepAlive?.trim();

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

@@ -28,10 +28,6 @@ function applyGenerationOptions(params) {
         derivedNumPredict: deriveOllamaNumPredict({
             payload: params.payload,
             invocation: params.invocation,
-            ...(params.effectiveFormat
-                ? { effectiveFormat: params.effectiveFormat }
-                : {}),
-            useStructuredOutputCeiling: params.useStructuredOutputCeiling,
             ...(params.outputTokenLimit !== undefined
                 ? { outputTokenLimit: params.outputTokenLimit }
                 : {}),
@@ -71,8 +67,6 @@ export function buildOllamaPayload(requestBody, payloadOptions = {}) {
     applyGenerationOptions({
         payload,
         invocation,
-        ...(effectiveFormat ? { effectiveFormat } : {}),
-        useStructuredOutputCeiling: !invocation.profile.supportsThinking || invocation.think === "none",
         ...(outputTokenLimit !== undefined ? { outputTokenLimit } : {}),
     });
     return payload;
@@ -103,8 +97,6 @@ export function buildOllamaRawPayload(requestBody, payloadOptions = {}) {
     applyGenerationOptions({
         payload,
         invocation,
-        ...(effectiveFormat ? { effectiveFormat } : {}),
-        useStructuredOutputCeiling: false,
         ...(outputTokenLimit !== undefined ? { outputTokenLimit } : {}),
     });
     return payload;

package/dist/src/model-gateway/providers/ollama/request-diagnostics.js

@@ -1,4 +1,5 @@
 import { traceDebug } from "../../../runtime/observability/debug-logger.js";
+import { resolveConfiguredOllamaBaseUrl } from "./base-url.js";
 import { readEffectiveOption } from "./options.js";
 function readRecord(value) {
     const isRecord = value !== null && typeof value === "object" && !Array.isArray(value);
@@ -28,7 +29,7 @@ function countArrayItems(value) {
     return Array.isArray(value) ? value.length : 0;
 }
 export function resolveOllamaBaseUrl(invocation, fallbackUrl) {
-    return invocation.profile.providerConfig?.baseUrl?.trim() || fallbackUrl;
+    return resolveConfiguredOllamaBaseUrl(invocation.profile.providerConfig?.baseUrl, fallbackUrl);
 }
 export function emitOllamaSchemaDiagnostics(requestId, diagnostics) {
     for (const diagnostic of diagnostics) {

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

@@ -2,10 +2,12 @@ import { fetchProviderWithTrace } from "../../model-io-trace.js";
 import { emitOpenAIMessageOutputDiagnostic, emitOpenAISchemaDiagnostics, emitOpenAIStreamTermination, hasStructuredTextFormat, resolveOpenAIStreamFailureOutcome, } from "./diagnostics.js";
 import { countOpenAIInputTokens } from "./input-token-count.js";
 import { buildOpenAIResponsesPayload, collectOpenAIResponsesStream, forwardOpenAIResponsesStream, resolveOpenAIProviderSettings, } from "./protocol.js";
+import { embedWithOpenAI } from "./embeddings.js";
 export function createOpenAIProviderAdapter() {
     return Object.freeze({
         type: "openai",
         supportsImageInput: false,
+        embed: embedWithOpenAI,
         countInputTokens: countOpenAIInputTokens,
         async invoke(params) {
             const settings = resolveOpenAIProviderSettings(params.requestBody);

package/dist/src/model-gateway/providers/openai/embeddings.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProviderEmbeddingParams, ModelProviderEmbeddingResult } from "../contracts.js";
+export declare function embedWithOpenAI(params: ModelProviderEmbeddingParams): Promise<ModelProviderEmbeddingResult>;

package/dist/src/model-gateway/providers/openai/embeddings.js

@@ -0,0 +1,87 @@
+import { createEmbeddingModelFingerprint } from "../../embeddings/fingerprint.js";
+import { validateEmbeddingVectors } from "../../embeddings/validation.js";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
+const ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export async function embedWithOpenAI(params) {
+    const settings = resolveEmbeddingSettings(params);
+    if (!settings.apiKey) {
+        return {
+            kind: "error",
+            statusCode: 500,
+            message: `missing OpenAI API key env: ${settings.apiKeyEnv}`,
+        };
+    }
+    const response = await params.fetchImpl(`${settings.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${settings.apiKey}`,
+        },
+        body: JSON.stringify({
+            ...params.profile.options,
+            model: params.profile.model,
+            input: params.texts,
+            encoding_format: "float",
+        }),
+    });
+    if (!response.ok) {
+        return {
+            kind: "error",
+            statusCode: response.status || 502,
+            message: (await response.text()) || "openai embedding error",
+        };
+    }
+    const body = await response.json().catch(() => undefined);
+    const vectors = readOrderedVectors(body, params.texts.length);
+    return Object.freeze({
+        kind: "embedded",
+        vectors: validateEmbeddingVectors({
+            vectors,
+            expectedCount: params.texts.length,
+        }),
+        modelFingerprint: createEmbeddingModelFingerprint(params.profile, settings.baseUrl),
+    });
+}
+function resolveEmbeddingSettings(params) {
+    const configuredEnv = params.profile.providerConfig.apiKeyEnv?.trim();
+    const apiKeyEnv = configuredEnv && ENV_VAR_NAME_PATTERN.test(configuredEnv)
+        ? configuredEnv
+        : DEFAULT_OPENAI_API_KEY_ENV;
+    const apiKey = process.env[apiKeyEnv];
+    return {
+        baseUrl: (params.profile.providerConfig.baseUrl?.trim() ||
+            process.env.OPENAI_BASE_URL ||
+            DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, ""),
+        apiKeyEnv,
+        ...(apiKey ? { apiKey } : {}),
+    };
+}
+function readOrderedVectors(value, expectedCount) {
+    const body = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+    if (!body || !Array.isArray(body.data)) {
+        return [];
+    }
+    const entries = body.data.filter(isRecord);
+    if (!hasContiguousIndices(entries, expectedCount)) {
+        return [];
+    }
+    return [...entries]
+        .sort((left, right) => Number(left.index) - Number(right.index))
+        .map((entry) => entry.embedding);
+}
+function hasContiguousIndices(entries, expectedCount) {
+    if (entries.length !== expectedCount) {
+        return false;
+    }
+    const indices = new Set(entries.map(({ index }) => index));
+    return (indices.size === expectedCount &&
+        [...indices].every((index) => Number.isSafeInteger(index) &&
+            Number(index) >= 0 &&
+            Number(index) < expectedCount));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/model-gateway/providers/openai/payload.js

@@ -1,6 +1,6 @@
 import { resolveModelStepOutputTokenLimit } from "../../../shared/model-step-registry.js";
 import { isAssistantToolCallMessage, isToolResultMessage, validateModelGatewayMessages, } from "../../protocol/message-contract.js";
-import { normalizeReasoning, resolveModelInvocation, } from "../../policy/invocation-policy.js";
+import { resolveModelInvocation } from "../../policy/invocation-policy.js";
 import { projectOpenAIResponsesFormat, resolveModelGatewayFormat, } from "../../structured-output/projection.js";
 import { resolveProviderEnvelopeInputTokens } from "../envelope-budget.js";
 function prependInstructionInput(params) {
@@ -73,9 +73,7 @@ export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     const generation = invocation.profile.generation;
     const temperature = readFiniteNumber(generation.temperature);
     const topP = readFiniteNumber(generation.topP);
-    const reasoningEffort = normalizeReasoning(requestBody.reasoningOverride) ??
-        generation.reasoningEffort ??
-        invocation.think;
+    const reasoningEffort = invocation.think;
     const formatProjection = projectOpenAIResponsesFormat(resolveModelGatewayFormat(requestBody.format, invocation.format));
     if (formatProjection.diagnostics.length > 0) {
         payloadOptions.onFormatProjection?.(formatProjection.diagnostics);
@@ -83,9 +81,8 @@ export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     const canUseSamplingControls = !invocation.profile.supportsThinking ||
         reasoningEffort === undefined ||
         reasoningEffort === "none";
-    const shouldSendReasoning = invocation.profile.supportsThinking &&
-        reasoningEffort !== undefined &&
-        reasoningEffort !== "none";
+    const shouldProjectOpenAIReasoning = invocation.profile.supportsThinking &&
+        reasoningEffort !== undefined;
     const payload = {
         model: invocation.model,
         input: resolveInputWithProviderInstructions(requestBody, formatProjection.instructions),
@@ -97,7 +94,7 @@ export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     if (canUseSamplingControls && topP !== undefined) {
         payload.top_p = topP;
     }
-    if (shouldSendReasoning) {
+    if (shouldProjectOpenAIReasoning) {
         payload.reasoning = { effort: reasoningEffort };
     }
     if (formatProjection.format) {

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

@@ -1,4 +1,4 @@
-import type { ModelGatewayPolicyConfig, ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
+import type { ModelGatewayEmbeddingRequest, ModelGatewayPolicyConfig, ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
 import type { ModelProviderAdapter, ModelProviderAdapterRegistry, ModelProviderInputTokenMeasurement } from "../providers/contracts.js";
 export type GatewayFetch = typeof fetch;
 export type GatewayResponse = {
@@ -37,10 +37,12 @@ export type ModelGatewayStatusResult = {
     now: string;
 };
 export type ProviderRequestAbortScopeParams = Readonly<{
+    endpoint: "chat" | "raw" | "input_tokens" | "embeddings";
+    requestBody: ModelGatewayRequest | ModelGatewayEmbeddingRequest;
+}>;
+export type ProviderFetchParams = Readonly<{
     endpoint: "chat" | "raw" | "input_tokens";
     requestBody: ModelGatewayRequest;
-}>;
-export type ProviderFetchParams = ProviderRequestAbortScopeParams & Readonly<{
     invocation: ResolvedModelInvocation;
     fetchImpl: typeof fetch;
     abortSignal: AbortSignal;

package/dist/src/model-gateway/server/create-server.js

@@ -1,5 +1,6 @@
 import { createServer, } from "node:http";
 import { listModelProfiles } from "../policy/model-registry.js";
+import { createEmbeddingHandler } from "../embeddings/server-handler.js";
 import { getModelGatewayStatus, isLoopbackRequest, requestModelGatewayRestart, } from "./admin.js";
 import { createChatHandler } from "./chat-handler.js";
 import { configureModelGateway } from "./configuration.js";
@@ -38,6 +39,7 @@ export function createModelGatewayServer(options = {}) {
     const chatHandler = createChatHandler(handlerOptions, inputTokenMeasurements);
     const inputTokenCountHandler = createInputTokenCountHandler(handlerOptions, inputTokenMeasurements);
     const rawHandler = createRawHandler(handlerOptions);
+    const embeddingHandler = createEmbeddingHandler(handlerOptions);
     return createServer(async (request, response) => {
         try {
             const route = `${request.method ?? ""} ${request.url ?? ""}`;
@@ -79,6 +81,13 @@ export function createModelGatewayServer(options = {}) {
                         endpoint: "raw",
                         handler: rawHandler,
                     });
+                case "POST /embeddings":
+                    return await handleProviderRequest({
+                        request,
+                        response,
+                        endpoint: "embeddings",
+                        handler: embeddingHandler,
+                    });
                 case "POST /admin/restart":
                     if (!isLoopbackRequest(request)) {
                         return sendText(response, 403, "forbidden");

package/dist/src/model-gateway/server/errors.js

@@ -1,4 +1,6 @@
 import { ModelInvocationResolutionError } from "../policy/invocation-policy.js";
+import { EmbeddingProviderRequestError } from "../embeddings/execution.js";
+import { EmbeddingProfileResolutionError } from "../embeddings/profile.js";
 import { ModelProviderContextWindowExceededError, ModelProviderEnvelopeInspectionError, } from "../model-io-trace.js";
 import { ModelProviderAdapterResolutionError } from "../providers/contracts.js";
 import { sendText } from "./http-response.js";
@@ -16,6 +18,29 @@ function handleProviderAdapterResolutionError(error, response) {
     sendText(response, error.statusCode, error.message);
     return true;
 }
+function handleEmbeddingProfileResolutionError(error, response) {
+    if (!(error instanceof EmbeddingProfileResolutionError)) {
+        return false;
+    }
+    sendText(response, error.statusCode, error.message);
+    return true;
+}
+function handleBadRequestError(error, response) {
+    if (!(error instanceof Error) ||
+        !("statusCode" in error) ||
+        error.statusCode !== 400) {
+        return false;
+    }
+    sendText(response, 400, error.message);
+    return true;
+}
+function handleEmbeddingProviderRequestError(error, response) {
+    if (!(error instanceof EmbeddingProviderRequestError)) {
+        return false;
+    }
+    sendText(response, error.statusCode, error.message);
+    return true;
+}
 function handleProviderContextWindowError(error, response) {
     const isContextWindowError = error instanceof ModelProviderContextWindowExceededError ||
         error instanceof ModelProviderEnvelopeInspectionError;
@@ -32,6 +57,15 @@ export function handleKnownGatewayError(params) {
     if (handleProviderAdapterResolutionError(params.error, params.response)) {
         return true;
     }
+    if (handleEmbeddingProfileResolutionError(params.error, params.response)) {
+        return true;
+    }
+    if (handleEmbeddingProviderRequestError(params.error, params.response)) {
+        return true;
+    }
+    if (handleBadRequestError(params.error, params.response)) {
+        return true;
+    }
     return (params.includeContextWindowErrors &&
         handleProviderContextWindowError(params.error, params.response));
 }

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

@@ -3,4 +3,6 @@ export { resolveModelGatewayPort } from "./configuration.js";
 export type { GatewayFetch, GatewayResponse, ModelGatewayHandlerOptions, ModelGatewayInvocationContext, ModelGatewayRestartRequest, ModelGatewayRestartResult, ModelGatewayStatusResult, } from "./contracts.js";
 export { createModelGatewayServer } from "./create-server.js";
 export { createInputTokenCountHandler } from "./input-token-count-handler.js";
+export { resolveProviderAdapters } from "./provider-registry.js";
+export { createEmbeddingHandler } from "../embeddings/server-handler.js";
 export { createRawHandler } from "./raw-handler.js";

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

@@ -2,4 +2,6 @@ export { createChatHandler } from "./chat-handler.js";
 export { resolveModelGatewayPort } from "./configuration.js";
 export { createModelGatewayServer } from "./create-server.js";
 export { createInputTokenCountHandler } from "./input-token-count-handler.js";
+export { resolveProviderAdapters } from "./provider-registry.js";
+export { createEmbeddingHandler } from "../embeddings/server-handler.js";
 export { createRawHandler } from "./raw-handler.js";

package/dist/src/model-gateway/server/provider-fetch.d.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ModelGatewayRequest } from "../types.js";
+import type { ModelGatewayEmbeddingRequest, ModelGatewayRequest } from "../types.js";
 import type { ProviderFetchParams } from "./contracts.js";
+type DiagnosticRequestBody = ModelGatewayRequest | ModelGatewayEmbeddingRequest;
 export declare function createAbortBoundProviderFetch(params: ProviderFetchParams): typeof fetch;
 export declare function createContextGuardedProviderFetch(params: ProviderFetchParams & Readonly<{
     endpoint: "chat" | "raw";
@@ -8,9 +9,10 @@ export declare function createContextGuardedProviderFetch(params: ProviderFetchP
 export declare function createProviderRequestAbortScope(params: {
     req: IncomingMessage;
     res: ServerResponse;
-    endpoint: "chat" | "raw" | "input_tokens";
-    requestBody: ModelGatewayRequest;
+    endpoint: "chat" | "raw" | "input_tokens" | "embeddings";
+    requestBody: DiagnosticRequestBody;
 }): Readonly<{
     signal: AbortSignal;
     dispose(): void;
 }>;
+export {};

package/dist/src/model-gateway/server/provider-fetch.js

@@ -6,7 +6,9 @@ function readDebugRequestId(requestBody) {
         : "";
 }
 function readModelStep(requestBody) {
-    return typeof requestBody.modelStep === "string" ? requestBody.modelStep : "";
+    return "modelStep" in requestBody && typeof requestBody.modelStep === "string"
+        ? requestBody.modelStep
+        : "";
 }
 function serializeAbortReason(reason) {
     return reason instanceof Error

package/dist/src/model-gateway/server/request-body.d.ts

@@ -1,3 +1,3 @@
 import type { IncomingMessage } from "node:http";
 import type { ModelGatewayRequest } from "../types.js";
-export declare function readJsonBody(request: IncomingMessage): Promise<ModelGatewayRequest>;
+export declare function readJsonBody<T extends object = ModelGatewayRequest>(request: IncomingMessage): Promise<T>;

package/dist/src/model-gateway/server/request-body.js

@@ -1,4 +1,5 @@
 export async function readJsonBody(request) {
+    request.setEncoding("utf8");
     let raw = "";
     for await (const chunk of request) {
         raw += chunk;

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

@@ -72,6 +72,13 @@ export type ModelGatewayProfileConfig = {
     context?: ModelContextConfig;
     calibration?: Record<string, ModelStepCalibrationConfig>;
 };
+/** Provider/model binding for non-generative embedding requests. */
+export type ModelGatewayEmbeddingProfileConfig = {
+    label?: string;
+    provider: string;
+    model: string;
+    options?: Record<string, unknown>;
+};
 export type ModelModality = "text" | "image" | "audio";
 export type ModelGatewayProfileCapabilities = {
     inputModalities?: ModelModality[];
@@ -127,9 +134,40 @@ export type ModelStepCalibrationConfig = {
 export type ModelGatewayPolicyConfig = {
     providers?: Record<string, ModelGatewayProviderConfig>;
     profiles?: Record<string, ModelGatewayProfileConfig>;
+    embeddingProfiles?: Record<string, ModelGatewayEmbeddingProfileConfig>;
     invocationProfiles?: Record<string, ModelInvocationProfileConfig>;
     defaults?: ModelGatewayPolicyDefaults;
 };
+export type ModelGatewayEmbeddingRequest = {
+    profileId?: unknown;
+    texts?: unknown;
+    debugRequestId?: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+};
+export type ModelGatewayEmbeddingParams = Readonly<{
+    profileId: string;
+    texts: readonly string[];
+    modelPolicy?: ModelGatewayPolicyConfig;
+    abortSignal: AbortSignal;
+    debugRequestId?: string;
+}>;
+export type ModelGatewayEmbeddingResult = Readonly<{
+    profileId: string;
+    provider: ModelProvider;
+    model: string;
+    modelFingerprint: string;
+    dimensions: number;
+    vectors: readonly (readonly number[])[];
+}>;
+export type ResolvedEmbeddingProfile = Readonly<{
+    id: string;
+    label: string;
+    providerId: string;
+    provider: ModelProvider;
+    providerConfig: ModelGatewayProviderConfig;
+    model: string;
+    options: Readonly<Record<string, unknown>>;
+}>;
 export type ModelGatewayRequest = {
     text?: string;
     prompt?: string;
@@ -186,6 +224,7 @@ export type ModelProfile = {
 export type ResolvedModelInvocation = {
     profile: ModelProfile;
     model: string;
+    /** `none` is an explicit disable; only `undefined` permits adapter omission. */
     think?: ModelReasoningLevel;
     format?: ModelGatewayFormat;
     instructions?: string[];

package/dist/src/plugin-contract/manifest.d.ts

@@ -5,6 +5,7 @@ export declare const ABOT_RUNTIME_EXTENSION_VERSION: 1;
 export type AgentPluginOperationManifest = Readonly<{
     summary: string;
     input: ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
     effect: ToolNormalInvocationEffect;
     approval: ToolNormalInvocationApproval;
     fixedParams?: Readonly<Record<string, ToolNormalInvocationFixedValue>>;

package/dist/src/plugin-sdk/index.d.ts

@@ -4,4 +4,6 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./tool-availability-brief.js";
+export * from "./tool-availability-overview.js";
 export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/index.js

@@ -4,4 +4,6 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./tool-availability-brief.js";
+export * from "./tool-availability-overview.js";
 export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/tool-availability-brief.d.ts

@@ -0,0 +1,9 @@
+import type { ToolAvailabilityEntry } from "../plugin-contract/entrypoint.js";
+import { type BoundedCollectionMetadata, type BoundedTextMetadata } from "./bounds.js";
+export type ToolAvailabilityBrief = Readonly<{
+    text: string;
+    collection: BoundedCollectionMetadata;
+    output: BoundedTextMetadata;
+}>;
+/** Formats the existing bounded, on-demand tool brief without executing tools. */
+export declare function buildToolAvailabilityBrief(entries: readonly ToolAvailabilityEntry[]): ToolAvailabilityBrief;

package/dist/src/plugin-sdk/tool-availability-brief.js

@@ -0,0 +1,48 @@
+import { boundCollection, boundText, } from "./bounds.js";
+const TOOL_COUNT_MAX = 64;
+const OUTPUT_CHARACTER_MAX = 16_000;
+/** Formats the existing bounded, on-demand tool brief without executing tools. */
+export function buildToolAvailabilityBrief(entries) {
+    const orderedTools = [...entries].sort(compareAvailableTools);
+    const boundedTools = boundCollection(orderedTools, {
+        maxItems: TOOL_COUNT_MAX,
+    });
+    const rawOutput = [
+        `Available tool operations: ${entries.length}`,
+        ...boundedTools.items.map(formatAvailableTool),
+        ...(boundedTools.metadata.truncated
+            ? [
+                `[${boundedTools.metadata.omittedItems} additional tool operations omitted]`,
+            ]
+            : []),
+    ].join("\n");
+    const boundedOutput = boundText(rawOutput, {
+        maxChars: OUTPUT_CHARACTER_MAX,
+        marker: "\n[available tool brief truncated]",
+    });
+    return Object.freeze({
+        text: boundedOutput.text,
+        collection: boundedTools.metadata,
+        output: boundedOutput.metadata,
+    });
+}
+function formatAvailableTool(tool) {
+    return [
+        `- ${tool.operationId}`,
+        `(tool=${tool.toolName}; effect=${tool.effect}; groups=${tool.catalogGroups.join(",")})`,
+        tool.summary,
+    ].join(" ");
+}
+function compareAvailableTools(left, right) {
+    const byOperation = compareAscii(left.operationId, right.operationId);
+    if (byOperation !== 0)
+        return byOperation;
+    return compareAscii(left.toolName, right.toolName);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/plugin-sdk/tool-availability-overview.d.ts

@@ -0,0 +1,9 @@
+import type { ToolAvailabilityEntry } from "../plugin-contract/entrypoint.js";
+export type ToolAvailabilityOverviewLevel = "detailed" | "titles" | "groups";
+export type ToolAvailabilityOverviewGroup = Readonly<{
+    groupId: string;
+    memberCount: number;
+    effects: readonly string[];
+}>;
+/** Complete informational candidates; callers own admission and context budget. */
+export declare function buildToolAvailabilityOverview(entries: readonly ToolAvailabilityEntry[], groups: readonly ToolAvailabilityOverviewGroup[], level: ToolAvailabilityOverviewLevel): string;