@mupt-ai/dari-gateway 0.3.2 → 0.3.4

package/dist/protocol/input/openai_responses.js

@@ -5,6 +5,7 @@ import { parseDataImageUrl } from "../../interaction/image.js";
 import { decodeUntrustedProviderContinuationState } from "../../interaction/provider_continuation_state.js";
 import { CANONICAL_ROUTER_MODEL, explicitModelId, unsupportedModelMessage } from "./router_model.js";
 import { isProtocolToolCallId, TOOL_CALL_ID_MAX_LENGTH, toolsByWireName, } from "../../interaction/tool_identity.js";
+import { parsePdfDataUrl } from "../../interaction/document.js";
 const UNSUPPORTED_INPUT_ITEM_TYPES = new Set([
     "additional_tools",
     "agent_message",
@@ -388,6 +389,13 @@ function responseContent(value, param) {
                 ...(detail !== undefined ? { detail } : {}),
             };
         }
+        if (part.type === "input_file") {
+            const data = typeof part.file_data === "string" ? parsePdfDataUrl(part.file_data) : undefined;
+            if (data === undefined) {
+                throw new HttpError(400, "Responses input_file parts must carry a base64 PDF data URL in file_data; file_id and file_url are not supported.", "unsupported_file_source", `${param}.${index}`);
+            }
+            return { type: "document", mimeType: "application/pdf", data };
+        }
         throw new HttpError(400, `Responses content part type '${String(part.type ?? "unknown")}' is not supported.`, "unsupported_response_content", `${param}.${index}.type`);
     });
 }

package/dist/protocol/output/anthropic_messages_output.js

@@ -51,6 +51,13 @@ export function anthropicContent(output) {
                 content.push({ type: "text", text: `Referenced tool: ${part.toolName}` });
                 continue;
             }
+            if (part.type === "document") {
+                content.push({
+                    type: "document",
+                    source: { type: "base64", media_type: part.mimeType, data: part.data },
+                });
+                continue;
+            }
             const image = parseDataImageUrl(part.url);
             if (!image)
                 throw new Error("Anthropic output images must use base64 data URLs.");

package/dist/providers/key_check.d.ts

@@ -0,0 +1,31 @@
+/**
+ * - `valid`: the provider accepted the key.
+ * - `rejected`: the provider refused it (401 or 403).
+ * - `unchecked`: no answer either way, such as a network error, an outage, or
+ *   a provider without a known check. Callers treat this as not rejected so a
+ *   provider outage never blocks a key.
+ */
+export type ProviderKeyCheckResult = {
+    result: "valid";
+} | {
+    result: "rejected";
+    status: number;
+} | {
+    result: "unchecked";
+};
+export type ProviderKeyEndpoint = {
+    api: string;
+    baseUrl: string;
+};
+/**
+ * Ask a provider whether an API key works, with the cheapest authenticated
+ * request its wire API offers: list models, or, where listing models needs
+ * no key, an endpoint that does. The self-hosted gateway runs this at startup
+ * and the hosted control plane before it saves a key.
+ */
+export declare function checkProviderKey(args: {
+    provider: string;
+    key: string;
+    endpoint?: ProviderKeyEndpoint;
+    fetch: typeof fetch;
+}): Promise<ProviderKeyCheckResult>;

package/dist/providers/key_check.js

@@ -0,0 +1,54 @@
+import { getBuiltinModels } from "@mupt-ai/pi-ai/providers/all";
+const CHECK_TIMEOUT_MS = 10_000;
+/**
+ * Ask a provider whether an API key works, with the cheapest authenticated
+ * request its wire API offers: list models, or, where listing models needs
+ * no key, an endpoint that does. The self-hosted gateway runs this at startup
+ * and the hosted control plane before it saves a key.
+ */
+export async function checkProviderKey(args) {
+    const check = keyCheckRequest(args.provider, args.key, args.endpoint);
+    if (check === null)
+        return { result: "unchecked" };
+    try {
+        const response = await args.fetch(check.url, {
+            headers: check.headers,
+            signal: AbortSignal.timeout(CHECK_TIMEOUT_MS),
+        });
+        await response.body?.cancel();
+        if (response.status === 401 || response.status === 403) {
+            return { result: "rejected", status: response.status };
+        }
+        return response.ok ? { result: "valid" } : { result: "unchecked" };
+    }
+    catch {
+        return { result: "unchecked" };
+    }
+}
+function keyCheckRequest(provider, key, endpoint) {
+    const bearer = { authorization: `Bearer ${key}` };
+    if (endpoint === undefined) {
+        if (provider === "openrouter")
+            return { url: "https://openrouter.ai/api/v1/key", headers: bearer };
+        if (provider === "vercel-ai-gateway")
+            return { url: "https://ai-gateway.vercel.sh/v1/credits", headers: bearer };
+    }
+    const target = endpoint
+        ?? getBuiltinModels(provider)?.[0];
+    if (target === undefined || !URL.canParse(target.baseUrl))
+        return null;
+    const base = target.baseUrl.replace(/\/+$/, "");
+    switch (target.api) {
+        case "anthropic-messages":
+            return { url: `${base}/v1/models`, headers: { "x-api-key": key, "anthropic-version": "2023-06-01" } };
+        case "google-generative-ai":
+            return { url: `${base}/models`, headers: { "x-goog-api-key": key } };
+        case "mistral-conversations":
+            return { url: `${base}/v1/models`, headers: bearer };
+        case "openai-completions":
+        case "openai-responses":
+            return { url: `${base}/models`, headers: bearer };
+        default:
+            return null;
+    }
+}

package/dist/providers/model_capabilities.d.ts

@@ -4,6 +4,8 @@ type ModelCapabilityMetadata = {
 export declare const BEDROCK_API = "bedrock-converse-stream";
 export declare function isBedrockApi(api: unknown): boolean;
 export declare function modelSupportsImageInput(metadata: ModelCapabilityMetadata): boolean;
+export declare function apiSupportsDocumentInput(api: string): boolean;
+export declare function modelSupportsDocumentInput(modelId: string, metadata: ModelCapabilityMetadata): boolean;
 export declare function providerApiCanSerializeResponseFormat(metadata: ModelCapabilityMetadata): boolean;
 export declare function isOpenAIResponsesApi(api: unknown): boolean;
 export declare function modelSupportsReasoningConfigurationUpdate(metadata: ModelCapabilityMetadata): boolean;

package/dist/providers/model_capabilities.js

@@ -6,6 +6,21 @@ export function isBedrockApi(api) {
 export function modelSupportsImageInput(metadata) {
     return Array.isArray(metadata.model.input) && metadata.model.input.includes("image");
 }
+/* PDFs are sent natively only where the model owner documents PDF input on
+   that API. The same API can serve other owners (xAI and Meta on Responses,
+   GPT on Bedrock) whose PDF support is unverified, so both must match. */
+const DOCUMENT_INPUT_APIS_BY_OWNER = {
+    anthropic: new Set(["anthropic-messages", "bedrock-converse-stream"]),
+    openai: new Set(["openai-responses", "azure-openai-responses", "openai-codex-responses"]),
+};
+export function apiSupportsDocumentInput(api) {
+    return Object.values(DOCUMENT_INPUT_APIS_BY_OWNER).some((apis) => apis.has(api));
+}
+export function modelSupportsDocumentInput(modelId, metadata) {
+    const owner = modelId.split("/", 1)[0] ?? "";
+    const api = metadata.model.api;
+    return typeof api === "string" && DOCUMENT_INPUT_APIS_BY_OWNER[owner]?.has(api) === true;
+}
 export function providerApiCanSerializeResponseFormat(metadata) {
     return (metadata.model.api === "openai-responses" ||
         metadata.model.api === "azure-openai-responses" ||

package/dist/providers/pi_context.js

@@ -5,6 +5,7 @@ import { parseDataImageUrl } from "../interaction/image.js";
 import { providerToolCallId, toolWireName } from "../interaction/tool_identity.js";
 import { compatibleProviderContinuation, sameProviderIdentity, } from "../interaction/provider_continuation_state.js";
 import { isOpenAIResponsesApi } from "./model_capabilities.js";
+import { apiSupportsDocumentInput } from "./model_capabilities.js";
 const UNKNOWN_SOURCE = {
     provider: "dari",
     api: "interaction-history",
@@ -72,7 +73,7 @@ export function buildContext(request, target) {
         sawConversationItem = true;
         if (item.type === "message" && item.role === "user") {
             flushAssistant();
-            appendUserMessage(messages, userContent(item.content, item.contentShape), timestamp);
+            appendUserMessage(messages, userContent(item.content, item.contentShape, target), timestamp);
             continue;
         }
         if (item.type === "tool_result") {
@@ -252,10 +253,10 @@ function thinkingContent(item, continuation) {
         redacted: true,
     };
 }
-function userContent(content, shape) {
+function userContent(content, shape, target) {
     if (shape !== "parts")
         return content.filter((part) => part.type === "text").map((part) => part.text).join("");
-    return content.map(contentToPi);
+    return content.map((part) => contentToPi(part, target));
 }
 function appendPositionalNote(messages, text, timestamp) {
     const previous = messages.at(-1);
@@ -290,13 +291,20 @@ function toolResultContent(content, target) {
     const filtered = target.api === "anthropic-messages"
         ? content.filter((part) => part.type !== "tool_reference")
         : content;
-    return filtered.map(contentToPi);
+    return filtered.map((part) => contentToPi(part, target));
 }
-function contentToPi(content) {
+function contentToPi(content, target) {
     if (content.type === "text")
         return { type: "text", text: content.text };
     if (content.type === "tool_reference")
         return { type: "text", text: `Referenced tool: ${content.toolName}` };
+    if (content.type === "document") {
+        // Routing keeps PDFs on document-capable models; this guards direct callers.
+        if (!apiSupportsDocumentInput(target.api)) {
+            throw new HttpError(400, `PDF document input is not supported by the ${target.api} API.`, "unsupported_input_modality", "input.document");
+        }
+        return { type: "document", mimeType: content.mimeType, data: content.data };
+    }
     const image = parseDataImageUrl(content.url);
     if (!image) {
         throw new HttpError(400, "Only base64 data URLs are supported for routed image input.", "invalid_request_error", "input.image_url");

package/dist/runtime/harness_identity/conversation.d.ts

@@ -13,6 +13,10 @@ export type HarnessConversationIdentity = {
     kind: "openai_chat_session";
     value: string;
     qualifiers?: string[];
+} | {
+    kind: "muse_code_thread";
+    value: string;
+    qualifiers?: string[];
 };
 export type HarnessConversationScope = {
     organizationId: string;

package/dist/runtime/harness_identity/extract.d.ts

@@ -6,4 +6,5 @@ export declare function openCodeRequestContext(headers: Headers): AgentRequestCo
 export declare function codexConversationIdentity(headers: Headers, payload: Record<string, unknown>): HarnessConversationIdentity | undefined;
 export declare function codexRequestPurpose(headers: Headers, payload: Record<string, unknown>): InteractionRequestPurpose | undefined;
 export declare function codexRequestContext(headers: Headers, payload: Record<string, unknown>): AgentRequestContext | undefined;
+export declare function museCodeConversationIdentity(headers: Headers): HarnessConversationIdentity | undefined;
 export declare function claudeCodeConversationIdentity(headers: Headers, metadataSessionId?: string): HarnessConversationIdentity | undefined;

package/dist/runtime/harness_identity/extract.js

@@ -129,6 +129,13 @@ export function codexRequestContext(headers, payload) {
         agentType: boundedIdentity(agentKind, "x-codex-turn-metadata.subagent_kind"),
     };
 }
+// Muse Code sends its thread on every Responses request. The main agent's
+// thread is its session, and each subagent has its own thread, so each keeps
+// its own conversation and lease.
+export function museCodeConversationIdentity(headers) {
+    const threadId = boundedIdentity(headers.get("x-tbh-thread-id"), "x-tbh-thread-id");
+    return threadId === undefined ? undefined : { kind: "muse_code_thread", value: threadId };
+}
 export function claudeCodeConversationIdentity(headers, metadataSessionId) {
     const candidates = [
         uuidIdentity(headers.get("x-claude-code-session-id"), "x-claude-code-session-id"),

package/dist/runtime/harness_identity/index.d.ts

@@ -1,2 +1,2 @@
 export { scopedHarnessAgentId, scopedHarnessConversationId, scopedHarnessSessionId, type HarnessConversationIdentity, type HarnessConversationScope, } from "./conversation.js";
-export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, openCodeRequestContext, piRequestContext, } from "./extract.js";
+export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, museCodeConversationIdentity, openCodeRequestContext, piRequestContext, } from "./extract.js";

package/dist/runtime/harness_identity/index.js

@@ -1,2 +1,2 @@
 export { scopedHarnessAgentId, scopedHarnessConversationId, scopedHarnessSessionId, } from "./conversation.js";
-export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, openCodeRequestContext, piRequestContext, } from "./extract.js";
+export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, museCodeConversationIdentity, openCodeRequestContext, piRequestContext, } from "./extract.js";

package/dist/runtime/prepare_routed_completion.js

@@ -1,4 +1,6 @@
 import { interactionConversationPrefix } from "../context/interaction_fingerprint.js";
+import { clampRequestedEffort } from "../context/routing_context.js";
+import { modelMetadataLookup } from "../providers/pi.js";
 import { buildRoutingContext, derivePrefixLookupHashes, } from "../context/routing_context.js";
 import { isBackgroundRequest } from "../interaction/types.js";
 import { executionProviderForModel } from "../models/execution_provider.js";
@@ -84,7 +86,10 @@ export async function prepareRoutedCompletion(args) {
     }
     const access = strictProviderAccess(credentials, args.interaction);
     credentials = access.credentials;
-    args = { ...args, interaction: access.interaction };
+    args = {
+        ...args,
+        interaction: clampRequestedEffort(access.interaction, credentials, modelMetadataLookup(credentials.model_configs)),
+    };
     credentials = await withProviderCredentials(credentials, args.apiKey, args.clientHarness);
     const billable = true;
     const routing = await buildRoutingContext({
@@ -138,6 +143,8 @@ export async function prepareRoutedCompletion(args) {
         identityHit: routing.identityHit,
         hits: routing.hits,
         costEstimates: routing.reportingCostEstimates,
+        candidates: candidateResolution.candidates,
+        sessionPinKey: sessionPin?.key,
         pruning: reportedPruning(candidateResolution.pruning, routing.imageCapabilityPrunedModels),
         pricing: routing.pricing,
         chainByModel: routing.prefix.chainByModel,

package/dist/self_host/config.d.ts

@@ -7,7 +7,7 @@ import { type ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
  *   default:
  *     models:
  *       - anthropic/claude-sonnet-5-5
- *       - id: openai/gpt-5.5
+ *       - id: openai/gpt-6.1-sol
  *         thinking: [medium, high]
  *     subscriptions: true   # serve with connected Claude Code / ChatGPT plans
  *     sessionPinning: false # route each session and subagent once, then keep its model

package/dist/self_host/config.js

@@ -5,7 +5,8 @@ const MODEL_ID_PATTERN = /^[a-z0-9][a-z0-9.-]*\/\S+$/;
 export async function loadGatewayConfig(path) {
     const file = Bun.file(path);
     if (!(await file.exists())) {
-        throw new Error(`Gateway config not found at ${path}.`);
+        throw new Error(`Gateway config not found at ${path}. Write one from dari-gateway.example.yaml, `
+            + "or set DARI_GATEWAY_CONFIG (in the container image, mount it at /config/dari-gateway.yaml).");
     }
     const text = await file.text();
     const raw = path.endsWith(".json") ? JSON.parse(text) : Bun.YAML.parse(text);

package/dist/self_host/main.js

@@ -8,9 +8,11 @@ import { createRequestHandler } from "../http/handler.js";
 import { installShutdownHandlers, startServer } from "../http/serve.js";
 import { createAutoRoutingSelectorBackend } from "../strategies/auto_routing_selector.js";
 import { createPrioritySelectorBackend } from "../strategies/priority_selector.js";
-import { loadGatewayConfig } from "./config.js";
 import { createSelfHostedPlatform } from "./platform.js";
-import { gatewayKeyIndex, providersWithoutCredentials } from "./resolve.js";
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+import { checkProviderKey } from "../providers/key_check.js";
+import { loadGatewayConfig } from "./config.js";
+import { configuredProviderApiKey, gatewayKeyIndex, providersWithoutCredentials } from "./resolve.js";
 import { PrefixStore } from "./prefix_store.js";
 import { SessionPinStore } from "./session_pin_store.js";
 import { handleSubscriptionRequest, SubscriptionStore } from "./subscriptions/index.js";
@@ -69,6 +71,7 @@ export async function startSelfHostedGateway(env = process.env) {
             console.warn("dari-gateway router has providers without credentials; their models are not served", JSON.stringify({ router: routerId, providers: missing }));
         }
     }
+    await checkConfiguredProviderKeys(config, (provider) => configuredProviderApiKey({ config, providerApiKey, env }, provider));
     const autoRoutingKey = env.DARI_AUTO_ROUTING_API_KEY?.trim();
     const selectorBackend = autoRoutingKey
         ? createAutoRoutingSelectorBackend({
@@ -99,13 +102,43 @@ export async function startSelfHostedGateway(env = process.env) {
     const server = startServer(port, handler, { hostname });
     console.info("dari-gateway listening", JSON.stringify({
         hostname,
-        port,
+        // The bound port, so PORT=0 reports the port the OS assigned.
+        port: server.port,
         routers: Object.keys(config.routers),
         auto_routing: autoRoutingKey ? "dari" : "priority",
     }));
     return { server, close: () => db.close() };
 }
+/**
+ * Check each provider API key the routers use before serving: a key its
+ * provider rejects fails startup, and one no check could answer is reported.
+ */
+async function checkConfiguredProviderKeys(config, providerApiKey) {
+    const providers = new Set(Object.values(config.routers).flatMap((router) => router.models.map((model) => providerForModel(model.id))));
+    const checks = await Promise.all([...providers].map(async (provider) => {
+        const endpoint = config.providers[provider];
+        // Endpoints configured without a key variable take no key.
+        if (endpoint !== undefined && endpoint.apiKeyEnv === undefined)
+            return null;
+        const key = await providerApiKey(provider);
+        if (key === undefined)
+            return null;
+        return { provider, ...(await checkProviderKey({ provider, key, ...(endpoint ? { endpoint } : {}), fetch })) };
+    }));
+    const rejected = checks.flatMap((check) => check?.result === "rejected" ? [`${check.provider} (${check.status})`] : []);
+    if (rejected.length > 0) {
+        throw new Error(`Provider API keys were rejected: ${rejected.join(", ")}. Fix or unset each key before starting the gateway.`);
+    }
+    const unchecked = checks.flatMap((check) => check?.result === "unchecked" ? [check.provider] : []);
+    if (unchecked.length > 0) {
+        console.warn("dari-gateway could not check these provider API keys", JSON.stringify({ providers: unchecked }));
+    }
+}
 if (import.meta.main) {
-    const { server, close } = await startSelfHostedGateway();
-    installShutdownHandlers(server, async () => close());
+    // Startup errors are configuration mistakes: print the message, not a stack.
+    const started = await startSelfHostedGateway().catch((error) => {
+        console.error(`dari-gateway: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    });
+    installShutdownHandlers(started.server, async () => started.close());
 }

package/dist/self_host/resolve.d.ts

@@ -25,6 +25,7 @@ export type SelfHostedResolverDeps = {
  * neither are left out.
  */
 export declare function resolveSelfHostedRouter(deps: SelfHostedResolverDeps, request: ResolveRouterRequest): Promise<ResolvedRouter>;
+export declare function configuredProviderApiKey(deps: Pick<SelfHostedResolverDeps, "config" | "providerApiKey" | "env">, provider: string): Promise<string | undefined>;
 export declare function gatewayKeyIndex(keys: readonly string[], presented: string): number | null;
 /**
  * Providers a router lists that no credential can serve: no API key and no

package/dist/self_host/resolve.js

@@ -44,7 +44,7 @@ export async function resolveSelfHostedRouter(deps, request) {
         if (subscription !== null && deps.subscriptions.list(subscription).length > 0) {
             exhausted.add(subscription);
         }
-        const apiKey = await providerApiKey(deps, provider);
+        const apiKey = await configuredProviderApiKey(deps, provider);
         credentials.set(provider, apiKey ? { key: apiKey, source: "user" } : null);
     }
     const models = router.models.filter((model) => credentials.get(providerForModel(model.id)) != null);
@@ -112,7 +112,7 @@ export async function resolveSelfHostedRouter(deps, request) {
 }
 // Configured endpoints read their own key variable, or send a placeholder
 // when they take none; known providers use their standard variable.
-async function providerApiKey(deps, provider) {
+export async function configuredProviderApiKey(deps, provider) {
     const endpoint = deps.config.providers[provider];
     if (endpoint === undefined)
         return (await deps.providerApiKey(provider))?.trim() || undefined;
@@ -172,7 +172,7 @@ export async function providersWithoutCredentials(deps, router) {
         const connected = plans.some((plan) => plan !== null && deps.subscriptions.list(plan).length > 0);
         if (connected)
             continue;
-        const apiKey = await providerApiKey(deps, provider);
+        const apiKey = await configuredProviderApiKey(deps, provider);
         if (apiKey === undefined)
             missing.push(provider);
     }

package/dist/strategies/selector_projection.js

@@ -145,6 +145,9 @@ function selectorContentField(content, shape, imagePart) {
             if (part.type === "tool_reference") {
                 return { type: "text", text: `Referenced tool: ${part.toolName}` };
             }
+            // The selector model is text-only; it sees a marker, not the document bytes.
+            if (part.type === "document")
+                return { type: "text", text: "(PDF document omitted from selector input)" };
             return imagePart(part.url, part.detail);
         }),
     };

package/dist/telemetry/report.d.ts

@@ -1,4 +1,4 @@
-import { type CandidateCostEstimate, type CandidatePruningAudit, type ChainHits, type PrefixHit, type PricingLookup, type RoutingDecision, type RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
+import { type CandidateCostEstimate, type CandidatePruningAudit, type ChainHits, type PrefixHit, type PricingLookup, type RoutingCandidate, type RoutingDecision, type RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
 import type { ImageCapabilityPrunedModel } from "../context/routing_context.js";
 import { type InteractionRequest, type ProviderIdentity } from "../interaction/types.js";
 import { type RequestTags } from "../platform/platform.js";
@@ -47,6 +47,8 @@ export declare class RequestReporter {
         identityHit?: PrefixHit;
         hits: ChainHits;
         costEstimates: CandidateCostEstimate[];
+        candidates: readonly RoutingCandidate[];
+        sessionPinKey?: string;
         pruning: ReportedCandidatePruning | null;
         pricing: PricingLookup | null;
         chainByModel: ReadonlyMap<string, string[]>;

package/dist/telemetry/report.js

@@ -414,6 +414,9 @@ export class RequestReporter {
                 touched_prefix_hash: touchedHash,
             };
             gatewayPlatform().recordRequest({
+                router: requestRecordRouter(a.credentials),
+                candidates: a.candidates.map(({ model, reasoningEffort }) => ({ model, reasoningEffort })),
+                ...(a.sessionPinKey === undefined ? {} : { sessionPinKey: a.sessionPinKey }),
                 row: ingestPayload,
                 summary: {
                     request_id: a.requestId,
@@ -583,3 +586,23 @@ function usageIngest(usage, pricingKnown) {
         pricing_known: pricingKnown,
     };
 }
+function requestRecordRouter(router) {
+    return {
+        enabledModels: [...router.enabled_models],
+        thinkingLevels: Object.fromEntries(router.enabled_models.map((model) => [
+            model,
+            [
+                ...(router.model_thinking_levels?.[model]
+                    ?? router.model_configs?.[model]?.supported_thinking_levels
+                    ?? []),
+            ],
+        ])),
+        defaultThinkingLevels: Object.fromEntries(router.enabled_models.flatMap((model) => {
+            const level = router.model_configs?.[model]?.default_thinking_level;
+            return level ? [[model, level]] : [];
+        })),
+        strict: router.strict === true,
+        speculativeRouting: router.speculative_routing === true,
+        sessionPinning: router.session_pinning === true,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mupt-ai/dari-gateway",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Self-hostable LLM gateway for coding agents and APIs: one endpoint for Anthropic Messages, OpenAI Chat Completions, and OpenAI Responses, with subscription pooling, failover, and prompt-cache-aware routing.",
   "license": "Apache-2.0",
   "repository": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@aws-sdk/client-sts": "3.1063.0",
     "@mupt-ai/dari-router": "0.2.5",
-    "@mupt-ai/pi-ai": "1.4.0-mupt.2"
+    "@mupt-ai/pi-ai": "1.4.0-mupt.3"
   },
   "devDependencies": {
     "@types/bun": "^1.3.4",

package/src/context/interaction_fingerprint.ts

@@ -105,7 +105,10 @@ export function interactionLooseChain(routerId: string, request: InteractionRequ
 // unrelated work reusing the same harness session gets a new group.
 export function interactionConversationPrefix(request: InteractionRequest): string {
   const firstStep = conversationFingerprintSteps(
-    looseFingerprintSteps(request.sourceProtocol, request.items),
+    looseFingerprintSteps(
+      request.sourceProtocol,
+      request.items.filter((item) => !isOpenClawRuntimeContext(item)),
+    ),
   ).at(0);
   return sha256(stableStringify({
     version: CONVERSATION_PREFIX_VERSION,
@@ -115,6 +118,17 @@ export function interactionConversationPrefix(request: InteractionRequest): stri
   }));
 }
 
+// OpenClaw appends a user message of runtime context (active exec sessions,
+// subagents) to each request and drops it from later history. On a first
+// turn it merges into the first transcript step, so leaving it in would give
+// the first turn a different conversation than the turns after it.
+const OPENCLAW_RUNTIME_CONTEXT = "<<<BEGIN_OPENCLAW_INTERNAL_CONTEXT>>>";
+
+function isOpenClawRuntimeContext(item: InteractionItem): boolean {
+  return item.type === "message" && item.role === "user" && item.content.length > 0 &&
+    item.content.every((part) => part.type === "text" && part.text.trimStart().startsWith(OPENCLAW_RUNTIME_CONTEXT));
+}
+
 export function interactionPrefixContext(
   routerId: string,
   request: InteractionRequest,

package/src/context/interaction_fingerprint_format.ts

@@ -22,6 +22,7 @@ export type FingerprintContent =
           url: string;
           detail?: "auto" | "low" | "high" | "original";
         }
+      | { type: "document"; mimeType: "application/pdf"; data: string }
       | { type: "tool_reference"; toolName: string }
     >
   | null;
@@ -150,6 +151,9 @@ export function interactionFingerprintContent(
         toolName: part.toolName,
       };
     }
+    if (part.type === "document") {
+      return { type: "document" as const, mimeType: part.mimeType, data: part.data };
+    }
     return {
       type: "image" as const,
       url: part.url,

package/src/context/provider_prompt_accounting.ts

@@ -1,3 +1,5 @@
+import { constants as zlibConstants, inflateSync } from "node:zlib";
+
 import {
   isRecord,
   stableStringify,
@@ -27,6 +29,42 @@ const IMAGE_ESTIMATED_TOKENS = {
   original: 2048,
 } as const;
 const CHARS_PER_ESTIMATED_TOKEN = 4;
+// Anthropic bills each PDF page as its text plus a page image: 1,500-3,000
+// tokens. Use the top of that range so a long PDF cannot look like it fits.
+const PDF_ESTIMATED_TOKENS_PER_PAGE = 3000;
+const PDF_PAGE_PATTERN = /\/Type\s*\/Page(?![a-zA-Z])/g;
+const PDF_OBJECT_STREAM_START = /\/Type\s*\/ObjStm[\s\S]*?stream\r?\n/g;
+// Object streams hold small dictionaries. The cap is total inflated bytes per
+// PDF, so a compression bomb in a request costs at most this much memory.
+const PDF_OBJECT_STREAM_INFLATE_BUDGET = 4 * 1024 * 1024;
+
+function estimatedPdfPages(base64: string): number {
+  const bytes = Buffer.from(base64, "base64");
+  // latin1 maps each byte to one character, so string offsets are byte offsets.
+  const pdf = bytes.toString("latin1");
+  const visible = pdf.match(PDF_PAGE_PATTERN)?.length ?? 0;
+  if (visible > 0) return visible;
+  // PDF 1.5+ may keep every page dictionary in compressed object streams.
+  let hidden = 0;
+  let budget = PDF_OBJECT_STREAM_INFLATE_BUDGET;
+  for (const match of pdf.matchAll(PDF_OBJECT_STREAM_START)) {
+    const start = match.index + match[0].length;
+    const end = pdf.indexOf("endstream", start);
+    if (end === -1 || budget <= 0) break;
+    try {
+      const objects = inflateSync(bytes.subarray(start, end), {
+        finishFlush: zlibConstants.Z_SYNC_FLUSH,
+        maxOutputLength: budget,
+      });
+      budget -= objects.length;
+      hidden += objects.toString("latin1").match(PDF_PAGE_PATTERN)?.length ?? 0;
+    } catch (error) {
+      // Over budget: stop. Another filter or bad data: count what is readable.
+      if (error instanceof RangeError) break;
+    }
+  }
+  return Math.max(1, hidden);
+}
 
 // Cost and cache-lookback estimates are candidate-specific because compatible
 // continuation state and provider serialization can change what each model
@@ -130,7 +168,7 @@ export function promptMetrics(
       0,
     ),
     serializedChars:
-      stableStringify(prompt).length + accountingInput.imageEstimatedChars,
+      stableStringify(prompt).length + accountingInput.attachmentEstimatedChars,
   };
 }
 
@@ -214,14 +252,22 @@ function providerVisibleTools(
 
 function promptAccountingInput(request: InteractionRequest): {
   request: InteractionRequest;
-  imageEstimatedChars: number;
+  attachmentEstimatedChars: number;
 } {
-  let imageEstimatedChars = 0;
-  const sanitizeContent = (parts: InteractionContent[]) =>
+  let attachmentEstimatedChars = 0;
+  // Attachments are estimated rather than serialized: their base64 is not
+  // what the provider bills, and a PDF must not reach the serializer of a
+  // model that cannot carry it.
+  const sanitizeContent = (parts: InteractionContent[]): InteractionContent[] =>
     parts.map((part) => {
+      if (part.type === "document") {
+        attachmentEstimatedChars +=
+          estimatedPdfPages(part.data) * PDF_ESTIMATED_TOKENS_PER_PAGE * CHARS_PER_ESTIMATED_TOKEN;
+        return { type: "text", text: "" };
+      }
       if (part.type !== "image") return part;
       const detail = part.detail ?? "auto";
-      imageEstimatedChars +=
+      attachmentEstimatedChars +=
         IMAGE_ESTIMATED_TOKENS[detail] * CHARS_PER_ESTIMATED_TOKEN;
       return { ...part, url: ACCOUNTING_IMAGE_URL };
     });
@@ -236,6 +282,6 @@ function promptAccountingInput(request: InteractionRequest): {
   });
   return {
     request: { ...request, items },
-    imageEstimatedChars,
+    attachmentEstimatedChars,
   };
 }