@urun-sh/openai 0.5.4 → 0.5.5

package/dist/hosted/index.d.cts

@@ -2,283 +2,10 @@ import { Server } from 'node:http';
 import { createClientToken } from '@urun-sh/core';
 import { U as UrunResponses } from '../ResponsesClient-Dft3bg3b.cjs';
 import { b as UrunSessionLike } from '../types-lsVTbNcH.cjs';
-import { C as CatalogRow } from '../models-NYMZrklp.cjs';
-import { P as ProxyClients } from '../server-wmUnMewW.cjs';
+import { S as SessionGoneError, P as ProxyClients, M as ModelRouter } from '../responses-turn-OrO4euEN.cjs';
+import '../models-NYMZrklp.cjs';
 import '../video-out-D20UuJ8G.cjs';
 
-/**
- * THE OPENROUTER PROVIDER DOCUMENT — `GET /v1/models?format=openrouter`.
- *
- * OpenRouter's provider monitor polls this document (schema 2.4, per
- * openrouter.ai/docs/guides/community/for-providers) to list a provider's
- * models on the marketplace. The `id` field is the EXACT model identifier
- * OpenRouter sends back as `model` on chat completions — which here is the
- * app slug, the same id the OpenAI surface lists. One id space, two views.
- *
- * MODALITY GATING: only rows whose catalog `task` names a chat-completions
- * shape (chat | code | agent | vl) are declared. A voice/video/image app
- * behind a chat surface would stream garbage into OpenRouter's baseline
- * tests; models the catalog cannot vouch for are OMITTED, never guessed.
- * With no catalog oracle configured the document is `{"data": []}` — honest
- * emptiness, not invented capability (the chart turns the oracle on).
- *
- * PRICING is deliberately omitted entirely: the schema's rule is "a modality
- * with no pricing array is simply unpriced", OpenRouter configures pricing
- * during provider onboarding, and the per-model price surface is
- * urun-infra U3 (model_prices) — when that lands, this module grows a
- * `prices` input and emits the input/output pricing arrays.
- *
- * The full closed-value-domain schema ships as OpenAPI 3.1 at
- * openrouter.ai/docs/assets/provider-monitor-schema-v2.openapi.json.
- */
-
-type OpenRouterProviderDoc = {
-    data: OpenRouterProviderModel[];
-};
-interface OpenRouterProviderModel {
-    schema_version: '2.4';
-    /** The EXACT id OpenRouter sends back as `model` — the app slug. */
-    id: string;
-    name: string;
-    created: number;
-    /** Valid enum: int4|int8|fp4|mxfp4|nvfp4|fp6|fp8|mxfp8|fp16|bf16|fp32|null. */
-    quantization: string | null;
-    description: string;
-    hugging_face_id: string;
-    input_modalities: Array<Record<string, unknown>>;
-    output_modalities: Array<Record<string, unknown>>;
-}
-
-/**
- * Per-model → per-app routing for the compat proxy (owner directive
- * 2026-08-07): swapping the model in a coding harness routes the request to
- * the org's DEPLOYED app for that model. v1 is deployed-only — a uRun model
- * that is not deployed gets a loud 404 naming `urun serve <id>`; a later
- * phase (explicitly out of scope here; urun-infra#1490 shared-endpoints)
- * auto-creates from the model catalog on first request.
- *
- * MODEL-ID SURFACE (the documented mapping): a model may be named by
- *   - the app slug itself        ("qwen3-6-27b-bf16"), or
- *   - the catalog id             ("qwen3.6-27b"), or
- *   - the catalog id:variant     ("qwen3.6-27b:bf16"),
- * where slugification mirrors urun-cli `serve.py _default_app_name` exactly:
- * lowercase, every non-alphanumeric-non-dash character becomes "-", leading/
- * trailing dashes stripped (catalog id "qwen3.6-27b" + variant "bf16" → app
- * "qwen3-6-27b-bf16"). COLLISION RULE: an exact slug match always wins over
- * the catalog-id (prefix) interpretation.
- *
- * RESOLUTION ORDER (one canonical path, documented end to end):
- *   1. model absent / "urun" / an alias of the startup app  → DEFAULT app.
- *   2. exact slug match on a deployed serve app             → that app.
- *   3. catalog-id form matching exactly one deployed app    → that app
- *      (two or more candidates → loud ambiguity error naming them).
- *   4. the name maps to an org app that is NOT an active app exposing the
- *      proxy's serve function                               → loud 404
- *      naming `urun serve <model>` and the available models.
- *   5. the name matches a catalog row but no deployed app   → loud 404
- *      naming `urun serve <id>` (deployed-only v1).
- *   6. anything else — a model name outside the uRun namespace entirely
- *      (e.g. the harness's own upstream default, "claude-*"/"gpt-*") →
- *      DEFAULT app. This IS today's single-app contract, kept deliberately
- *      so `urun compat <agent>` with the agent's stock model keeps working
- *      with zero new env; the per-model /stats table records every such
- *      mapping so it is visible, never silent. Models the proxy ADVERTISES
- *      on /v1/models can never land here — they resolve (2/3) or fail loud
- *      (4/5) above.
- *
- * NO-DEFAULT MODE (`defaultApp: null`) — the HOSTED multi-tenant lane
- * (`src/hosted/`): a shared endpoint serving every org has no "the app this
- * proxy was started for", so rules 1 and 6 have nothing to fall back TO.
- * Rather than inventing one (picking "some" app for a caller would be the
- * worst kind of silent divergence), both rules become the SAME loud
- * {@link UnknownModelError} that rules 4/5 already raise: name a deployed
- * model, here is the list. Rules 2–5 are byte-for-byte the local behavior —
- * one router, one resolution order, two configurations.
- */
-
-/** One org app row from `GET {orgApi}/apps` (urun-cli `ApiClient.list_apps`). */
-interface DeployedApp {
-    app_slug: string;
-    function_name?: string | null;
-    deployment_status?: string | null;
-    [k: string]: unknown;
-}
-/**
- * A session handle names a pooled session that no longer exists (closed,
- * evicted after its pod died, replaced by a re-home, or the proxy restarted).
- * The caller asked to REATTACH that exact session — opening a fresh one and
- * calling it "resumed" would be a silent lie, so this is always loud.
- */
-declare class SessionGoneError extends Error {
-}
-/**
- * OpenAI-shaped model list (same shape as models.ts listModels). When the
- * catalog oracle is configured, each entry ALSO carries the catalog
- * enrichment fields (additive JSON — OpenAI clients ignore unknown fields;
- * the OpenRouter + Vercel AI Gateway provider listings need them). Entries
- * whose slug matches no catalog row stay at the bare four fields.
- */
-interface RouterModelEntry {
-    id: string;
-    object: 'model';
-    created: number;
-    owned_by: string;
-    /** Display name — the canonical `<model_id>:<variant>` catalog ref. */
-    name?: string;
-    /** User-facing description from the catalog (console Endpoints copy). */
-    description?: string;
-    /** Catalog modality (chat | code | agent | vl | audio | image | ...). */
-    task?: string;
-    /** Serving engine (vllm | sglang | llamacpp | ...). */
-    engine?: string;
-    /** The catalog lane this app deploys, e.g. 'rtx6000:1'. */
-    gpu_spec?: string;
-    /** Context window in tokens (chat rows carry it in engine_args). */
-    context_length?: number;
-}
-interface RouterModelList {
-    object: 'list';
-    data: RouterModelEntry[];
-}
-interface ModelRouterOptions<S> {
-    /**
-     * The startup app slug (URUN_APP) — the DEFAULT model — or `null` for the
-     * hosted multi-tenant lane, which has no per-proxy default app: there,
-     * every request must NAME a deployed model and an unnamed/unknown one
-     * fails loud instead of silently landing somewhere (see the module header,
-     * "NO-DEFAULT MODE").
-     */
-    defaultApp: string | null;
-    /** The serve function name every routed app must expose (URUN_FUNCTION). */
-    fnName: string;
-    /** Open a backhaul session for an app slug (called at most once per app). */
-    openSession: (appSlug: string) => S | Promise<S>;
-    /** Terminal release for one pool entry (Session.end() underneath). */
-    closeSession: (entry: S) => Promise<void>;
-    /**
-     * List the org's deployed apps, or null when the credentials cannot
-     * (URUN_JWT lane: the pre-vended token is scoped to the default app, so
-     * there is no org listing AND no cross-app session — routing degrades to
-     * the default-app-only contract, which is exactly today's behavior).
-     */
-    listApps: (() => Promise<DeployedApp[]>) | null;
-    /**
-     * Catalog rows (models.ts fetchCatalogRows) as the uRun-namespace oracle
-     * for rule 5 AND the /v1/models enrichment + OpenRouter provider-doc
-     * source, or null when catalog access is not configured. Optional fields
-     * beyond model_id/variant are tolerated (thin rows still typecheck).
-     */
-    listCatalog: (() => Promise<CatalogRow[]>) | null;
-    /** Deployed-apps cache TTL (the list changes on deploys, not per request). */
-    appsTtlMs?: number;
-    /**
-     * The stable NATIVE identity of one pooled entry (the uRun session id in
-     * the proxy wiring — the same identity the serve-side session-affinity tag
-     * rides, urun-python#1556). Powers the session-identity seam
-     * ({@link ModelRouter.handleFor} / {@link ModelRouter.sessionForHandle});
-     * a router without it fails LOUD on those calls, never approximates.
-     */
-    sessionKey?: (entry: S) => string;
-}
-/**
- * The session pool: one backhaul session per deployed app, keyed by app slug,
- * opened lazily on the first request that routes to it and reused for every
- * subsequent one. The startup app is seeded eagerly by the CLI. Sessions
- * close on proxy shutdown via {@link closeAll}; there is NO idle-close policy
- * (deliberate v1 simplification — noted as a follow-up in the PR).
- */
-declare class ModelRouter<S> {
-    private readonly opts;
-    private readonly pool;
-    private appsCache;
-    private rowsCache;
-    constructor(opts: ModelRouterOptions<S>);
-    /** Seed an already-open session (the CLI's eagerly-opened startup app). */
-    seed(appSlug: string, entry: S): void;
-    private deployedApps;
-    /**
-     * Catalog rows with the same TTL discipline as {@link deployedApps} (the
-     * catalog changes on reseed migrations, not per request). Null when no
-     * oracle is configured — callers degrade to the bare four-field entries.
-     */
-    private catalogRows;
-    /** Apps this proxy may serve: active AND exposing the serve function. */
-    private servable;
-    private availableIds;
-    /**
-     * NO-DEFAULT MODE's terminal for rules 1 and 6: there is no app to fall
-     * back to, so say so loudly and list what the CALLER'S org actually has.
-     * Never returns.
-     */
-    private noDefaultApp;
-    /**
-     * Resolve a request's `model` to an app slug — the documented resolution
-     * order from the module header. Throws {@link UnknownModelError} for a uRun
-     * model that is not deployed (rules 4/5).
-     */
-    resolveApp(model: string | undefined): Promise<string>;
-    /** The pooled session for a model — opened lazily, reused afterwards. */
-    sessionFor(model: string | undefined): Promise<{
-        app: string;
-        entry: S;
-    }>;
-    private keyOf;
-    /**
-     * SESSION-IDENTITY SEAM (a): the opaque stable handle for the pooled
-     * session currently serving `model`'s turns. Rides the SAME acquisition
-     * path as every request ({@link sessionFor}) — the session opens lazily if
-     * this model has none yet — and derives the handle from native identity
-     * (app slug + uRun session id), zero bespoke bookkeeping.
-     */
-    handleFor(model: string | undefined): Promise<{
-        app: string;
-        handle: string;
-    }>;
-    /**
-     * SESSION-IDENTITY SEAM (b): the exact pooled session a handle names.
-     * NEVER opens a fresh session — a handle whose session is gone (closed,
-     * evicted, re-homed to a replacement, proxy restarted) or malformed throws
-     * {@link SessionGoneError} loudly. Resume is reattach-or-fail, not
-     * reattach-or-quietly-restart.
-     */
-    sessionForHandle(handle: string): Promise<{
-        app: string;
-        entry: S;
-    }>;
-    /**
-     * Drop ONE pooled session whose backhaul died (its pod was restarted /
-     * drained / deleted) and release it — the next {@link sessionFor} opens a
-     * fresh one, i.e. asks the control plane for a new assignment. Used by the
-     * one-shot re-home (rehome.ts, urun-sh/urun-python#1592).
-     *
-     * IDENTITY-GUARDED (the same rule the pi lane's SessionPool follows): a
-     * concurrent request that already re-homed this app has put a NEWER entry
-     * under the key, and evicting that would close a healthy session out from
-     * under it.
-     */
-    evict(app: string, entry: S): Promise<void>;
-    /**
-     * `GET /v1/models`: the org's deployed serve apps as model entries, the
-     * default app FIRST. On the JWT lane (no org listing) this is the default
-     * app plus any app already in the pool — the gap is called out loudly in
-     * the PR, not papered over here.
-     */
-    modelList(): Promise<RouterModelList>;
-    /**
-     * The OpenRouter PROVIDER document (`GET /v1/models?format=openrouter`):
-     * schema 2.4 per openrouter.ai/docs/guides/community/for-providers. Only
-     * chat-completions-shaped models are declared (task chat | code | agent |
-     * vl — a voice or video app behind a chat surface would stream garbage);
-     * models the catalog cannot vouch for are OMITTED, never guessed. Pricing
-     * is deliberately omitted entirely (schema rule: "A modality with no
-     * pricing array is simply unpriced" — OpenRouter configures pricing during
-     * provider onboarding; the per-model price surface is urun-infra U3).
-     */
-    openRouterModels(): Promise<OpenRouterProviderDoc>;
-    /** Close every pooled session (Session.end() underneath) — proxy shutdown. */
-    closeAll(): Promise<void>;
-}
-
 /**
  * HOSTED AUTH — the Bearer key IS the identity AND the tenancy.
  *
@@ -479,6 +206,14 @@ interface CatalogConfig {
  */
 type OwnedSession = UrunSessionLike & {
     end: () => Promise<unknown>;
+    /**
+     * The SDK's NATIVE local release (core `Session.detach`): drop the media
+     * transport and decrement the reference count while the named session
+     * stays live and attachable. Optional here because only the
+     * `release: 'detach'` lane requires it — that lane fails LOUD when a
+     * session object lacks it (no approximation, no fake detach).
+     */
+    detach?: () => void;
     id?: string;
     endsAt?: Date | null;
     onPhase?: (handler: (phase: {
@@ -592,6 +327,121 @@ declare class TenantRegistry {
     /** Shutdown: end every pooled session through `Session.end()`. */
     closeAll(): Promise<void>;
 }
+/** The most distinct LIVE conversations one replica keeps private backhauls for. */
+declare const MAX_CONVERSATIONS = 512;
+/** The most resume handles the conversation index remembers (bounded memory). */
+declare const MAX_CONVERSATION_HANDLES = 1024;
+/**
+ * Every conversation slot holds a conversation (active or resumable) — a NEW
+ * bootstrap/setup is refused. Explicit and honest: never an LRU-detach of
+ * someone else's conversation to admit a new one.
+ */
+declare class ConversationCapacityError extends Error {
+    constructor();
+}
+/**
+ * One conversation's private backhaul. Its pooled sessions are reachable by
+ * NO other conversation of any caller: the token subject is conversation-
+ * unique, so the platform's own session dedupe never coalesces them.
+ */
+interface PrivateConversationBackhaul {
+    clients: ProxyClients;
+    /**
+     * LOCAL release of every pooled session — `release: 'detach'` underneath,
+     * i.e. core's NATIVE `Session.detach()`: the media transport drops, the
+     * refcount decrements, the NAMED session stays live and attachable. Never
+     * `Session.end()`: no caller has explicitly ended anything.
+     */
+    release(): Promise<void>;
+}
+interface ConversationBackhaulOptions {
+    /** The session-gateway base sessions are opened against. */
+    baseUrl: string;
+    /** The org control-plane API base (`GET {apiUrl}/apps`). */
+    apiUrl: string;
+    /** The model-catalog oracle for routing rule 5, or null. */
+    catalog: CatalogConfig | null;
+    /** Injected in tests; production builds real uRun backhauls. */
+    build?: (caller: CallerIdentity, conversation: {
+        id: string;
+        subject: string;
+    }) => PrivateConversationBackhaul;
+}
+/**
+ * The per-CONNECTION Live/realtime seam — transport-neutral (Gemini Live,
+ * OpenAI Realtime, ...). `clients` lazily opens the caller's PRIVATE
+ * conversation backhaul on first use; `bindResumeHandle` indexes each handle
+ * the protocol lane mints; `clientsForResume` re-attaches the conversation a
+ * handle belongs to — SAME native identity, owner binding enforced, loud
+ * SessionGoneError when the conversation is gone; `release` drops THIS
+ * attachment when the socket closes.
+ */
+interface PrivateConversationConnection {
+    clients: ProxyClients;
+    bindResumeHandle(handle: string): void;
+    clientsForResume(handle: string): Promise<ProxyClients>;
+    /**
+     * Release THIS attachment: called by the surface when its socket closes.
+     * When the LAST attachment of a conversation goes, its native transport is
+     * detached immediately — while the conversation's native session
+     * REFERENCES (and its resume handles) are RETAINED, so a later resume
+     * re-attaches the SAME named session through canonical attach-by-name.
+     * Idempotent.
+     */
+    release(): Promise<void>;
+}
+/**
+ * Process-local registry of per-conversation private backhauls, bounded by
+ * {@link MAX_CONVERSATIONS}. A conversation whose last attachment closes
+ * KEEPS its entry: its native session references + resume handles survive so
+ * a later resume re-attaches the SAME named session (canonical
+ * attach-by-name). At capacity, only such DETACHED entries are evicted
+ * (oldest first — their resume capability is the only thing lost, the named
+ * sessions stay attachable server-side); ACTIVE conversations are never
+ * touched, and when every slot is active a new bootstrap/setup is refused
+ * with an explicit capacity error. NO HA CLAIM: this registry is
+ * per-process; a replica restart loses every conversation (loud gone), and
+ * no other replica can serve one.
+ */
+declare class ConversationBackhauls {
+    private readonly opts;
+    /** apiKey → conversationId → entry (insertion-ordered = LRU). */
+    private readonly byCaller;
+    /** resume handle → owning conversation (the owner binding's index). */
+    private readonly byHandle;
+    constructor(opts: ConversationBackhaulOptions);
+    private build;
+    /** Find (LRU-refresh) or create the conversation entry, then ATTACH to it. */
+    private attachEntry;
+    private get conversationCount();
+    /**
+     * Free a slot for a NEW conversation: evict the OLDEST DETACHED
+     * conversation (one whose last attachment already closed — only its resume
+     * metadata is lost, no live transport is touched, no session is ended).
+     * ACTIVE conversations are never evicted. When every slot holds an active
+     * conversation, refuse LOUD with an explicit capacity error — the new
+     * bootstrap/setup fails, existing callers are untouched.
+     */
+    private evictOverflow;
+    private dropHandleIndexFor;
+    /**
+     * The per-upgrade seam for one authenticated caller — ONE attachment. The
+     * conversation backhaul opens on the FIRST seam call of a fresh connection;
+     * a resumed connection replaces `clients` wholesale via `clientsForResume`
+     * before any seam call, so the lazy path is never taken on resume. The
+     * attachment is released by `release()` (the socket's close path): when the
+     * LAST attachment of a conversation goes, its native transport is detached
+     * immediately and its resume metadata is retained — no resource keepalive,
+     * no resume loss.
+     */
+    connectionFor(caller: CallerIdentity): PrivateConversationConnection;
+    /**
+     * Drain-time LOCAL release: detach every conversation's sessions (native
+     * detach — the named sessions pause server-side, nothing is ended). Handles
+     * and conversations are forgotten; process exit is the conversation's end.
+     */
+    detachAll(): Promise<void>;
+}
 
 /**
  * The hosted endpoint's configuration.
@@ -671,7 +521,12 @@ declare function resolveHostedConfig(env?: NodeJS.ProcessEnv): HostedConfig;
  *                  or list apps can serve nothing and must be pulled out of
  *                  the Service rather than answering 502s.
  *   *    /v1/...   the compat surface, org-scoped by the Bearer key.
- *   *    anything else → 404 in the OpenAI error envelope.
+ *   WS   /ws/google.ai.generativelanguage.v1beta.GenerativeService.
+ *        BidiGenerateContent — the Gemini Live surface, org-scoped by the
+ *        Gemini credential (x-goog-api-key / Authorization: Bearer; `?key=`
+ *        refused). Ingress/charts must allowlist that path.
+ *   *    anything else → 404 in the OpenAI error envelope (unclaimed WS
+ *        upgrades get their own final refusal).
  *
  * WHAT IS DELIBERATELY NOT HERE: `/stats`. The local proxy exposes it for the
  * launcher's reuse probe; on a shared endpoint it would publish one tenant's
@@ -698,14 +553,20 @@ interface HostedProxyOptions extends HostedConfig {
     resolver?: OrgResolver;
     /** Injected in tests so backhauls are stubbed at the seam. */
     registry?: TenantRegistry;
+    /** Injected in tests so conversation backhauls are stubbed at the seam. */
+    conversations?: ConversationBackhauls;
 }
 /**
- * Build (not listen) the hosted endpoint. The caller owns listen/close, and
- * `closeAll` releases every pooled backhaul through `Session.end()`.
+ * Build (not listen) the hosted endpoint. The caller owns listen/close,
+ * `closeAll` releases every pooled backhaul through `Session.end()`, and
+ * `closeWebSockets` gracefully closes every attached WS surface — a drain
+ * must run it BEFORE `server.close()`/`closeAllConnections()` (see
+ * {@link drainServer}).
  */
 declare function createHostedProxy(options: HostedProxyOptions): {
     server: Server;
     closeAll: () => Promise<void>;
+    closeWebSockets: () => Promise<void>;
 };
 
-export { BIND_HOST, type CallerIdentity, ControlPlaneUnavailableError, DEFAULT_PORT, type HostedConfig, type HostedProxyOptions, MAX_CACHED_KEYS, MAX_TENANTS, ORG_BINDING_TTL_MS, OrgResolver, type OrgResolverOptions, ProxyAuthError, READINESS_TIMEOUT_MS, READINESS_TTL_MS, SERVE_FUNCTION, TenantRegistry, type TenantRegistryOptions, bearerFrom, createHostedProxy, resolveHostedConfig, tenantSubject };
+export { BIND_HOST, type CallerIdentity, ControlPlaneUnavailableError, type ConversationBackhaulOptions, ConversationBackhauls, ConversationCapacityError, DEFAULT_PORT, type HostedConfig, type HostedProxyOptions, MAX_CACHED_KEYS, MAX_CONVERSATIONS, MAX_CONVERSATION_HANDLES, MAX_TENANTS, ORG_BINDING_TTL_MS, OrgResolver, type OrgResolverOptions, type PrivateConversationBackhaul, type PrivateConversationConnection, ProxyAuthError, READINESS_TIMEOUT_MS, READINESS_TTL_MS, SERVE_FUNCTION, TenantRegistry, type TenantRegistryOptions, bearerFrom, createHostedProxy, resolveHostedConfig, tenantSubject };

package/dist/hosted/index.d.ts

@@ -2,122 +2,10 @@ import { Server } from 'node:http';
 import { createClientToken } from '@urun-sh/core';
 import { U as UrunResponses } from '../ResponsesClient-BYx3YLGo.js';
 import { b as UrunSessionLike } from '../types-lsVTbNcH.js';
-import { C as CatalogRow } from '../models-NYMZrklp.js';
-import { P as ProxyClients } from '../server-DuH_5OD9.js';
+import { S as SessionGoneError, P as ProxyClients, M as ModelRouter } from '../responses-turn-KOAoIqZ-.js';
+import '../models-NYMZrklp.js';
 import '../video-out-CWesbk12.js';
 
-type OpenRouterProviderDoc = {
-    data: OpenRouterProviderModel[];
-};
-interface OpenRouterProviderModel {
-    schema_version: '2.4';
-    
-    id: string;
-    name: string;
-    created: number;
-    
-    quantization: string | null;
-    description: string;
-    hugging_face_id: string;
-    input_modalities: Array<Record<string, unknown>>;
-    output_modalities: Array<Record<string, unknown>>;
-}
-
-interface DeployedApp {
-    app_slug: string;
-    function_name?: string | null;
-    deployment_status?: string | null;
-    [k: string]: unknown;
-}
-
-declare class SessionGoneError extends Error {
-}
-
-interface RouterModelEntry {
-    id: string;
-    object: 'model';
-    created: number;
-    owned_by: string;
-    
-    name?: string;
-    
-    description?: string;
-    
-    task?: string;
-    
-    engine?: string;
-    
-    gpu_spec?: string;
-    
-    context_length?: number;
-}
-interface RouterModelList {
-    object: 'list';
-    data: RouterModelEntry[];
-}
-interface ModelRouterOptions<S> {
-    
-    defaultApp: string | null;
-    
-    fnName: string;
-    
-    openSession: (appSlug: string) => S | Promise<S>;
-    
-    closeSession: (entry: S) => Promise<void>;
-    
-    listApps: (() => Promise<DeployedApp[]>) | null;
-    
-    listCatalog: (() => Promise<CatalogRow[]>) | null;
-    
-    appsTtlMs?: number;
-    
-    sessionKey?: (entry: S) => string;
-}
-
-declare class ModelRouter<S> {
-    private readonly opts;
-    private readonly pool;
-    private appsCache;
-    private rowsCache;
-    constructor(opts: ModelRouterOptions<S>);
-    
-    seed(appSlug: string, entry: S): void;
-    private deployedApps;
-    
-    private catalogRows;
-    
-    private servable;
-    private availableIds;
-    
-    private noDefaultApp;
-    
-    resolveApp(model: string | undefined): Promise<string>;
-    
-    sessionFor(model: string | undefined): Promise<{
-        app: string;
-        entry: S;
-    }>;
-    private keyOf;
-    
-    handleFor(model: string | undefined): Promise<{
-        app: string;
-        handle: string;
-    }>;
-    
-    sessionForHandle(handle: string): Promise<{
-        app: string;
-        entry: S;
-    }>;
-    
-    evict(app: string, entry: S): Promise<void>;
-    
-    modelList(): Promise<RouterModelList>;
-    
-    openRouterModels(): Promise<OpenRouterProviderDoc>;
-    
-    closeAll(): Promise<void>;
-}
-
 declare class ProxyAuthError extends Error {
     readonly status: number;
     constructor(message: string, status?: number);
@@ -174,6 +62,8 @@ interface CatalogConfig {
 
 type OwnedSession = UrunSessionLike & {
     end: () => Promise<unknown>;
+    
+    detach?: () => void;
     id?: string;
     endsAt?: Date | null;
     onPhase?: (handler: (phase: {
@@ -218,6 +108,61 @@ declare class TenantRegistry {
     closeAll(): Promise<void>;
 }
 
+declare const MAX_CONVERSATIONS = 512;
+
+declare const MAX_CONVERSATION_HANDLES = 1024;
+
+declare class ConversationCapacityError extends Error {
+    constructor();
+}
+
+interface PrivateConversationBackhaul {
+    clients: ProxyClients;
+    
+    release(): Promise<void>;
+}
+interface ConversationBackhaulOptions {
+    
+    baseUrl: string;
+    
+    apiUrl: string;
+    
+    catalog: CatalogConfig | null;
+    
+    build?: (caller: CallerIdentity, conversation: {
+        id: string;
+        subject: string;
+    }) => PrivateConversationBackhaul;
+}
+
+interface PrivateConversationConnection {
+    clients: ProxyClients;
+    bindResumeHandle(handle: string): void;
+    clientsForResume(handle: string): Promise<ProxyClients>;
+    
+    release(): Promise<void>;
+}
+
+declare class ConversationBackhauls {
+    private readonly opts;
+    
+    private readonly byCaller;
+    
+    private readonly byHandle;
+    constructor(opts: ConversationBackhaulOptions);
+    private build;
+    
+    private attachEntry;
+    private get conversationCount();
+    
+    private evictOverflow;
+    private dropHandleIndexFor;
+    
+    connectionFor(caller: CallerIdentity): PrivateConversationConnection;
+    
+    detachAll(): Promise<void>;
+}
+
 declare const DEFAULT_PORT = 8080;
 
 declare const SERVE_FUNCTION = "serve";
@@ -250,11 +195,14 @@ interface HostedProxyOptions extends HostedConfig {
     resolver?: OrgResolver;
     
     registry?: TenantRegistry;
+    
+    conversations?: ConversationBackhauls;
 }
 
 declare function createHostedProxy(options: HostedProxyOptions): {
     server: Server;
     closeAll: () => Promise<void>;
+    closeWebSockets: () => Promise<void>;
 };
 
-export { BIND_HOST, type CallerIdentity, ControlPlaneUnavailableError, DEFAULT_PORT, type HostedConfig, type HostedProxyOptions, MAX_CACHED_KEYS, MAX_TENANTS, ORG_BINDING_TTL_MS, OrgResolver, type OrgResolverOptions, ProxyAuthError, READINESS_TIMEOUT_MS, READINESS_TTL_MS, SERVE_FUNCTION, TenantRegistry, type TenantRegistryOptions, bearerFrom, createHostedProxy, resolveHostedConfig, tenantSubject };
+export { BIND_HOST, type CallerIdentity, ControlPlaneUnavailableError, type ConversationBackhaulOptions, ConversationBackhauls, ConversationCapacityError, DEFAULT_PORT, type HostedConfig, type HostedProxyOptions, MAX_CACHED_KEYS, MAX_CONVERSATIONS, MAX_CONVERSATION_HANDLES, MAX_TENANTS, ORG_BINDING_TTL_MS, OrgResolver, type OrgResolverOptions, type PrivateConversationBackhaul, type PrivateConversationConnection, ProxyAuthError, READINESS_TIMEOUT_MS, READINESS_TTL_MS, SERVE_FUNCTION, TenantRegistry, type TenantRegistryOptions, bearerFrom, createHostedProxy, resolveHostedConfig, tenantSubject };

package/dist/hosted/index.js

@@ -1 +1 @@
-import{a as e,b as o,c as t,d as n,e as p,f as s,g as T,h as E,i as _,j as a,k as S,l as f,m as x,n as i,o as y,p as O}from"../chunk-STFRT5OY.js";import"../chunk-RQBD4OAA.js";import"../chunk-K23AZPI4.js";import"../chunk-VNM4M4P3.js";import"../chunk-GBBY3PCZ.js";import"../chunk-4MSBS7M6.js";import"../chunk-5NXM4IO3.js";import"../chunk-CWJRDBDC.js";import"../chunk-OI2OY32M.js";import{c as r}from"../chunk-YSFSRI3D.js";r();export{_ as BIND_HOST,o as ControlPlaneUnavailableError,T as DEFAULT_PORT,p as MAX_CACHED_KEYS,S as MAX_TENANTS,n as ORG_BINDING_TTL_MS,s as OrgResolver,e as ProxyAuthError,y as READINESS_TIMEOUT_MS,i as READINESS_TTL_MS,E as SERVE_FUNCTION,x as TenantRegistry,t as bearerFrom,O as createHostedProxy,a as resolveHostedConfig,f as tenantSubject};
+import{a as r,b as e,c as t,d as n,e as a,f as s,g as i,h as p,i as E,j as C,k as S,l as T,m as _,n as O,o as N,p as A,q as l,r as v,s as f,t as x}from"../chunk-5BZCM3RS.js";import"../chunk-I2Q3B3OG.js";import"../chunk-K23AZPI4.js";import"../chunk-QVF7NF7G.js";import"../chunk-GBBY3PCZ.js";import"../chunk-DMD5UENK.js";import"../chunk-5NXM4IO3.js";import"../chunk-CWJRDBDC.js";import"../chunk-OI2OY32M.js";import{c as o}from"../chunk-YSFSRI3D.js";o();export{E as BIND_HOST,e as ControlPlaneUnavailableError,l as ConversationBackhauls,A as ConversationCapacityError,i as DEFAULT_PORT,a as MAX_CACHED_KEYS,O as MAX_CONVERSATIONS,N as MAX_CONVERSATION_HANDLES,S as MAX_TENANTS,n as ORG_BINDING_TTL_MS,s as OrgResolver,r as ProxyAuthError,f as READINESS_TIMEOUT_MS,v as READINESS_TTL_MS,p as SERVE_FUNCTION,_ as TenantRegistry,t as bearerFrom,x as createHostedProxy,C as resolveHostedConfig,T as tenantSubject};