@opengeni/api-router 3.0.1 → 3.1.2

package/dist/mcp/session-event-view.d.ts

@@ -1,6 +1,12 @@
 import { z } from "zod";
 import type { SessionEventSliceOptions, SessionEventSlicePage } from "@opengeni/db/session-event-slices";
 export declare const SESSION_EVENT_VIEW_MAX_BYTES: number;
+/**
+ * toolName with includeOutput reads each named call's result through the exact
+ * callId path, so one page carries at most this many call/result pairs inside
+ * the same 16 KiB envelope. An omitted limit means the newest (or oldest) one.
+ */
+export declare const SESSION_EVENT_NAMED_OUTPUT_MAX_CALLS = 3;
 declare const selectionSchema: z.ZodObject<{
     sessionId: z.ZodString;
     view: z.ZodEnum<{
@@ -11,12 +17,26 @@ declare const selectionSchema: z.ZodObject<{
     includeArguments: z.ZodBoolean;
     includeOutput: z.ZodBoolean;
     callId: z.ZodNullable<z.ZodString>;
+    toolName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNumber>;
     direction: z.ZodEnum<{
         after: "after";
         before: "before";
     }>;
     after: z.ZodNumber;
     before: z.ZodNullable<z.ZodNumber>;
+    named: z.ZodOptional<z.ZodObject<{
+        toolName: z.ZodString;
+        includeArguments: z.ZodBoolean;
+        limit: z.ZodNumber;
+        direction: z.ZodEnum<{
+            after: "after";
+            before: "before";
+        }>;
+        after: z.ZodNumber;
+        before: z.ZodNullable<z.ZodNumber>;
+        more: z.ZodBoolean;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type Selection = z.infer<typeof selectionSchema>;
 export type SessionEventViewInput = {
@@ -28,6 +48,7 @@ export type SessionEventViewInput = {
     limit?: number | undefined;
     cursor?: string | undefined;
     callId?: string | undefined;
+    toolName?: string | undefined;
     includeArguments?: boolean | undefined;
     includeOutput?: boolean | undefined;
 };
@@ -46,9 +67,20 @@ export declare function resolveSessionEventView(input: SessionEventViewInput): {
         includeArguments: boolean;
         includeOutput: boolean;
         callId: string | null;
+        toolName: string | null;
+        limit?: number | undefined;
         direction: "after" | "before";
         after: number;
         before: number | null;
+        named?: {
+            toolName: string;
+            includeArguments: boolean;
+            limit: number;
+            direction: "after" | "before";
+            after: number;
+            before: number | null;
+            more: boolean;
+        } | undefined;
     };
     continuation: {
         v: 1 | 2;
@@ -58,17 +90,47 @@ export declare function resolveSessionEventView(input: SessionEventViewInput): {
             includeArguments: boolean;
             includeOutput: boolean;
             callId: string | null;
+            toolName: string | null;
+            limit?: number | undefined;
             direction: "after" | "before";
             after: number;
             before: number | null;
+            named?: {
+                toolName: string;
+                includeArguments: boolean;
+                limit: number;
+                direction: "after" | "before";
+                after: number;
+                before: number | null;
+                more: boolean;
+            } | undefined;
         };
         sequence: number | null;
         offset: number;
     } | null;
+    notice: string | undefined;
 };
 /** Read-only projection over the existing RLS/audit query. No command observations. */
 export declare function readSessionEventView(input: SessionEventViewInput, read: ReadPage): Promise<{
+    notice: string;
+    view: "conversation" | "results" | "tools";
+    effectiveLimit: number;
+    direction: "after" | "before";
+    events: Item[];
+    nextAfter: number | null;
+    nextBefore: number | null;
+    hasMore: boolean;
+    nextCursor: string | null;
+    sourceExact: boolean;
+    sourceLoss?: {
+        reason: "structured_value_exceeds_budget";
+        completeTextAvailable: false;
+        message: string;
+    };
+    maxBytes: number;
+} | {
     view: "conversation" | "results" | "tools";
+    effectiveLimit: number;
     direction: "after" | "before";
     events: Item[];
     nextAfter: number | null;

package/dist/mcp/session-view.d.ts

@@ -79,6 +79,12 @@ export declare function boundSessionCompactDetailMcp(session: Session, monitorin
     parentSessionId?: string;
     activeTurnId?: string;
     lastSequence: number;
+    archive?: {
+        state: "archived" | "archiving";
+        archivedAt: string | null;
+        readOnly: boolean;
+    };
+    keepLive?: boolean;
     goal?: {
         status: "active" | "completed" | "paused";
         summary: string | null;
@@ -138,6 +144,8 @@ export declare function boundSessionDetailMcp(session: Session, effectiveControl
     tools: unknown;
     metadata: unknown;
     model: string;
+    reasoningEffort: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh";
+    latencyMode: "fast" | "priority" | "standard";
     sandboxBackend: string;
     sandboxOs: "linux" | "macos" | "windows";
     sandboxGroupId: string;
@@ -167,6 +175,13 @@ export declare function boundSessionDetailMcp(session: Session, effectiveControl
     pinned: boolean;
     pinnedAt: string | null;
     pinVersion: number;
+    retention?: {
+        keepLive: boolean;
+        archive: {
+            state: "archived" | "archiving";
+            archivedAt: string | null;
+        } | null;
+    };
     treeStats?: {
         directChildren: number;
         totalDescendants: number;

package/dist/mcp/session-wait.d.ts

@@ -38,6 +38,8 @@ export declare const SESSION_WAIT_EVENTS_PER_TARGET = 20;
  * agent messages, blocking failures, goal facts, and session status/control
  * changes. Raw deltas, tool receipts, sandbox/machine diagnostics, and PTY
  * noise never wake a waiter; `session_events` remains the drill-down for them.
+ * The change mode further drops per-message completions: see
+ * {@link sessionWaitChangeEventMatches}.
  */
 export declare const SESSION_WAIT_EVENT_TYPES: readonly ["turn.started", "turn.completed", "turn.failed", "turn.cancelled", "turn.superseded", "turn.capacity_waiting", "agent.message.completed", "session.status.changed", "session.requiresAction", "session.humanInput.requested", "session.control.paused", "session.control.resumed", "session.wait.started", "session.wait.finished", "tool.auth_needed", "session.command.finished", "credential.auth_needed", "rig.setup.failed", "goal.set", "goal.updated", "goal.progress", "goal.rewrite.proposed", "goal.rewrite.rejected", "goal.completed", "goal.paused", "goal.resumed", "goal.cleared", "goal.continuation"];
 /**
@@ -55,6 +57,15 @@ export declare const SESSION_WAIT_COMPLETION_EVENT_TYPES: readonly ["turn.comple
  * while the session still has work to do, so they must not release a parent.
  */
 export declare function sessionWaitCompletionEventMatches(event: SessionEvent): boolean;
+/**
+ * `waitFor=change` wakes on settled changes. A per-message assistant completion
+ * (commentary, or a final message the turn is about to settle) is not one: the
+ * `turn.completed` that follows carries the answer. Waking on every progress
+ * note would only buy the waiter another poll. The phase-less, id-less
+ * completion older workers publish with `turn.completed` still matches.
+ * Readers pair this with `excludeStreamedAssistantMessages` in SQL.
+ */
+export declare function sessionWaitChangeEventMatches(event: SessionEvent): boolean;
 /** The self-session event that announces a newly pending machine input. */
 export declare const SESSION_WAIT_OWN_PENDING_EVENT_TYPE = "system.update.pending";
 /**
@@ -63,12 +74,19 @@ export declare const SESSION_WAIT_OWN_PENDING_EVENT_TYPE = "system.update.pendin
  * child notices are reported but do not end the wait by themselves.
  */
 export declare function ownPendingKindWakes(kind: string): boolean;
+/**
+ * Re-derive the caller's own pending-input facts after the returned content
+ * consumed some of that input, keeping the same byte bound.
+ */
+export declare function withOwnPendingUpdateKinds(result: SessionWaitResult, kinds: readonly string[]): SessionWaitResult;
 export declare function sessionWaitSemanticClass(type: SessionEventType): SessionEventSemanticClass;
 export type SessionWaitTarget = {
     sessionId: string;
     afterSequence: number;
 };
 export type SessionWaitEventSummary = {
+    /** True only when every semantic result field survived all projections. */
+    contentComplete?: boolean;
     id: string;
     sequence: number;
     type: SessionEventType;

package/dist/mcp/site-agent-clamp-tools.d.ts

@@ -0,0 +1,38 @@
+import type { AccessGrant } from "@opengeni/contracts";
+import { type ApiRouteDeps, type SiteAgentClamp, type SiteClampedResource } from "@opengeni/core";
+/** A refused write by an agent started from a Site page, as first-party tools return it. */
+export declare function siteAgentClampedToolResult(message: string): {
+    isError: true;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export type SiteAgentClampedToolResult = ReturnType<typeof siteAgentClampedToolResult>;
+/**
+ * Null, or the refusal when `grant` is an agent started from a Site page
+ * (the Site clamp): such an agent cannot create or change `what`.
+ */
+export declare function siteAgentClampRefusal(deps: Pick<ApiRouteDeps, "db">, grant: AccessGrant, what: SiteClampedResource): Promise<SiteAgentClampedToolResult | null>;
+/**
+ * Null, or the refusal when `grant` is an agent started from a Site page:
+ * such an agent cannot run on, attach, swap or provision sandboxes or
+ * Connected Machines (the viewer's machines among them).
+ */
+export declare function siteAgentComputeRefusal(deps: Pick<ApiRouteDeps, "db">, grant: AccessGrant): Promise<SiteAgentClampedToolResult | null>;
+/** The first-party tools that write documents, spreadsheets and presentations. */
+export declare const SITE_AGENT_EDITABLE_ARTIFACT_WRITE_TOOLS: ReadonlySet<string>;
+export declare const SITE_AGENT_EDITABLE_ARTIFACT_RESOURCE: "documents, spreadsheets or presentations the Site did not declare";
+/**
+ * Whether a Site-clamped agent may write documents, spreadsheets and
+ * presentations: only when a published Site it was started from declares a
+ * first-party editing tool (`editable_artifact_create`, `_import` or
+ * `_apply`) in its current version's requested tools. Console frames (no
+ * published Site) and Sites that declare none may not; a read that fails
+ * refuses. Existing artifacts additionally need immutable creation provenance
+ * in this same Site-clamped session tree; merely reading/associating one is not
+ * authority to edit it. There is no explicit artifact declaration surface yet.
+ */
+export declare function siteAgentMayEditArtifacts(deps: Pick<ApiRouteDeps, "db">, grant: Pick<AccessGrant, "accountId" | "workspaceId" | "metadata">, clamp: SiteAgentClamp, artifactId?: string): Promise<boolean>;
+/** Null, or the refusal of an undeclared document, spreadsheet or presentation write. */
+export declare function siteAgentEditableArtifactRefusal(deps: Pick<ApiRouteDeps, "db">, grant: AccessGrant, artifactId?: string): Promise<SiteAgentClampedToolResult | null>;

package/dist/mcp/site-data-tools.d.ts

@@ -0,0 +1,22 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type AccessGrant } from "@opengeni/contracts";
+import type { ApiRouteDeps } from "@opengeni/core";
+import { type SiteAgentDataResolution } from "../site-publishing/agent-data-tools.js";
+type JsonResult = (value: unknown) => {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+};
+/**
+ * First-party Site Data tools. They act with the agent's own authority: the
+ * person it acts for (a chat's person or a schedule's owner) decides whether
+ * it manages the Site's data or is one of its viewers.
+ *
+ * A published Site's own agent (`siteAgent` resolves a Site context) is
+ * different: only `site_data_query` and `site_data_write` work, pinned to
+ * that Site (any other siteId is refused) and acting as the conversation's
+ * viewer, exactly as the Site's page does; every other tool refuses it.
+ */
+export declare function registerSiteDataTools(server: McpServer, deps: ApiRouteDeps, grant: AccessGrant, authorize: () => Promise<void>, json: JsonResult, siteAgent?: () => Promise<SiteAgentDataResolution>): void;
+export {};

package/dist/mcp/site-publication-tools.d.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type AccessGrant } from "@opengeni/contracts";
+import type { ApiRouteDeps } from "@opengeni/core";
+type JsonResult = (value: unknown) => {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+};
+/** What people outside the workspace may do, stated in every publication answer. */
+export declare const SITE_AUDIENCE_RULES = "Workspace members may use everything the Site declares, within what they may do in the workspace, and are never limited by Site limits. People outside the workspace (invited people and public visitors) get only the Site's own data: Site Data (by each collection's access mode, and its guest access for anonymous visitors), Site SQL named queries their audience allows, and the page. They never get workspace tools or subscription-billed models, and their assistant use counts toward the Site limit.";
+/**
+ * First-party tools for publishing a Site on its own hostname. They act with
+ * the agent's own authority: only a Site's managers (its owner, a workspace
+ * admin, or an agent acting for one) read or change its publication, and
+ * only a workspace admin changes its limits. Takedown stays with people.
+ */
+export declare function registerSitePublicationTools(server: McpServer, deps: ApiRouteDeps, grant: AccessGrant, authorize: () => Promise<void>, json: JsonResult): void;
+export {};

package/dist/mcp/site-sql-tools.d.ts

@@ -0,0 +1,27 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type AccessGrant } from "@opengeni/contracts";
+import type { ApiRouteDeps } from "@opengeni/core";
+import { type SiteAgentDataResolution } from "../site-publishing/agent-data-tools.js";
+type JsonResult = (value: unknown) => {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+};
+/**
+ * First-party Site SQL tools: optional per-Site Cloudflare storage (one SQLite
+ * database per Site). Only the Site's managers (its owner, a workspace admin,
+ * or an agent acting for them) can manage it; Site pages call named queries
+ * with site.sql.run, and so can agents with site_sql_run. The tools act with
+ * the agent's own authority, through the same service as the HTTP routes. An
+ * agent started from a Site page gets that page's reach (resolveSiteDataAccess):
+ * every management tool refuses it, and site_sql_run runs only the named
+ * queries the page itself could run, on that Site.
+ *
+ * A published Site's own agent (`siteAgent` resolves a Site context) gets
+ * `site_sql_run` as the conversation's viewer (audiences and `:viewer` as on
+ * the page) and, for workspace members, read-only `site_sql_query`; both are
+ * pinned to that Site and every other tool refuses it.
+ */
+export declare function registerSiteSqlTools(server: McpServer, deps: ApiRouteDeps, grant: AccessGrant, authorize: () => Promise<void>, json: JsonResult, siteAgent?: () => Promise<SiteAgentDataResolution>): void;
+export {};

package/dist/mcp-oauth.d.ts

@@ -1,10 +1,14 @@
-import { type AccessGrant, type ToolGatewayCatalog, type ToolGatewayIdentity } from "@opengeni/contracts";
+import { OrganizationAccessPolicy, type AccessGrant, type ToolGatewayCatalog, type ToolGatewayIdentity } from "@opengeni/contracts";
+import { type McpOAuthAccess } from "@opengeni/db";
 import { type ApiRouteDeps } from "@opengeni/core";
-import { Hono } from "hono";
+import { Hono, type Context } from "hono";
+/** One organization MCP server for everyone; the sign-in chooses the organization. */
+export declare const ORGANIZATION_MCP_PATH = "/v1/mcp";
 export type McpOAuthResource = {
     resource: string;
-    workspaceId: string;
-    kind: "all" | "docs" | "files";
+    /** Null for the organization server. */
+    workspaceId: string | null;
+    kind: "all" | "docs" | "files" | "organization";
 };
 export type McpOAuthRouteAccess = {
     grant: AccessGrant;
@@ -17,3 +21,32 @@ export declare function isMcpOAuthResourcePath(pathname: string): boolean;
 export declare function mcpOAuthConsentToolIdentities(catalog: ToolGatewayCatalog): ToolGatewayIdentity[];
 export declare function isMcpOAuthPublicProtocolPath(pathname: string): boolean;
 export declare function mcpOAuthAuthenticateHeader(deps: ApiRouteDeps, pathname: string): string;
+export declare function mcpOAuthRedirectUriCandidates(registered: string[], requested: string): string[];
+export declare function completeAuthorizationRedirect(c: Context, redirectTo: string): Response;
+export type McpOAuthConsentAccount = {
+    id: string;
+    name: string;
+};
+export type McpOAuthConsentWorkspace = {
+    id: string;
+    accountId: string;
+    name: string;
+    kind: "personal" | "shared";
+};
+export declare function renderMcpOAuthConsentPage(input: {
+    clientName: string;
+    requestToken: string;
+    accounts: McpOAuthConsentAccount[];
+    workspaces: McpOAuthConsentWorkspace[];
+    selectedWorkspaceId: string;
+}): string;
+export declare function renderMcpOAuthContinuePage(redirectTo: string): string;
+export declare function renderMcpOAuthExpiredPage(message: string): string;
+/**
+ * The organization connection behind an organization-server bearer, or null
+ * when the request carries no MCP OAuth token. Invalid, revoked, expired or
+ * workspace-bound tokens are refused.
+ */
+export declare function resolveOrganizationMcpOAuthAccess(deps: ApiRouteDeps, request: Request): Promise<(McpOAuthAccess & {
+    organizationAccess: OrganizationAccessPolicy;
+}) | null>;

package/dist/model-calls/chat-completions.d.ts

@@ -0,0 +1,87 @@
+import { ModelCallError, type ModelCallInput } from "@opengeni/core";
+import { type SingleModelCallResult } from "@opengeni/runtime/model-call";
+export type ParsedChatCompletionRequest = {
+    model: string | null;
+    request: ModelCallInput["request"];
+    stream: boolean;
+    includeUsage: boolean;
+};
+export declare function parseChatCompletionRequest(body: unknown): ParsedChatCompletionRequest;
+export declare function chatCompletionUsage(usage: SingleModelCallResult["usage"]): {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details: {
+        cached_tokens: number;
+    };
+    completion_tokens_details: {
+        reasoning_tokens: number;
+    };
+} | null;
+export declare function chatCompletionId(requestId: string): string;
+export declare function chatCompletionResponse(input: {
+    requestId: string;
+    created: number;
+    model: string;
+    result: SingleModelCallResult;
+}): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        message: {
+            role: string;
+            content: string;
+            refusal: null;
+        };
+        logprobs: null;
+        finish_reason: import("@opengeni/runtime").SingleModelCallFinishReason;
+    }[];
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        prompt_tokens_details: {
+            cached_tokens: number;
+        };
+        completion_tokens_details: {
+            reasoning_tokens: number;
+        };
+    } | null;
+};
+export declare function chatCompletionChunk(input: {
+    requestId: string;
+    created: number;
+    model: string;
+    delta: {
+        role?: "assistant";
+        content?: string;
+    };
+    finishReason: SingleModelCallResult["finishReason"] | null;
+    includeUsage: boolean;
+}): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: {
+            role?: "assistant";
+            content?: string;
+        };
+        logprobs: null;
+        finish_reason: import("@opengeni/runtime").SingleModelCallFinishReason | null;
+    }[];
+    usage?: null;
+};
+export declare function chatCompletionError(error: ModelCallError): {
+    error: {
+        message: string;
+        type: import("@opengeni/core").ModelCallErrorType;
+        param: string | null;
+        code: string | null;
+    };
+};

package/dist/model-calls/pending-usage-settlements.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Fast in-process retry for task usage receipts of attempt-authenticated
+ * single model calls. Durable custody lives in the database, not here.
+ *
+ * Before dispatch, admission opens a durable pending marker for the call's
+ * source identity (`model_call:<requestId>`). The provider response has
+ * already been returned when settlement runs, so a failed settlement is never
+ * fixed by calling the provider again:
+ *
+ * - the exact settlement is retained here and retried against the database
+ *   with bounded backoff until it lands (no expiry, no silent eviction);
+ * - the marker is fenced at once when possible, and any marker left unfilled
+ *   (fenced, or older than the overdue window after a crash or on another
+ *   replica) blocks new model requests for the whole task on every replica;
+ * - maintenance discloses a marker that is never filled as an unpriced call,
+ *   so coverage reads partial instead of complete.
+ *
+ * Settlement is idempotent on the source identity and fills the marker
+ * exactly once, so a retry racing a slow original write records usage once.
+ * When this process already retains `maxEntries` settlements it refuses new
+ * task calls instead of dropping any.
+ */
+export type RetainedSettlement = () => Promise<unknown>;
+export type PendingUsageSettlementsOptions = {
+    /** Upper bound on retained settlements across all sessions. */
+    maxEntries?: number;
+    /** First background retry delay; doubles up to `maxDelayMs`. */
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    /** Test hook; defaults to setTimeout with unref. */
+    schedule?: (fn: () => void, delayMs: number) => void;
+};
+export declare class PendingUsageSettlements {
+    private readonly options;
+    private readonly entries;
+    private readonly maxEntries;
+    private readonly initialDelayMs;
+    private readonly maxDelayMs;
+    constructor(options?: PendingUsageSettlementsOptions);
+    get size(): number;
+    /** True when no further settlement can be retained: new task calls are refused. */
+    get full(): boolean;
+    /** True when this session has a retained, not yet recorded settlement. */
+    has(sessionId: string): boolean;
+    /**
+     * Retain a failed settlement for exact DB-only retry. Returns false only
+     * when the process is already at capacity; the durable marker then remains
+     * the custody (fenced or overdue, later disclosed as unpriced).
+     */
+    retain(sessionId: string, sourceId: string, settle: RetainedSettlement): boolean;
+    /**
+     * Record every retained settlement of `sessionId`. Throws the first failure;
+     * successful ones are removed either way.
+     */
+    flush(sessionId: string): Promise<void>;
+    private scheduleRetry;
+}

package/dist/model-calls/service.d.ts

@@ -0,0 +1,36 @@
+import { type CodexFetch, type CodexUsagePayload } from "@opengeni/codex";
+import { type Settings } from "@opengeni/config";
+import type { EntitlementsPort } from "@opengeni/contracts";
+import { type SessionUsageLimitMetricsSink, type ModelCallService, type WorkspaceModelSelection } from "@opengeni/core";
+import { type Database } from "@opengeni/db";
+import { PendingUsageSettlements } from "./pending-usage-settlements.js";
+export type ModelCallServiceDeps = {
+    db: Database;
+    settings: Settings;
+    /** Catalog source settings; defaults to `settings`. */
+    catalogSourceSettings?: Settings;
+    entitlements?: EntitlementsPort | null;
+    codexFetch?: CodexFetch;
+    log?: (message: string, attributes: Record<string, string | number | boolean>) => void;
+    /** Content-free task usage-limit counters (closed-set labels). */
+    usageLimitMetrics?: SessionUsageLimitMetricsSink | null;
+    /** Retained task usage receipts awaiting DB-only recovery (tests inject one). */
+    pendingUsageSettlements?: PendingUsageSettlements;
+};
+export declare function createModelCallService(deps: ModelCallServiceDeps): ModelCallService;
+/**
+ * SuperGrok runs only on the shared subscription core, whose single-call
+ * `completion` operation stays Codex-only (design 5.3): this API neither
+ * lists nor serves a SuperGrok subscription model, so a request for one is
+ * `model_not_found` before admission, never a misleading capacity error.
+ */
+export declare function servedBySingleModelCalls(selection: WorkspaceModelSelection): boolean;
+/**
+ * Whether the account still has included plan usage. A single call never
+ * spends a ChatGPT account's paid extra credits: an exhausted or unverifiable
+ * account is skipped before anything reaches the provider.
+ */
+export declare function codexIncludedUsageAvailable(usage: CodexUsagePayload, now?: number): boolean;
+export declare function isModelCallAbort(error: unknown): boolean;
+/** Map a provider or runtime failure to a public error; aborts pass through. */
+export declare function publicModelCallError(error: unknown): unknown;

package/dist/model-catalog.d.ts

@@ -1,6 +1,6 @@
 import { type ConfiguredModel } from "@opengeni/config";
-import { ClientModel, type WorkspaceModelCatalogResponse as WorkspaceModelCatalogResponseType } from "@opengeni/contracts";
-import { type WorkspaceModelSelectionInput } from "@opengeni/core";
+import { ClientModel, type DefaultModelSelection, type WorkspaceModelCatalogResponse as WorkspaceModelCatalogResponseType } from "@opengeni/contracts";
+import { type WorkspaceModelSelection, type WorkspaceModelSelectionInput } from "@opengeni/core";
 export { MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS, type ModelAvailabilityObservation, type ModelCredentialReadinessObservation, } from "@opengeni/core";
 /** Static, client-safe definition projection. No provider secret is reachable. */
 export declare function projectClientModel(model: ConfiguredModel): ClientModel;
@@ -12,4 +12,10 @@ export declare function projectClientModel(model: ConfiguredModel): ClientModel;
  * successful typed resolver observation; credential health and provider health
  * are separate inputs and neither is fabricated.
  */
-export declare function buildWorkspaceModelCatalog(input: WorkspaceModelSelectionInput): WorkspaceModelCatalogResponseType;
+export declare function buildWorkspaceModelCatalog(input: WorkspaceModelSelectionInput, defaults?: WorkspaceModelCatalogDefaults): WorkspaceModelCatalogResponseType;
+/** Resolved new-chat defaults published beside the catalog rows. */
+export type WorkspaceModelCatalogDefaults = {
+    defaultSelection: DefaultModelSelection;
+    creditsSelection: DefaultModelSelection | null;
+};
+export declare function projectWorkspaceModelCatalog(selections: readonly WorkspaceModelSelection[], defaults?: WorkspaceModelCatalogDefaults): WorkspaceModelCatalogResponseType;

package/dist/native-push-dispatch.d.ts

@@ -0,0 +1,69 @@
+import type { Settings } from "@opengeni/config";
+import { type ClaimedNativePushDelivery, type Database, type NativePushOutcome } from "@opengeni/db";
+import type { Observability } from "@opengeni/observability";
+export type NativePushSendResult = {
+    outcome: NativePushOutcome;
+    error?: string;
+};
+export type NativePushSender = (delivery: ClaimedNativePushDelivery) => Promise<NativePushSendResult>;
+/** A claimed payload, marked when its question asks for a secret. */
+export type NativePushPayload = ClaimedNativePushDelivery["payload"] & {
+    secretQuestion?: boolean;
+};
+export type NativePushDispatchDeps = {
+    db: Database;
+    settings: Settings;
+    observability?: Pick<Observability, "info" | "warn" | "error">;
+    senders?: Partial<Record<"ios" | "android", NativePushSender>>;
+};
+/**
+ * A notification message as plain text for the lock screen: links keep their
+ * text, emphasis and code marks go, and "- " bullets become "•".
+ */
+export declare function plainNotificationText(markdown: string): string;
+/** The visible text of a push: title, optional subtitle, and the message with its facts. */
+export declare function nativePushAlert(payload: NativePushPayload): {
+    title: string;
+    subtitle?: string;
+    body?: string;
+};
+/**
+ * What breaks through Focus: an agent notification the agent marked
+ * time-sensitive, and questions and approvals for a person who asked for them
+ * to (their setting puts the urgency on the delivery). Everything else, and
+ * replies and failures always, arrive as ordinary alerts, so Focus and the
+ * person's own notification settings decide when they show.
+ */
+export declare function nativePushInterruptionLevel(payload: ClaimedNativePushDelivery["payload"]): "time-sensitive" | "active";
+/** What the app reads on tap: enough to open the session in the right account. */
+export declare function nativePushData(payload: ClaimedNativePushDelivery["payload"]): {
+    sessionId: string;
+    workspaceId: string;
+    subjectId: string;
+    rule: "agent" | "failed" | "needs_input" | "reply_ready";
+    eventType?: string;
+    sequence?: number;
+};
+/**
+ * The notification category the app registers actions for: an approval can be
+ * approved (behind device unlock) or denied, a question answered inline.
+ */
+export declare function nativePushCategory(payload: NativePushPayload): "og.approval" | "og.question" | undefined;
+/** APNs with a token-based (.p8) key; one HTTP/2 connection per environment. */
+export declare function createApnsSender(input: {
+    keyId: string;
+    teamId: string;
+    privateKey: string;
+}): NativePushSender;
+/** FCM HTTP v1 with a service account; data-only, so the app presents it. */
+export declare function createFcmSender(input: {
+    serviceAccountJson: string;
+    fetch?: typeof fetch;
+}): NativePushSender;
+/** The senders this deployment has credentials for. */
+export declare function configuredNativePushSenders(settings: Settings): Partial<Record<"ios" | "android", NativePushSender>>;
+export declare function drainNativePushDeliveries(deps: NativePushDispatchDeps): Promise<{
+    claimed: number;
+    delivered: number;
+}>;
+export declare function startNativePushDispatchPump(deps: NativePushDispatchDeps): () => Promise<void>;

package/dist/observability.d.ts

@@ -1,3 +1,5 @@
-import type { EventLogger } from "@opengeni/events";
+import { type EventBusOptions, type EventLogger } from "@opengeni/events";
 import type { Observability } from "@opengeni/observability";
+/** Logger plus the closed-label subscription-termination counter for NATS connections. */
+export declare function observabilityEventBusOptions(observability: Observability): Pick<EventBusOptions, "logger" | "onSubscriptionTerminated">;
 export declare function observabilityEventLogger(observability: Observability): EventLogger;