@mupt-ai/dari-gateway 0.1.0 → 0.2.1

package/dist/runtime/provider_stream_outcome.js

@@ -0,0 +1,55 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { scrubSecrets } from "../telemetry/scrub.js";
+export function isProviderFailureMessage(message) {
+    return message.stopReason === "error" || message.stopReason === "aborted";
+}
+export function providerFailureFromEvent(event) {
+    if (isRecord(event.error)) {
+        return isProviderFailureMessage(event.error)
+            ? event.error
+            : providerFailure(stringValue(event.error.errorMessage) ?? stringValue(event.error.message) ?? "Provider request failed.");
+    }
+    return providerFailure(stringValue(event.error) ?? stringValue(event.errorMessage) ?? stringValue(event.message) ?? "Provider request failed.");
+}
+export function providerFailureFromCaught(error) {
+    const failure = providerFailure(caughtErrorMessage(error));
+    if (!isRecord(error))
+        return failure;
+    for (const key of ["statusCode", "status_code", "status", "httpStatus", "code", "error"]) {
+        if (error[key] !== undefined)
+            failure[key] = error[key];
+    }
+    return failure;
+}
+/**
+ * A terminal provider message remains the source of truth for exact usage even
+ * when translating that message into a client protocol response fails.
+ */
+export function providerFailureFromTerminal(error, terminalMessage) {
+    return {
+        ...providerFailureFromCaught(error),
+        ...(typeof terminalMessage.responseId === "string"
+            ? { responseId: terminalMessage.responseId }
+            : {}),
+        ...(isRecord(terminalMessage.usage)
+            ? { usage: terminalMessage.usage }
+            : {}),
+    };
+}
+function caughtErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    return "Provider request failed.";
+}
+export function providerFailure(message) {
+    return { stopReason: "error", errorMessage: message, content: [] };
+}
+export function providerFailureMessage(message) {
+    const detail = stringValue(message.errorMessage);
+    return detail ? scrubSecrets(detail) : "Provider request failed.";
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}

package/dist/runtime/request_tags.d.ts

@@ -0,0 +1,7 @@
+import type { RequestTags } from "../platform/platform.js";
+/**
+ * Parse `X-Dari-Tags: run=r1,trial=3,setting=low` into attribution labels for
+ * the platform's request and usage records. Malformed or oversized headers
+ * are refused rather than silently dropped, so cost is never misattributed.
+ */
+export declare function requestTags(header: string | null): RequestTags;

package/dist/runtime/request_tags.js

@@ -0,0 +1,33 @@
+import { HttpError } from "../http/errors.js";
+const TAGS_MAX_CHARS = 2048;
+const TAGS_MAX_COUNT = 32;
+const TAG_KEY = /^[A-Za-z0-9_.:-]{1,64}$/;
+const TAG_VALUE_MAX_CHARS = 256;
+/**
+ * Parse `X-Dari-Tags: run=r1,trial=3,setting=low` into attribution labels for
+ * the platform's request and usage records. Malformed or oversized headers
+ * are refused rather than silently dropped, so cost is never misattributed.
+ */
+export function requestTags(header) {
+    const tags = {};
+    if (header === null || header.trim() === "")
+        return tags;
+    if (header.length > TAGS_MAX_CHARS)
+        throw invalidTags(`X-Dari-Tags exceeds ${TAGS_MAX_CHARS} characters.`);
+    const pairs = header.split(",");
+    if (pairs.length > TAGS_MAX_COUNT)
+        throw invalidTags(`X-Dari-Tags has more than ${TAGS_MAX_COUNT} tags.`);
+    for (const pair of pairs) {
+        const separator = pair.indexOf("=");
+        const key = pair.slice(0, separator).trim();
+        const value = pair.slice(separator + 1).trim();
+        if (separator < 0 || !TAG_KEY.test(key) || value.length > TAG_VALUE_MAX_CHARS) {
+            throw invalidTags("X-Dari-Tags must be comma-separated key=value pairs.");
+        }
+        tags[key] = value;
+    }
+    return tags;
+}
+function invalidTags(message) {
+    return new HttpError(400, message, "invalid_tags");
+}

package/dist/runtime/routed_completion.d.ts

@@ -0,0 +1,17 @@
+import { type InteractionRequest } from "../interaction/types.js";
+import type { SelectorBackend } from "../strategies/routing.js";
+import type { ClientHarness } from "../types.js";
+import type { HarnessConversationIdentity } from "./harness_identity/index.js";
+import type { RoutedProtocol } from "./routed_protocol.js";
+export declare function handleRoutedCompletion(args: {
+    request: Request;
+    routerId: string;
+    apiKey: string;
+    payload: InteractionRequest;
+    responseBody: RoutedProtocol["responseBody"];
+    streamBody: RoutedProtocol["streamBody"];
+    errorResponse: (error: unknown) => Response;
+    selectorBackend: SelectorBackend;
+    clientHarness?: ClientHarness;
+    harnessConversationIdentity?: HarnessConversationIdentity;
+}): Promise<Response>;

package/dist/runtime/routed_completion.js

@@ -0,0 +1,80 @@
+import { randomUUID } from "node:crypto";
+import { isBackgroundRequest } from "../interaction/types.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
+import { captureRequestError } from "../observability/errors.js";
+import { assertAutoroutingAllowed, assertCreditAvailableBeforeRouting, routerSelectsModels } from "../telemetry/usage.js";
+import { prepareRoutedCompletion } from "./prepare_routed_completion.js";
+import { runPreparedRoutedCompletion } from "./routed_runtime.js";
+export async function handleRoutedCompletion(args) {
+    const requestId = randomUUID();
+    const clientRequestId = normalizedClientRequestId(args.request.headers.get("x-request-id"));
+    const receivedAt = new Date();
+    const startedMs = Date.now();
+    const prepared = await prepareRoutedCompletion({
+        routerId: args.routerId,
+        apiKey: args.apiKey,
+        interaction: args.payload,
+        protocol: { responseBody: args.responseBody, streamBody: args.streamBody },
+        receivedAt,
+        startedMs,
+        requestId,
+        clientRequestId,
+        tagsHeader: args.request.headers.get("x-dari-tags"),
+        clientHarness: args.clientHarness,
+        harnessConversationIdentity: args.harnessConversationIdentity,
+    }).catch((error) => ({ error }));
+    if ("error" in prepared) {
+        const response = args.errorResponse(prepared.error);
+        captureRequestError(prepared.error, {
+            request: args.request,
+            routerId: args.routerId,
+            requestId,
+            sourceProtocol: args.payload.sourceProtocol,
+            status: response.status,
+        });
+        return responseWithRequestId(response, requestId);
+    }
+    try {
+        // Only auto-selection needs the plan: an explicitly requested model and
+        // background work are served without the selector.
+        const selects = prepared.credentials.strict !== true &&
+            explicitModelId(prepared.interaction.model) === null &&
+            !isBackgroundRequest(prepared.interaction) &&
+            routerSelectsModels(prepared.credentials);
+        assertAutoroutingAllowed(prepared.credentials, selects);
+        assertCreditAvailableBeforeRouting(prepared.billable, prepared.credentials);
+        const response = await runPreparedRoutedCompletion({
+            prepared,
+            selectorBackend: args.selectorBackend,
+            clientSignal: args.request.signal,
+        });
+        return responseWithRequestId(response, requestId);
+    }
+    catch (error) {
+        const terminal = prepared.reporter.freezeFailure(error);
+        terminal.report();
+        let response = args.errorResponse(error);
+        // Provider retries may already have consumed tokens before the HTTP error.
+        // Return the same model-only cost as successful OpenAI-compatible responses.
+        if (args.payload.sourceProtocol === "openai_chat") {
+            const body = await response.json();
+            response = Response.json({ ...body, usage: { cost: prepared.reporter.modelCost() } }, { status: response.status, headers: response.headers });
+        }
+        captureRequestError(error, {
+            request: args.request,
+            routerId: prepared.routerId,
+            requestId,
+            sourceProtocol: args.payload.sourceProtocol,
+            status: response.status,
+        });
+        return responseWithRequestId(response, requestId);
+    }
+}
+function normalizedClientRequestId(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized.slice(0, 200) : null;
+}
+function responseWithRequestId(response, requestId) {
+    response.headers.set("X-Request-Id", requestId);
+    return response;
+}

package/dist/runtime/routed_protocol.d.ts

@@ -0,0 +1,30 @@
+import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import type { InteractionOutput, InteractionRequest, ProviderIdentity } from "../interaction/types.js";
+import type { ProviderStreamOutcome } from "./provider_stream_outcome.js";
+export type RoutedCompletionResponseArgs = {
+    id: string;
+    model: string;
+    output: InteractionOutput;
+    modelCost?: number | null;
+    request: InteractionRequest;
+    routing: RoutingDecision;
+    conversationId?: string;
+};
+export type RoutedCompletionStreamArgs = {
+    id: string;
+    model: string;
+    routing: RoutingDecision;
+    events: AsyncIterable<Record<string, unknown>>;
+    source: ProviderIdentity;
+    request: InteractionRequest;
+    conversationId?: string;
+    onFinal?: (outcome: ProviderStreamOutcome) => void;
+    modelCost?: (message: Record<string, unknown>, failed: boolean) => number | null;
+    beforeClose?: (outcome: ProviderStreamOutcome) => Promise<void> | void;
+    clientSignal?: AbortSignal;
+    onAbort?: () => void;
+};
+export type RoutedProtocol = {
+    responseBody: (args: RoutedCompletionResponseArgs) => Record<string, unknown>;
+    streamBody: (args: RoutedCompletionStreamArgs) => ReadableStream<Uint8Array>;
+};

package/dist/runtime/routed_protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/routed_runtime.d.ts

@@ -0,0 +1,40 @@
+import { type PreviousDecision, type RouterPrefixHit, type RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import type { InteractionRequest } from "../interaction/types.js";
+import { type CompletedNonStreamingExecution } from "../providers/execution.js";
+import type { SelectorBackend } from "../strategies/routing.js";
+import type { ResolvedRouter } from "../types.js";
+import type { PreparedRoutedCompletion } from "./prepare_routed_completion.js";
+import { type RoutedRuntimeReporter } from "./runtime_reporter.js";
+export type RoutedRuntimeResult = {
+    routing: RoutingDecision;
+    output: CompletedNonStreamingExecution["output"];
+    prefixHit?: RouterPrefixHit;
+};
+export declare class RoutedRuntimeProviderSettledError extends Error {
+    readonly name = "RoutedRuntimeProviderSettledError";
+    readonly runtimeResult: RoutedRuntimeResult;
+    readonly cause: unknown;
+    constructor(message: string, runtimeResult: RoutedRuntimeResult, cause: unknown);
+}
+export type ExplicitRoutedInteractionArgs = {
+    routerId: string;
+    interaction: InteractionRequest;
+    credentials: ResolvedRouter;
+    selectorBackend: SelectorBackend;
+    previousDecision?: PreviousDecision;
+    billable?: boolean;
+    reporter?: RoutedRuntimeReporter;
+};
+export type { SelectorAdapter, SelectorAdapterArgs, SelectorBackend, SelectorRun, } from "../strategies/routing.js";
+export type { ExperimentRoutedRuntimeReporter, RoutedRuntimeReporter, } from "./runtime_reporter.js";
+export { createExperimentRoutedRuntimeReporter } from "./runtime_reporter.js";
+export declare function runPreparedRoutedCompletion(args: {
+    prepared: PreparedRoutedCompletion;
+    selectorBackend: SelectorBackend;
+    clientSignal?: AbortSignal;
+}): Promise<Response>;
+export declare function runPreparedRoutedInteraction(args: {
+    prepared: PreparedRoutedCompletion;
+    selectorBackend: SelectorBackend;
+}): Promise<RoutedRuntimeResult>;
+export declare function runExplicitRoutedInteraction(args: ExplicitRoutedInteractionArgs): Promise<RoutedRuntimeResult>;