@omnicross/core 0.1.10 → 0.2.1

package/dist/types-Dm4_36V4.d.ts

@@ -0,0 +1,196 @@
+import * as _omnicross_contracts_image_generation_types from '@omnicross/contracts/image-generation-types';
+import { ImageArtifactMetadata, ImageRequestOptions } from '@omnicross/contracts/image-generation-types';
+import { I as ImageAsset, p as ImageReferenceLease, K as OpenAIOperationHandler, h as ImageOrchestrator, L as OpenAIOperationHandlerContext, s as ImageReferenceStore, u as ImageRetentionPolicy } from './types-By9Tg6-I.js';
+import { FileHandle } from 'node:fs/promises';
+
+type ResourceKind = 'input' | 'spool';
+declare const IMAGE_REQUEST_DIRECTORY_MARKER_NAME = ".omnicross-images-owner.json";
+declare const IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT = "{\"schema\":\"omnicross-images-temporary\",\"version\":1}\n";
+/** Internal request-scoped file. It deliberately has no path property or getter. */
+declare class StagedTemporaryFile {
+    #private;
+    readonly byteLength: number;
+    constructor(scope: ImageRequestResourceScope, path: string, byteLength: number, kind: ResourceKind);
+    open(signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+    /** Internal validator seam; no path is returned or retained by the caller. */
+    inspect<T>(callback: (privatePath: string) => Promise<T>): Promise<T>;
+    dispose(): Promise<void>;
+    toImageAsset(metadata: Omit<ImageArtifactMetadata, 'artifactId' | 'byteLength' | 'independentlyDecodable'>): TemporaryImageAsset;
+}
+declare class TemporaryImageAsset implements ImageAsset {
+    #private;
+    readonly artifactId: _omnicross_contracts_image_generation_types.ImageArtifactId;
+    readonly mimeType: `image/${string}`;
+    readonly byteLength: number;
+    readonly width: number;
+    readonly height: number;
+    readonly hasAlpha: boolean | undefined;
+    readonly sha256: string | undefined;
+    readonly independentlyDecodable: true;
+    constructor(file: StagedTemporaryFile, metadata: Omit<ImageArtifactMetadata, 'artifactId' | 'byteLength' | 'independentlyDecodable'>);
+    open(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array>>;
+}
+declare class RequestFileWriter {
+    #private;
+    constructor(options: {
+        scope: ImageRequestResourceScope;
+        handle: FileHandle;
+        path: string;
+        kind: ResourceKind;
+        maxBytes: number;
+        declaredBytes?: number;
+    });
+    get byteLength(): number;
+    write(chunk: Uint8Array, signal?: AbortSignal): Promise<void>;
+    finish(): Promise<StagedTemporaryFile>;
+    abort(): Promise<void>;
+}
+interface CreateImageRequestResourceScopeOptions {
+    readonly limits: ImageApiLimits;
+    readonly signal: AbortSignal;
+    readonly tempRoot?: string;
+    /** Trusted tenant identity; required whenever a shared budget is injected. */
+    readonly tenantId?: string;
+    readonly sharedBudget?: ImageTemporaryResourceBudget;
+    /** Write the fixed, content-free daemon ownership marker into the request directory. */
+    readonly ownedDirectoryMarker?: boolean;
+    /** Host-private lease hook used to keep recurring cleanup away from live scopes. */
+    readonly onDirectoryActive?: (privateDirectory: string) => () => void;
+}
+/** One active-scope reservation from the daemon's cross-request budget. */
+interface ImageTemporaryResourceBudgetLease {
+    /** Atomically charge bytes before a write; a thrown call MUST charge nothing. */
+    reserve(bytes: number): void;
+    /** Infallibly release up to the bytes previously reserved by this lease. */
+    release(bytes: number): void;
+    /** Idempotently and infallibly release the active-scope reservation. */
+    releaseScope(): void;
+}
+/** Credential/content-blind shared temporary budget port. */
+interface ImageTemporaryResourceBudget {
+    /** Atomically acquire one active scope for a trusted, non-empty tenant. */
+    acquireScope(tenantId: string): ImageTemporaryResourceBudgetLease;
+}
+interface ImageRequestResourceOwnership {
+    readonly tenantId: string;
+    readonly sharedBudget: ImageTemporaryResourceBudget;
+    readonly ownedDirectoryMarker?: boolean;
+}
+declare class ImageRequestResourceScope {
+    #private;
+    private constructor();
+    static create(options: CreateImageRequestResourceScopeOptions): Promise<ImageRequestResourceScope>;
+    assertActive(): void;
+    reserve(kind: ResourceKind, bytes: number): void;
+    unreserve(kind: ResourceKind, bytes: number): void;
+    writerFinished(writer: RequestFileWriter): void;
+    releaseSpool(privatePath: string, bytes: number): Promise<void>;
+    createWriter(options: {
+        readonly kind: ResourceKind;
+        readonly maxBytes: number;
+        readonly declaredBytes?: number;
+    }): Promise<RequestFileWriter>;
+    materialize(source: AsyncIterable<Uint8Array>, options?: {
+        readonly kind?: ResourceKind;
+        readonly maxBytes?: number;
+        readonly declaredBytes?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<StagedTemporaryFile>;
+    addLease(lease: ImageReferenceLease): void;
+    cleanup(): Promise<void>;
+}
+declare function createImageRequestResourceScope(limits: ImageApiLimits, signal: AbortSignal, tempRoot?: string, ownership?: ImageRequestResourceOwnership): Promise<ImageRequestResourceScope>;
+
+interface ImageApiLimits {
+    readonly maxJsonBytes: number;
+    readonly maxMultipartBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxTotalInputBytes: number;
+    readonly maxFiles: number;
+    readonly maxFields: number;
+    readonly maxParts: number;
+    readonly maxHeaderPairs: number;
+    readonly maxFieldNameBytes: number;
+    readonly maxFieldValueBytes: number;
+    readonly maxPixels: number;
+    readonly maxRawBytes: number;
+    readonly maxOutputBytes: number;
+    readonly maxTotalOutputBytes: number;
+    readonly maxSpoolBytes: number;
+    readonly maxRedirects: number;
+    readonly maxRemoteUrlBytes: number;
+    readonly maxRemoteHeaderBytes: number;
+    readonly remoteConnectTimeoutMs: number;
+    readonly remoteTotalTimeoutMs: number;
+}
+declare const DEFAULT_IMAGE_API_LIMITS: ImageApiLimits;
+declare function assertFiniteImageApiLimits(limits: ImageApiLimits): void;
+interface ImageRemoteMaterializer {
+    materialize(source: AsyncIterable<Uint8Array>, declaredBytes: number | undefined, signal: AbortSignal): Promise<ImageAsset>;
+}
+interface RemoteImageAssetResolver {
+    resolve(input: {
+        readonly url: string;
+        readonly signal: AbortSignal;
+        readonly limits: ImageApiLimits;
+        readonly materializer: ImageRemoteMaterializer;
+    }): Promise<ImageAsset>;
+}
+interface ImageApiRuntime {
+    readonly tenantId: string;
+    readonly providerId: string;
+    readonly defaultModel: string;
+    readonly modelAliases: ReadonlyMap<string, string>;
+    readonly limits: ImageApiLimits;
+    readonly preferredAccountId?: string;
+    readonly preferredAccountGroup?: string;
+    readonly boundAccountFallbackPolicy?: 'strict' | 'pool';
+    readonly referenceStore?: ImageReferenceStore;
+    readonly remoteResolver?: RemoteImageAssetResolver;
+    readonly fingerprintUser?: (value: string) => string;
+    readonly retention?: ImageRetentionPolicy;
+}
+type ImageApiRuntimeResolver = (context: OpenAIOperationHandlerContext) => Promise<ImageApiRuntime> | ImageApiRuntime;
+interface ImageApiAuditRecord {
+    readonly requestId: string;
+    readonly operationId: 'images.generate' | 'images.edit';
+    readonly providerId?: string;
+    readonly model?: string;
+    readonly options?: Pick<ImageRequestOptions, 'n' | 'quality' | 'background' | 'outputFormat' | 'stream' | 'partialImages'>;
+    readonly inputCount?: number;
+    readonly inputBytes?: number;
+    readonly referenceOutcomes?: {
+        readonly hits: number;
+        readonly notFound: number;
+        readonly expired: number;
+        readonly failed: number;
+    };
+    readonly cleanupOutcome?: 'completed' | 'failed';
+    readonly terminal: 'completed' | 'failed' | 'cancelled';
+    readonly errorCode?: string;
+}
+interface ImageApiContributionsDeps {
+    readonly orchestrator: ImageOrchestrator;
+    readonly resolveRuntime: ImageApiRuntimeResolver;
+    readonly createRequestId?: () => string;
+    readonly now?: () => number;
+    readonly createResourceScope?: (limits: ImageApiLimits, signal: AbortSignal, tenantId: string) => Promise<ImageRequestResourceScope>;
+    readonly audit?: (record: ImageApiAuditRecord) => void | Promise<void>;
+}
+interface ImageOpenAIOperationContribution {
+    readonly operationId: 'images.generate' | 'images.edit';
+    readonly handler: OpenAIOperationHandler;
+}
+interface ImageApiContributions {
+    readonly generate: ImageOpenAIOperationContribution & {
+        readonly operationId: 'images.generate';
+    };
+    readonly edit: ImageOpenAIOperationContribution & {
+        readonly operationId: 'images.edit';
+    };
+    readonly all: readonly ImageOpenAIOperationContribution[];
+}
+
+export { type CreateImageRequestResourceScopeOptions as C, DEFAULT_IMAGE_API_LIMITS as D, IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT as I, type RemoteImageAssetResolver as R, IMAGE_REQUEST_DIRECTORY_MARKER_NAME as a, type ImageApiAuditRecord as b, type ImageApiContributions as c, type ImageApiContributionsDeps as d, type ImageApiLimits as e, type ImageApiRuntime as f, type ImageApiRuntimeResolver as g, type ImageOpenAIOperationContribution as h, type ImageRemoteMaterializer as i, type ImageRequestResourceOwnership as j, ImageRequestResourceScope as k, type ImageTemporaryResourceBudget as l, type ImageTemporaryResourceBudgetLease as m, assertFiniteImageApiLimits as n, createImageRequestResourceScope as o };

package/dist/{types-BB8pxk_3.d.ts → types-Dvlpjn0d.d.ts}

@@ -1,3 +1,4 @@
+import { e as ImageApiLimits } from './types-Dm4_36V4.js';
 import { ProxyConfig } from '@omnicross/contracts/account-tokens-types';
 import { AuditConfig } from '@omnicross/contracts/audit-types';
 import { BillingConfig } from '@omnicross/contracts/billing-types';
@@ -6,11 +7,52 @@ import { VoucherRecord, VoucherGrant, VoucherInfo, VoucherConfig } from '@omnicr
 import { WebhookConfig } from '@omnicross/contracts/webhook-types';
 import { L as Logger } from './logger-4GvQNzhE.js';
 import { ProviderConfigSource } from './ports/provider-config-source.js';
-import { P as ProviderProxy } from './ProviderProxy--ROec6VI.js';
-import { ProviderProxyDeps } from './provider-proxy/types.js';
+import { P as ProviderProxy } from './ProviderProxy-Ckr6oTrE.js';
+import { W as ProviderProxyDeps } from './types-By9Tg6-I.js';
 import { BoundAccountFallbackPolicy } from './pipeline/BoundAccountSelectionError.js';
+import { S as SearchApiProviderConfigs } from './types-CbCZqLGg.js';
+import { d as SearchFrontendModes } from './frontends-Doz0RaWu.js';
+import { S as SearchRuntime } from './runtime-t8AZacFF.js';
 import { c as KeySpend } from './keyPolicy-zdWTu3CQ.js';
 
+/**
+ * anthropicCountTokens — the `POST /v1/messages/count_tokens` handler
+ * (`claude-api-routing-errors`, R2 passthrough+reject subset).
+ *
+ * Before this module, the substring `/v1/messages` match routed count_tokens
+ * into the FULL generation pipeline — every context-stats call burned a real
+ * upstream inference (BYO money, subscription 5h-window quota) and returned a
+ * Message JSON instead of `{"input_tokens":N}` (audit F-1, P0).
+ *
+ * Strategies (portfolio-locked default: `'auto'`):
+ *  - **passthrough** (Anthropic-wire upstream — `plan.sameFormat`): strip the
+ *    generation-only fields the count_tokens endpoint rejects (`stream`,
+ *    `max_tokens`), rewrite `model` to the resolved upstream model, and POST to
+ *    `<upstream>/v1/messages/count_tokens` via the SAME same-format fetches the
+ *    generation path uses (credential injection, beta merge, claude header
+ *    baseline all inherited). The response — success OR failure — relays
+ *    verbatim with its real status (an Anthropic-wire error body already IS
+ *    the official shape; wrapping it would violate the verbatim moat).
+ *  - **estimate** (Change B; explicit config, or `auto` on a translation
+ *    upstream): a PURE-LOCAL heuristic estimate (`anthropicCountEstimate.ts`)
+ *    answered as `{"input_tokens":N}` with the `x-omnicross-count-estimate:
+ *    true` marker header — zero upstream calls, never recorded as usage.
+ *  - **reject** (explicit config, or `passthrough` degraded on a translation
+ *    upstream): a clean Anthropic 404 `not_found_error` with ZERO upstream
+ *    calls — Claude Code treats it as "endpoint absent" and falls back to its
+ *    local usage estimation.
+ *
+ * A free endpoint: no usage recording, no concurrency gate (the outbound face
+ * bypasses its gate before dispatch), single attempt — no 401 refresh retry,
+ * no subscription health marking (a failed count_tokens must not cool an
+ * account that serves inference; the inference path drives those itself).
+ *
+ * @module provider-proxy/ingress/anthropicCountTokens
+ */
+
+/** The operator-facing strategy config (§10 `anthropic.countTokens.mode`). */
+type CountTokensMode = 'auto' | 'passthrough' | 'estimate' | 'reject';
+
 /**
  * keySpendTracker — a cheap in-memory per-key accumulated-spend cache
  * (`outbound-key-policy`, design D3).
@@ -201,23 +243,104 @@ interface VoucherDb {
     voucherList(): Promise<VoucherRecord[]>;
 }
 
+/** The four endpoints, 1:1 with the four wire-format ingress parsers. */
+type OutboundEndpoint = 'chat' | 'responses' | 'messages' | 'gemini';
+/** Named-key authorization vocabulary. Images is deliberately not a text route. */
+type OutboundPermission = OutboundEndpoint | 'images';
 /**
- * Shared contract types for the outbound API server (`outbound-api-server`).
- *
- * The outbound server is a SEPARATE long-lived HTTP listener (distinct from the
- * resident loopback `ProviderProxy`) that authenticates external callers via
- * named API keys and routes their requests through the EXISTING `provider-proxy`
- * ingress parsers + transformer — there is exactly one conversion stack.
+ * The persisted `search` section (plan §6.3).
  *
- * These types are kept in their own module so the server, router, auth, rate
- * limiter, role detection, and route resolver can share shapes without circular
- * imports.
+ * Deliberately small. It carries the four things assembly cannot invent —
+ * which keyed providers exist, where they may egress, who executes per
+ * frontend, and the runtime's default policy — and nothing else. The
+ * provider-config SHAPES stay core-local (`@omnicross/core/search/api`); the
+ * 阶段4 deferral of promoting them into `@omnicross/contracts` is left standing
+ * because assembly turned out not to need it.
  *
- * @module outbound-api/types
+ * **Secrets are values here, not references.** The
+ * `search-provider:<id>:apiKey` secret-ref scheme Elftia uses is host-side and
+ * belongs to the Phase-2 cutover; this phase reads what the config holds and
+ * never prints it.
  */
-
-/** The four endpoints, 1:1 with the four wire-format ingress parsers. */
-type OutboundEndpoint = 'chat' | 'responses' | 'messages' | 'gemini';
+interface SearchServerConfig {
+    /**
+     * Per-frontend execution modes. Always total after normalization.
+     *
+     * **These do not all apply at the same moment.** `modes.codex` is read from
+     * the live config on every request, so an admin PUT takes effect at once;
+     * `modes.responses` / `modes.anthropic` are captured into the proxy deps at
+     * bootstrap, as are `providers`, `egress` and `policy` (they build the ONE
+     * runtime), so changing those requires a daemon restart. `doctor search`
+     * prints this distinction rather than leaving an operator to discover it.
+     */
+    modes: SearchFrontendModes;
+    /** Configured API providers. A provider absent here is UNCONFIGURED, not broken. */
+    providers: SearchApiProviderConfigs;
+    /** SSRF egress policy knobs. */
+    egress: {
+        /**
+         * Hostnames allowed to resolve into an otherwise-denied address class —
+         * the internal-SearXNG escape hatch. Exact, case-insensitive matching.
+         */
+        allowedPrivateHosts: string[];
+    };
+    /**
+     * The runtime's DEFAULT policy. These are 阶段3's existing knobs surfaced as
+     * configuration; no new orchestration semantics are introduced here.
+     */
+    policy: {
+        preferred?: string;
+        allowed?: string[];
+        fallbackEnabled: boolean;
+        maxAttempts?: number;
+    };
+}
+interface ImagesServerConfig {
+    enabled: boolean;
+    provider: 'codex-subscription';
+    defaultModel: string;
+    modelAliases: Record<string, string>;
+    account: {
+        id?: string;
+        group?: string;
+        fallback: 'strict' | 'pool';
+    };
+    queue: {
+        maxConcurrentJobsPerAccount: number;
+        maxQueuedJobs: number;
+        queueTimeoutMs: number;
+        generationTimeoutMs: number;
+    };
+    temporary: {
+        maxActiveScopes: number;
+        maxTotalBytes: number;
+        maxTenantBytes: number;
+        staleAfterMs: number;
+        cleanupIntervalMs: number;
+    };
+    limits: ImageApiLimits;
+    references: {
+        ttlMs: number;
+        maxArtifactBytes: number;
+        maxTotalBytes: number;
+        maxTenantBytes: number;
+        maxEntries: number;
+        maxCalls: number;
+        maxResponses: number;
+        maxTombstones: number;
+        tombstoneTtlMs: number;
+        cleanupIntervalMs: number;
+        storageRoot?: string;
+    };
+    remote: {
+        enabled: boolean;
+    };
+    evidenceTtlMs: number;
+}
+/** Non-consuming, account-bound image model discovery injected by the daemon. */
+interface ImageModelCatalogReader {
+    listAvailableModels(apiKeyId: string): Promise<readonly string[]>;
+}
 /** A `"providerId,modelId"` model reference (mirrors `RouterConfig` vocab). */
 type ModelRef = string;
 /** The detected request role; precedence background > default. */
@@ -513,6 +636,69 @@ interface FingerprintConfig {
     /** Operator UA baseline for un-captured accounts (piece 4). Absent ⇒ none. */
     ua?: string;
 }
+/**
+ * count_tokens strategy mode (§10 `anthropic.countTokens.mode`). ONE canonical
+ * union lives with the handler (`provider-proxy/ingress/anthropicCountTokens`);
+ * this alias re-exports it so the config-segment types and the runtime
+ * resolver can never drift apart (review B-M2).
+ */
+type AnthropicCountTokensMode = CountTokensMode;
+/** `GET /v1/models` response shape selector (§10 `anthropic.modelsShape`). */
+type AnthropicModelsShape = 'auto' | 'anthropic' | 'openai';
+/**
+ * Anthropic-protocol tuning segment (`claude-api-protocol-fidelity`, §10
+ * skeleton — count_tokens strategy/budget, /v1/models shape, synthetic-SSE
+ * heartbeat). Persisted + normalized like the other segments; read live per
+ * request (count_tokens/models) or hot-applied via the module setter
+ * (heartbeat). `proxyOauthUsage` / `apiHello` land in the follow-up change.
+ */
+interface AnthropicConfigSegment {
+    /**
+     * `/v1/messages/count_tokens` strategy. `mode` absent ⇒ `'auto'`
+     * (Anthropic-wire upstream → passthrough; translation upstream → local
+     * estimate). `estimateBudgetMs` bounds the local estimator walk (default
+     * 2000; a pathological input degrades to a coarser estimate, never fails).
+     */
+    countTokens?: {
+        mode?: AnthropicCountTokensMode;
+        estimateBudgetMs?: number;
+    };
+    /**
+     * `GET /v1/models` response shape. `'auto'` (default): a key authorized for
+     * the messages endpoint gets the Anthropic list shape, everyone else keeps
+     * the OpenAI shape; `'anthropic'` / `'openai'` force one shape (escape
+     * hatch for dual-protocol consumers).
+     */
+    modelsShape?: AnthropicModelsShape;
+    /**
+     * Synthetic-SSE ping heartbeat interval (ms) for the TRANSLATION path only.
+     * Default 20000; ≤0 disables. Hot-applied at `applyConfig` — in-flight
+     * streams pick the new value at their next timer arm.
+     */
+    heartbeatIntervalMs?: number;
+    /**
+     * Translate-path PDF text extraction budget (`claude-api-transform-fidelity`,
+     * R7). `budgetMs` default 2000 — bounds the synchronous zero-dependency
+     * text-layer walk; over-budget documents 400 explicitly (never silently
+     * dropped, never unbounded work).
+     */
+    pdfTextExtraction?: {
+        budgetMs?: number;
+    };
+    /**
+     * Serve `GET /api/oauth/usage` on the outbound listener as a PURE-CACHE read
+     * of the shared Claude allowance store (R9). Default FALSE — off, the path
+     * keeps its current generic 404 byte-for-byte. When on, a messages-authorized
+     * key bound to a Claude subscription receives the api.anthropic.com usage
+     * wire shape; NO upstream call or refresh is ever triggered by the query.
+     */
+    proxyOauthUsage?: boolean;
+    /**
+     * Answer `HEAD /api/hello` with a bare 200 at the listener level (R10 —
+     * clients probe "can this endpoint be safely rejected"). Default TRUE.
+     */
+    apiHello?: boolean;
+}
 /**
  * Layered upstream-proxy segment (upstream-proxy). Global + per-provider proxy
  * config for outbound EGRESS to upstreams (NOT the inbound listener). Resolved
@@ -627,6 +813,21 @@ interface OutboundApiServerConfig {
      * byte-identical zero regression, purely additive on the #4 key-policy.
      */
     voucher?: VoucherConfig;
+    /**
+     * Anthropic-protocol tuning segment (claude-api-protocol-fidelity, §10).
+     * Optional in the persisted shape; `normalizeServerConfig` always fills it
+     * with the frozen defaults (auto/auto/20000).
+     */
+    anthropic?: AnthropicConfigSegment;
+    /** Default-off Images serving policy; capability still requires fresh evidence. */
+    images?: ImagesServerConfig;
+    /**
+     * Search assembly (plan 阶段5/§6.3): which API providers exist, where they may
+     * egress, which frontend runs in which mode, and the runtime's default policy.
+     * Absent yields {@link DEFAULT_SEARCH_SERVER_CONFIG} — HTTP-only providers,
+     * modes `off`/`native`/`native`, public-only egress.
+     */
+    search?: SearchServerConfig;
 }
 /** A live status snapshot the Settings tab renders. */
 interface OutboundApiServerStatus {
@@ -641,6 +842,15 @@ interface OutboundApiServerStatus {
     formats: OutboundFormatUrls | null;
     /** The four format endpoint URLs over the LAN (only when network binding on). */
     lanFormats: OutboundFormatUrls | null;
+    /** Additive Images endpoints; absent while Images is disabled. */
+    images?: {
+        generations: string;
+        edits: string;
+    } | null;
+    lanImages?: {
+        generations: string;
+        edits: string;
+    } | null;
 }
 /** The four format endpoint URLs for one base. */
 interface OutboundFormatUrls {
@@ -667,8 +877,10 @@ interface OutboundApiKeyInfo {
     revoked: boolean;
     /** Intended consumer. Existing rows default to a general client key. */
     kind?: 'client' | 'integration';
-    /** Optional endpoint allow-list. Absent means every outbound endpoint. */
-    allowedEndpoints?: OutboundEndpoint[];
+    /** Exact effective permission list; legacy absent rows project to text-only permissions. */
+    allowedEndpoints: OutboundPermission[];
+    /** True when the stored row omitted permissions and compatibility defaults were projected. */
+    legacyPermissions: boolean;
     /** When true the key is rejected unless the TCP peer is loopback. */
     loopbackOnly?: boolean;
     /**
@@ -746,6 +958,8 @@ interface OutboundApiKeyCreated {
     name: string;
     keyPrefix: string;
     createdAt: number;
+    /** Exact effective permission list assigned to the new key. */
+    allowedEndpoints: OutboundPermission[];
     plaintextOnce: string;
 }
 /**
@@ -773,8 +987,8 @@ interface OutboundKeyDbRow {
     revokedAt: number | null;
     /** Intended consumer. Existing rows without this field remain client keys. */
     kind?: 'client' | 'integration';
-    /** Optional endpoint allow-list for least-privilege integration keys. */
-    allowedEndpoints?: OutboundEndpoint[];
+    /** Persisted exact permission list. Absent is a legacy text-only row. */
+    allowedEndpoints?: OutboundPermission[];
     /** Restrict use to requests whose direct socket peer is loopback. */
     loopbackOnly?: boolean;
     /**
@@ -817,7 +1031,7 @@ interface OutboundKeyDb {
         keyPrefix: string;
         createdAt?: number;
         kind?: 'client' | 'integration';
-        allowedEndpoints?: OutboundEndpoint[];
+        allowedEndpoints?: OutboundPermission[];
         loopbackOnly?: boolean;
         /**
          * The generated plaintext secret. When the DB holds a `SecretBox` it
@@ -831,6 +1045,8 @@ interface OutboundKeyDb {
     outboundApiKeysRevoke(id: string): Promise<boolean>;
     outboundApiKeysTouchLastUsed(id: string): Promise<boolean>;
     outboundApiKeysSetEnabled(id: string, enabled: boolean): Promise<boolean>;
+    /** Atomically replace the exact key permission list. */
+    outboundApiKeysSetPermissions(id: string, permissions: OutboundPermission[]): Promise<boolean>;
     /**
      * Set (or clear) a key's per-key concurrency ceiling. `null` clears the field
      * → unlimited (gate bypassed). Mirrors `outboundApiKeysSetEnabled`; returns
@@ -890,6 +1106,8 @@ interface OutboundApiDeps {
     readonly providerProxy: ProviderProxy;
     /** The proxy's app-session deps (reused verbatim for `routeRequest`). */
     readonly proxyDeps: ProviderProxyDeps;
+    /** Optional fail-closed Images catalog; absent means no image model is advertised. */
+    readonly imageModelCatalog?: ImageModelCatalogReader;
     /**
      * OPTIONAL unauthenticated `/health` provider (daemon-health-endpoint, D1
      * secondary mount). When wired (by the daemon bootstrap — core NEVER imports
@@ -915,6 +1133,17 @@ interface OutboundApiDeps {
      * embedders/tests that do not wire it).
      */
     readonly logger?: Logger;
+    /**
+     * OPTIONAL shared search runtime (plan 阶段5). When wired by the daemon
+     * bootstrap, `POST /v1/alpha/search` executes through it in managed mode.
+     * Absent ⇒ the route behaves exactly as mode `off`: a structured
+     * `unsupported_capability`, never a generic 404.
+     *
+     * There is exactly ONE of these per daemon, shared with both managed protocol
+     * frontends and with `doctor search`. A second instance anywhere would be a
+     * second provider order, which is what the whole extraction removes.
+     */
+    readonly searchRuntime?: SearchRuntime | null;
 }
 
-export { type AccountProbeConfig as A, computeVoucherGrant as B, type ChatDispatchMode as C, generateVoucherCode as D, ENDPOINT_MODEL_KINDS as E, type FingerprintConfig as F, type GatewayBinding as G, hashVoucherCode as H, newVoucherId as I, startOfLocalDay as J, type KeySpendReader as K, startOfLocalWeek as L, type MessagesModelKind as M, toVoucherInfo as N, type OutboundKeyDb as O, voucherCodePrefix as P, type ModelRef as Q, type RequestRole as R, type AccountHealthConfig as S, type OutboundKeyModelRestrictionMode as T, type UserMessageQueueConfig as U, type VoucherCreateInput as V, type AllowanceSchedulingConfig as a, type ConcurrencyQueueConfig as b, type EndpointRoutingConfig as c, type GatewayBindingFallback as d, type GatewayBindingKeyScope as e, type GatewayBindingModelMode as f, type GatewayBindingTarget as g, type GatewayModelMapping as h, type KeySpendSeeder as i, KeySpendTracker as j, type KindMappedEndpoint as k, type ModelKind as l, type ModelPrefixTargets as m, type OutboundApiDeps as n, type OutboundApiKeyCreated as o, type OutboundApiKeyInfo as p, type OutboundApiServerConfig as q, type OutboundApiServerStatus as r, type OutboundEndpoint as s, type OutboundFormatUrls as t, type OutboundKeyActivationMode as u, type OutboundKeyDbRow as v, type OutboundKeyPolicy as w, type OutboundProxyConfig as x, type ResponsesModelKind as y, type VoucherDb as z };
+export { type ImageModelCatalogReader as $, type AccountProbeConfig as A, type VoucherDb as B, type ChatDispatchMode as C, computeVoucherGrant as D, ENDPOINT_MODEL_KINDS as E, type FingerprintConfig as F, type GatewayBinding as G, generateVoucherCode as H, type ImagesServerConfig as I, hashVoucherCode as J, type KeySpendReader as K, newVoucherId as L, type MessagesModelKind as M, startOfLocalDay as N, type OutboundKeyDb as O, startOfLocalWeek as P, toVoucherInfo as Q, type RequestRole as R, type SearchServerConfig as S, voucherCodePrefix as T, type UserMessageQueueConfig as U, type VoucherCreateInput as V, type ModelRef as W, type AnthropicConfigSegment as X, type AccountHealthConfig as Y, type AnthropicCountTokensMode as Z, type AnthropicModelsShape as _, type AllowanceSchedulingConfig as a, type OutboundKeyModelRestrictionMode as a0, type ConcurrencyQueueConfig as b, type EndpointRoutingConfig as c, type GatewayBindingFallback as d, type GatewayBindingKeyScope as e, type GatewayBindingModelMode as f, type GatewayBindingTarget as g, type GatewayModelMapping as h, type KeySpendSeeder as i, KeySpendTracker as j, type KindMappedEndpoint as k, type ModelKind as l, type ModelPrefixTargets as m, type OutboundApiDeps as n, type OutboundApiKeyCreated as o, type OutboundApiKeyInfo as p, type OutboundApiServerConfig as q, type OutboundApiServerStatus as r, type OutboundEndpoint as s, type OutboundFormatUrls as t, type OutboundKeyActivationMode as u, type OutboundKeyDbRow as v, type OutboundKeyPolicy as w, type OutboundPermission as x, type OutboundProxyConfig as y, type ResponsesModelKind as z };

package/dist/usage.cjs

@@ -7,7 +7,7 @@
 
 
 
-var _chunkQUSEZNYScjs = require('./chunk-QUSEZNYS.cjs');
+var _chunk32SRZFFPcjs = require('./chunk-32SRZFFP.cjs');
 
 
 var _chunk2E42SAW3cjs = require('./chunk-2E42SAW3.cjs');
@@ -26,4 +26,4 @@ require('./chunk-XSVNC2UD.cjs');
 
 
 
-exports.PricingEngine = _chunk2E42SAW3cjs.PricingEngine; exports.THROUGHPUT_BUCKET_COUNT = _chunkQUSEZNYScjs.THROUGHPUT_BUCKET_COUNT; exports.THROUGHPUT_RETENTION_MS = _chunkQUSEZNYScjs.THROUGHPUT_RETENTION_MS; exports.THROUGHPUT_SAMPLE_LIMIT = _chunkQUSEZNYScjs.THROUGHPUT_SAMPLE_LIMIT; exports.THROUGHPUT_WINDOWS_MS = _chunkQUSEZNYScjs.THROUGHPUT_WINDOWS_MS; exports.UsageRecorder = _chunk5UK3KLE2cjs.UsageRecorder; exports.UsageThroughputTracker = _chunkQUSEZNYScjs.UsageThroughputTracker; exports.__resetSharedUsageThroughputTrackerForTests = _chunkQUSEZNYScjs.__resetSharedUsageThroughputTrackerForTests; exports.getSharedUsageThroughputTracker = _chunkQUSEZNYScjs.getSharedUsageThroughputTracker; exports.setSharedUsageThroughputTracker = _chunkQUSEZNYScjs.setSharedUsageThroughputTracker;
+exports.PricingEngine = _chunk2E42SAW3cjs.PricingEngine; exports.THROUGHPUT_BUCKET_COUNT = _chunk32SRZFFPcjs.THROUGHPUT_BUCKET_COUNT; exports.THROUGHPUT_RETENTION_MS = _chunk32SRZFFPcjs.THROUGHPUT_RETENTION_MS; exports.THROUGHPUT_SAMPLE_LIMIT = _chunk32SRZFFPcjs.THROUGHPUT_SAMPLE_LIMIT; exports.THROUGHPUT_WINDOWS_MS = _chunk32SRZFFPcjs.THROUGHPUT_WINDOWS_MS; exports.UsageRecorder = _chunk5UK3KLE2cjs.UsageRecorder; exports.UsageThroughputTracker = _chunk32SRZFFPcjs.UsageThroughputTracker; exports.__resetSharedUsageThroughputTrackerForTests = _chunk32SRZFFPcjs.__resetSharedUsageThroughputTrackerForTests; exports.getSharedUsageThroughputTracker = _chunk32SRZFFPcjs.getSharedUsageThroughputTracker; exports.setSharedUsageThroughputTracker = _chunk32SRZFFPcjs.setSharedUsageThroughputTracker;

package/dist/usage.d.cts

@@ -82,10 +82,12 @@ interface UsageThroughputWindow {
     totalTokens: number;
     costUsd: number;
     requestsPerMinute: number;
-    /** The headline TPM: `totalTokens` per minute over `windowMs`. */
+    /** `totalTokens` per minute over `windowMs`. */
     tokensPerMinute: number;
     inputTokensPerMinute: number;
     outputTokensPerMinute: number;
+    /** cacheRead + cacheCreation per minute over `windowMs`. */
+    cacheTokensPerMinute: number;
     costUsdPerMinute: number;
     /**
      * False when the sample cap evicted events that fall inside this window, so
@@ -98,7 +100,10 @@ interface UsageThroughputBucket {
     /** Epoch-ms of the bucket's (grid-aligned) start. */
     startTs: number;
     requests: number;
+    /** input + output + cacheRead + cacheCreation (same basis as `totalTokens`). */
     tokens: number;
+    /** Output tokens alone, so a card headlining output can trend in step. */
+    outputTokens: number;
 }
 /** The `GET /admin/api/usage/throughput` payload. */
 interface UsageThroughputSnapshot {

package/dist/usage.d.ts

@@ -82,10 +82,12 @@ interface UsageThroughputWindow {
     totalTokens: number;
     costUsd: number;
     requestsPerMinute: number;
-    /** The headline TPM: `totalTokens` per minute over `windowMs`. */
+    /** `totalTokens` per minute over `windowMs`. */
     tokensPerMinute: number;
     inputTokensPerMinute: number;
     outputTokensPerMinute: number;
+    /** cacheRead + cacheCreation per minute over `windowMs`. */
+    cacheTokensPerMinute: number;
     costUsdPerMinute: number;
     /**
      * False when the sample cap evicted events that fall inside this window, so
@@ -98,7 +100,10 @@ interface UsageThroughputBucket {
     /** Epoch-ms of the bucket's (grid-aligned) start. */
     startTs: number;
     requests: number;
+    /** input + output + cacheRead + cacheCreation (same basis as `totalTokens`). */
     tokens: number;
+    /** Output tokens alone, so a card headlining output can trend in step. */
+    outputTokens: number;
 }
 /** The `GET /admin/api/usage/throughput` payload. */
 interface UsageThroughputSnapshot {

package/dist/usage.js

@@ -7,7 +7,7 @@ import {
   __resetSharedUsageThroughputTrackerForTests,
   getSharedUsageThroughputTracker,
   setSharedUsageThroughputTracker
-} from "./chunk-6D4W22P4.js";
+} from "./chunk-QIIAMBTM.js";
 import {
   PricingEngine
 } from "./chunk-FXR6N3SR.js";