@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/observability/errors.d.ts

@@ -0,0 +1,8 @@
+import { type OperationalErrorContext, type RequestErrorContext } from "../platform/platform.js";
+export type { OperationalErrorCode } from "../platform/platform.js";
+export declare function captureRequestError(error: unknown, context: RequestErrorContext): void;
+/**
+ * Report failures deliberately caught outside the ingress exception path,
+ * including work after a response has started and process shutdown.
+ */
+export declare function captureOperationalError(error: unknown, context: OperationalErrorContext): void;

package/dist/observability/errors.js

@@ -0,0 +1,11 @@
+import { gatewayPlatform, } from "../platform/platform.js";
+export function captureRequestError(error, context) {
+    gatewayPlatform().captureRequestError(error, context);
+}
+/**
+ * Report failures deliberately caught outside the ingress exception path,
+ * including work after a response has started and process shutdown.
+ */
+export function captureOperationalError(error, context) {
+    gatewayPlatform().captureOperationalError(error, context);
+}

package/dist/platform/platform.d.ts

@@ -0,0 +1,152 @@
+import type { Provider, ReasoningEffort, RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
+import type { HarnessConversationIdentity } from "../runtime/harness_identity/index.js";
+import type { InteractionRequest, SourceProtocol } from "../interaction/types.js";
+import type { SubscriptionUsageLimit } from "../providers/subscription_limits.js";
+import type { ClientHarness, ProviderCredential, ProviderKeySource, ResolvedRouter } from "../types.js";
+/**
+ * Everything the gateway runtime needs from the deployment around it: router
+ * configuration and credentials, durable routing state, accounting sinks, and
+ * error reporting. The self-hosted gateway implements it with a local config
+ * file and SQLite (`self_host/`); other deployments supply their own.
+ *
+ * Methods may throw. Call sites that must not fail a served request catch,
+ * log, and continue.
+ */
+export type GatewayPlatform = {
+    /**
+     * Authenticate the request's key and return the router it may use, with
+     * decrypted provider credentials and the prefix-cache evidence matching
+     * `prefixHashes`. Throws HttpError(401) for an unknown key.
+     */
+    resolveRouter(request: ResolveRouterRequest): Promise<ResolvedRouter>;
+    /**
+     * Optional. Supply the credential for one enabled model of this request,
+     * consulted after `resolveRouter` and before its provider keys (for the
+     * self-hosted gateway, its environment keys), so an embedder can serve
+     * per-tenant keys from its own store. Undefined keeps the resolved key.
+     */
+    resolveProviderCredential?(request: ProviderCredentialRequest): Promise<ProviderCredential | undefined>;
+    /** Persist one completed turn's prefix entry and/or refresh a read entry. */
+    writePrefixState(write: PrefixStateWrite): Promise<void>;
+    /** Set or clear a conversation's prefetched routing lease. */
+    writePendingLease(write: PendingLeaseWrite): Promise<void>;
+    /**
+     * Hold an exhausted personal subscription until it resets. Resolves whether
+     * another connected subscription for the same provider can serve a retry.
+     */
+    markSubscriptionUnavailable(hold: SubscriptionHold): Promise<boolean>;
+    /**
+     * Account one call served on a platform-managed provider key. Only reached
+     * when `resolveRouter` reports a "managed" key source.
+     */
+    recordUsage(usage: Record<string, unknown>): Promise<void>;
+    /** Receive the finished request's log row. Must not throw. */
+    recordRequest(record: RequestRecord): void;
+    captureRequestError(error: unknown, context: RequestErrorContext): void;
+    captureOperationalError(error: unknown, context: OperationalErrorContext): void;
+};
+export type ResolveRouterRequest = {
+    routerId: string;
+    apiKey: string;
+    prefixHashes?: string[];
+    conversationId?: string;
+    includePublicEvalCatalog?: boolean;
+    clientHarness?: ClientHarness;
+};
+export type ProviderCredentialRequest = {
+    provider: Provider;
+    model: string;
+    routerId: string;
+    organizationId: string;
+    apiKey: string;
+};
+export type PrefixStateWrite = {
+    organization_id: string;
+    router_id: string;
+    received_at: string;
+    zdr: boolean;
+    prefix_entry: Record<string, unknown> | null;
+    touched_prefix_hash: string | null;
+};
+export type PendingLeaseWrite = {
+    router_id: string;
+    conversation_id: string;
+    decided_at_depth: number;
+    pending_lease: {
+        model: string;
+        reasoning_effort: string;
+        turns: number;
+        reason: string;
+        output_text: string | null;
+    } | null;
+};
+export type SubscriptionHold = {
+    userId: string;
+    credentialId: string | undefined;
+    limit: SubscriptionUsageLimit;
+};
+export type RequestRecord = {
+    row: Record<string, unknown>;
+    summary: RequestSummary;
+    distinctId: string;
+    interaction: InteractionRequest;
+    isNewConversation: boolean;
+    zdr: boolean;
+    harnessConversationIdentity?: HarnessConversationIdentity;
+    tags: RequestTags;
+};
+export type RequestTags = Record<string, string>;
+export type RequestSummary = {
+    request_id: string;
+    organization_id: string;
+    router_id: string;
+    api_key_id: string | null;
+    source_protocol: SourceProtocol;
+    request_kind: "user_message" | "tool_continuation" | "other";
+    status: "completed" | "provider_error" | "selector_error" | "aborted";
+    error_code: string | null;
+    stream: boolean;
+    zdr: boolean;
+    strategy: RoutingStrategy;
+    selected_model: string | null;
+    selected_provider: Provider | null;
+    selected_reasoning_effort: ReasoningEffort | null;
+    next_model: string | null;
+    next_reasoning_effort: ReasoningEffort | null;
+    fallback_model: string | null;
+    fallback_reasoning_effort: ReasoningEffort | null;
+    provider_key_source: ProviderKeySource | null;
+    message_count: number;
+    tool_count: number;
+    candidate_count: number;
+    provider_attempt_count: number;
+    prefix_match_depth: number | null;
+    prefix_warm_tokens: number | null;
+    selector_latency_ms: number | null;
+    provider_latency_ms: number | null;
+    total_latency_ms: number;
+    input_tokens: number | null;
+    cache_read_tokens: number | null;
+    cache_write_tokens: number | null;
+    output_tokens: number | null;
+    total_tokens: number | null;
+    total_cost_usd: number | null;
+    cost_source: "provider" | "pricing" | null;
+    pricing_known: boolean | null;
+};
+export type RequestErrorContext = {
+    request: Request;
+    routerId: string;
+    requestId?: string;
+    sourceProtocol: SourceProtocol | "openai_models" | "anthropic_models";
+    status: number;
+};
+export type OperationalErrorCode = "background_drain_timeout" | "billing_usage_report_failed" | "routing_report_assembly_failed" | "routing_report_barrier_failed" | "server_force_stop_failed" | "stream_report_finalization_failed" | "subscription_unavailable_ingest_failed";
+export type OperationalErrorContext = {
+    code: OperationalErrorCode;
+    requestId?: string;
+    routerId?: string;
+};
+/** Bind the platform every request uses. The latest binding wins. */
+export declare function bindGatewayPlatform(platform: GatewayPlatform): void;
+export declare function gatewayPlatform(): GatewayPlatform;

package/dist/platform/platform.js

@@ -0,0 +1,11 @@
+let bound = null;
+/** Bind the platform every request uses. The latest binding wins. */
+export function bindGatewayPlatform(platform) {
+    bound = platform;
+}
+export function gatewayPlatform() {
+    if (bound === null) {
+        throw new Error("No gateway platform is bound; create the request handler first.");
+    }
+    return bound;
+}

package/dist/platform/routing_contract.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ROUTER_ALIAS = "default";
+export declare const ROUTING_PREFIX_HASHES_MAX_COUNT = 200;

package/dist/platform/routing_contract.js

@@ -0,0 +1,5 @@
+// Stable public identity for the standard /v1 router. Platforms resolve it
+// to the caller's default router.
+export const DEFAULT_ROUTER_ALIAS = "default";
+// The most prefix hashes one router resolution looks up.
+export const ROUTING_PREFIX_HASHES_MAX_COUNT = 200;

package/dist/protocol/input/anthropic_messages.d.ts

@@ -0,0 +1,2 @@
+import type { InteractionRequest } from "../../interaction/types.js";
+export declare function anthropicMessagesToInteraction(payload: Record<string, unknown>): InteractionRequest;