@opengeni/api-router 0.12.7 → 0.14.3

package/dist/mcp/server.d.ts

@@ -0,0 +1,107 @@
+import { type AccessGrant } from "@opengeni/contracts";
+import { listSessionDiscoverySummaries, type SessionDiscoveryCursor, type SessionDiscoveryOrderBy } from "@opengeni/db";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiRouteDeps } from "@opengeni/core";
+import type { ToolspaceMcpSurface } from "./toolspace";
+export type McpServerOptions = {
+    requestOrigin?: string | null;
+    toolspace?: ToolspaceMcpSurface | null;
+    workspaceMemoryEnabled?: boolean | undefined;
+};
+export declare function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, options?: McpServerOptions): McpServer;
+/** Only a prompt explicitly supplied through the human/API channel may redirect a user-paused goal. */
+export declare function isHumanDirectedTurn(turn: {
+    source: string;
+}): boolean;
+/**
+ * Sacred user pause: a goal a human paused (pausedReason 'user_pause') must
+ * never be resurrected by a MACHINE turn. Child-completion notification turns
+ * carry a "resume it now" nudge; without this guard the agent processing one of
+ * them would call goal_set and re-arm the exact autonomous loop the user just
+ * paused (the runaway that made Pause feel broken). A genuine user message
+ * still redirects freely (it is not a child-notification turn), and the
+ * human-driven API resume path (PATCH /goal) is unaffected.
+ *
+ * Classification is by CALLER IDENTITY — `callerTurnId` is the turn that minted
+ * this MCP token (signed into it by the worker at turn setup). We deliberately
+ * do NOT read the session's live `active_turn_id`: that pointer can flip to a
+ * different turn between reads (a machine turn ends and a human turn becomes
+ * active mid-check), which would misclassify the caller and, worst case, refuse
+ * a legitimate human `goal_set` — inverting the guard against the very human
+ * power it must preserve. A caller turn's source/metadata are immutable, so this
+ * read is race-free. No caller identity ⇒ fail OPEN (only a positively
+ * identified machine child-notification caller is refused).
+ */
+export declare function assertGoalReactivationAllowed(deps: ApiRouteDeps, workspaceId: string, sessionId: string, callerTurnId: string | null): Promise<void>;
+export declare function encodeSessionDiscoveryCursor(cursor: SessionDiscoveryCursor): string;
+export declare function decodeSessionDiscoveryCursor(value: string): SessionDiscoveryCursor;
+export declare function capSessionDiscoveryPage(page: Awaited<ReturnType<typeof listSessionDiscoverySummaries>>, includeLastMessage: boolean): {
+    sessions: {
+        id: string;
+        title: string | null;
+        titleTruncated: boolean;
+        parentSessionId: string | null;
+        isRoot: boolean;
+        status: "cancelled" | "failed" | "idle" | "queued" | "recovering" | "requires_action" | "running" | "waiting_capacity";
+        pause: {
+            state: import("@opengeni/db").EffectiveControlState;
+            additionalBlockerCount: number;
+            source: {
+                kind: "session" | "workspace";
+                sessionId?: string;
+                displayName: string | null;
+                displayNameTruncated: boolean;
+            } | null;
+        };
+        goal: {
+            status: "active" | "completed" | "paused";
+            summary: string | null;
+            summaryTruncated: boolean;
+        } | null;
+        queuedPromptCount: number;
+        children: {
+            directChildren: number;
+            totalDescendants: number;
+            runningDescendants: number;
+            queuedDescendants: number;
+            attentionDescendants: number;
+            pausedDescendants: number;
+            failedDescendants: number;
+            truncated: boolean;
+        };
+        latestMessage?: {
+            type: "agent.message.completed" | "agent.message.delta" | "agent.model.request" | "agent.model.usage" | "agent.reasoning.delta" | "agent.toolCall.created" | "agent.toolCall.output" | "agent.updated" | "artifact.created" | "codex.account.switched" | "codex.capacity.resumed" | "codex.capacity.superseded" | "codex.capacity.waiting" | "codex.credential.selected" | "codex.fleet.decision" | "credential.auth_needed" | "fs.changed" | "git.changed" | "goal.cleared" | "goal.completed" | "goal.continuation" | "goal.paused" | "goal.resumed" | "goal.set" | "goal.updated" | "machine.link.lost" | "machine.link.restored" | "machine.op.failed" | "machine.op.recovered" | "machine.runner.restarted" | "memory.corrected" | "memory.saved" | "recording.available" | "recording.failed" | "recording.started" | "rig.setup.completed" | "rig.setup.failed" | "rig.setup.skipped" | "rig.setup.started" | "sandbox.box.created" | "sandbox.box.lost" | "sandbox.box.snapshot" | "sandbox.box.terminated" | "sandbox.command.output.delta" | "sandbox.env.drift" | "sandbox.operation.completed" | "sandbox.operation.failed" | "sandbox.operation.started" | "session.context.cleared" | "session.context.compacted" | "session.context.compaction.requested" | "session.context.compaction.skipped" | "session.context.compaction.started" | "session.control.paused" | "session.control.resumed" | "session.control.steer_requested" | "session.created" | "session.event.envelope_omitted" | "session.humanInput.requested" | "session.mcp.approval_policy.updated" | "session.queue.changed" | "session.queue.history" | "session.queue.prompt.cancelled" | "session.requiresAction" | "session.route.reconciled" | "session.status.changed" | "session.title_set" | "session.tool_policy.updated" | "stream.closed" | "stream.opened" | "stream.revoked" | "stream.url.rotated" | "system.update.cancelled" | "system.update.delivered" | "system.update.pending" | "system.update.settled" | "system.update.superseded" | "terminal.pty.exited" | "terminal.pty.output.delta" | "terminal.pty.started" | "tool.auth_needed" | "turn.cancelled" | "turn.capacity_waiting" | "turn.completed" | "turn.event.rejected_late" | "turn.failed" | "turn.queued" | "turn.recovery.requested" | "turn.started" | "turn.superseded" | "user.approvalDecision" | "user.humanInputResponse" | "user.message" | "user.pause" | "workspace.inference.paused" | "workspace.inference.resumed" | "workspace.revision.captured" | "workspace.revision.degraded";
+            preview: string | null;
+            previewTruncated: boolean;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    total: number;
+    hasMore: boolean;
+    nextCursor: string | null;
+    orderBy: SessionDiscoveryOrderBy;
+    snapshotAt: string;
+    snapshotRevision: string;
+    updatedAfter: string | null;
+    updatedThrough: string | null;
+    latestMessagePreviewBudget?: {
+        bytes: number;
+        maxBytes: number;
+        omittedCount: number;
+        truncated: boolean;
+        omissionReason: "aggregatePreviewBudget" | null;
+        drillDownTool: "session_events";
+        drillDownInput: {
+            direction: "before";
+            limit: 1;
+            mode: "monitoring";
+            payloadMode: "summary";
+            includeTypes: readonly ["user.message", "agent.message.completed"];
+        };
+    };
+    responseTruncated: boolean;
+    truncationReason?: string;
+    bytes: number;
+    maxBytes: number;
+};

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

@@ -0,0 +1,191 @@
+/**
+ * Model-facing projections for cross-session monitoring tools.
+ *
+ * `session_events` reads are selected tail/forward and filtered in PostgreSQL;
+ * this module is the independent final guard before JSON enters a manager
+ * model's context. It measures the exact pretty-printed MCP text, trims fat
+ * payload fields, and—only if still required—removes rows from the pagination
+ * edge while preserving a usable cursor. It never manufactures an event or
+ * advances across an event it did not return.
+ */
+import type { Rig, Session, SessionEvent, SessionEventCompactResult, SessionEventPayloadMode, SessionEventReadDirection, SessionEventReadMode } from "@opengeni/contracts";
+export declare const SESSION_EVENT_MCP_MAX_BYTES: number;
+export declare const SESSION_EVENT_MCP_FIELD_MAX_CHARS = 4000;
+export declare const DEFAULT_SESSION_DETAIL_CHARS = 6000;
+export declare const SESSION_DETAIL_MCP_MAX_BYTES: number;
+export declare const RIG_DETAIL_MCP_MAX_BYTES: number;
+/**
+ * Keep the single-result MCP response below the same pretty-JSON envelope as
+ * event pages. The contracts projection bounds each value independently for
+ * HTTP/SDK use; this second boundary accounts for the result identity,
+ * failure/truncation metadata, and MCP's pretty-printing overhead.
+ */
+export declare function boundSessionEventCompactResult(result: SessionEventCompactResult, maxBytes?: number): SessionEventCompactResult;
+/** Recursively clamp fat leaves and collapse pathological containers. */
+export declare function capPayloadValue(value: unknown, perFieldChars: number, depth?: number): unknown;
+export declare function capEventPayload(event: SessionEvent, perFieldChars: number): SessionEvent;
+export type SessionEventMcpPageInput = {
+    events: readonly SessionEvent[];
+    mode: SessionEventReadMode;
+    payloadMode: SessionEventPayloadMode;
+    direction: SessionEventReadDirection;
+    sourceHasMore: boolean;
+    sourceTruncatedBy: "count" | "bytes" | null;
+    after: number;
+    before: number | null;
+    maxBytes?: number | undefined;
+};
+export type SessionEventMcpPage = {
+    mode: SessionEventReadMode;
+    payloadMode: SessionEventPayloadMode;
+    direction: SessionEventReadDirection;
+    events: SessionEvent[];
+    coveredSequence: {
+        first: number;
+        last: number;
+    } | null;
+    nextAfter: number | null;
+    nextBefore: number | null;
+    hasMore: boolean;
+    truncated: boolean;
+    truncation?: {
+        reasons: Array<"source_count" | "source_bytes" | "model_payload" | "model_bytes">;
+        omittedSide: "before" | "after";
+        resumeCursor: number | null;
+    };
+    bytes: number;
+    maxBytes: number;
+};
+/**
+ * Build the exact model-visible page. Returned `bytes` includes all metadata
+ * and pretty-printing used by the MCP JSON adapter.
+ */
+export declare function boundSessionEventMcpPage(input: SessionEventMcpPageInput): SessionEventMcpPage;
+type SessionDetailFieldFact = {
+    truncated: boolean;
+    originalBytes: number | null;
+    deliveredBytes: number;
+    originalCount?: number;
+    deliveredCount?: number;
+    measurementBounded?: boolean;
+};
+/** Purpose-built, flat, model-facing detail projection for `session_get`. */
+export declare function boundSessionDetailMcp(session: Session, effectiveControl?: unknown, maxBytes?: number): {
+    id: string;
+    workspaceId: string;
+    accountId: string;
+    status: "cancelled" | "failed" | "idle" | "queued" | "recovering" | "requires_action" | "running" | "waiting_capacity";
+    title: string | null;
+    titleSource: "agent" | "user" | null;
+    initialMessage: string;
+    instructions: string | null;
+    resources: unknown;
+    tools: unknown;
+    metadata: unknown;
+    model: string;
+    sandboxBackend: string;
+    sandboxOs: "linux" | "macos" | "windows";
+    sandboxGroupId: string;
+    activeSandboxId: string | null;
+    activeEpoch: number;
+    variableSetId: string | null;
+    environmentId: string | null;
+    rigId: string | null;
+    rigVersionId: string | null;
+    firstPartyMcpPermissions: unknown;
+    mcpServers: unknown;
+    parentSessionId: string | null;
+    createIdempotencyKey: string | null;
+    temporalWorkflowId: string | null;
+    activeTurnId: string | null;
+    lastInputTokens: number | null;
+    queueVersion: number;
+    queueHeadPosition: number;
+    queueTailPosition: number;
+    effectiveControl: unknown;
+    lastSequence: number;
+    codexPinnedCredentialId: string | null;
+    codexLastCredentialId: string | null;
+    codexCompactionMode: "portable" | "remote_v2";
+    pinned: boolean;
+    pinnedAt: string | null;
+    pinVersion: number;
+    treeStats?: {
+        directChildren: number;
+        totalDescendants: number;
+        runningDescendants: number;
+        queuedDescendants: number;
+        attentionDescendants: number;
+        pausedDescendants: number;
+        failedDescendants: number;
+        truncated: boolean;
+    };
+    createdAt: string;
+    updatedAt: string;
+    projection: {
+        truncated: boolean;
+        fields: Record<string, SessionDetailFieldFact>;
+        details: string[];
+        bytes: number;
+        maxBytes: number;
+    };
+};
+/** @deprecated use boundSessionDetailMcp for the actual MCP response. */
+export declare function capSessionDetail<T extends {
+    metadata?: unknown;
+    initialMessage?: unknown;
+}>(session: T, perFieldChars?: number): T;
+/** Bounded current definition plus compact-by-query historical rig summaries. */
+export declare function boundRigDetailMcp(rig: Rig, versionsPage: {
+    versions: unknown[];
+    total: number;
+    hasMore: boolean;
+}, changesPage: {
+    changes: unknown[];
+    total: number;
+    hasMore: boolean;
+}, maxBytes?: number): {
+    rig: {
+        id: string;
+        accountId: string;
+        workspaceId: string;
+        name: string;
+        description: string | null;
+        createdBy: string | null;
+        activeVersion: {
+            id: string;
+            rigId: string;
+            version: number;
+            image: string | null;
+            setupScript: string | null;
+            checks: unknown;
+            credentialHooks: unknown;
+            defaultVariableSetIds: unknown;
+            changelog: string | null;
+            createdBy: string | null;
+            active: boolean;
+            createdAt: string;
+        } | null;
+        activeVersionHealth: {
+            checkHealth: "failing" | "passing" | "unknown";
+            lastVerifiedAt: string | null;
+        } | null;
+        versionCount: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+    versions: unknown;
+    versionsTotal: number;
+    versionsTruncated: boolean;
+    changes: unknown;
+    changesTotal: number;
+    changesTruncated: boolean;
+    projection: {
+        truncated: boolean;
+        fields: Record<string, SessionDetailFieldFact>;
+        details: string[];
+        bytes: number;
+        maxBytes: number;
+    };
+};
+export {};

package/dist/mcp/toolspace.d.ts

@@ -0,0 +1,61 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type McpServerConfig } from "@opengeni/config";
+import { type AccessGrant, type SessionTurn } from "@opengeni/contracts";
+import { type ApiRouteDeps } from "@opengeni/core";
+import { type FetchLike } from "@opengeni/network";
+export type ToolspaceCallResult = CallToolResult;
+export type ToolspaceRegisteredTool = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    call: (args: Record<string, unknown>) => Promise<ToolspaceCallResult>;
+};
+export type ToolspaceMcpSurface = {
+    sessionId: string;
+    subjectId: string;
+    tools: ToolspaceRegisteredTool[];
+    close: () => Promise<void>;
+};
+type McpTool = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export type ToolListingEntry = {
+    serverId: string;
+    tool: McpTool;
+    requireApproval: McpServerConfig["requireApproval"];
+};
+/** Deterministic LRU bounded by both key count and serialized retained bytes. */
+export declare class ToolspaceToolListCache {
+    private readonly maxEntries;
+    private readonly maxBytes;
+    private readonly ttlMs;
+    private readonly values;
+    private retainedBytes;
+    constructor(maxEntries?: number, maxBytes?: number, ttlMs?: number);
+    read(key: string, now?: number): ToolListingEntry[] | null;
+    write(key: string, entries: ToolListingEntry[], now?: number): boolean;
+    clear(): void;
+    snapshot(): {
+        entries: number;
+        bytes: number;
+        keys: string[];
+    };
+    private delete;
+}
+export declare function isToolspaceGrant(settings: ApiRouteDeps["settings"], grant: AccessGrant): boolean;
+export declare function prepareToolspaceMcpSurface(input: {
+    deps: ApiRouteDeps;
+    grant: AccessGrant;
+}): Promise<ToolspaceMcpSurface | null>;
+export declare function toolspaceCanProxyServerId(serverId: string): boolean;
+export declare function connectionBrokerFetch(baseFetch: FetchLike, input: {
+    deps: ApiRouteDeps;
+    grant: AccessGrant;
+    config: McpServerConfig;
+    sessionId: string;
+    rootSessionId: string;
+    turn: SessionTurn;
+}): FetchLike;
+export {};

package/dist/model-catalog.d.ts

@@ -0,0 +1,39 @@
+import { type ConfiguredModel, type Settings } from "@opengeni/config";
+import { ClientModel, type WorkspaceModelCatalogResponse as WorkspaceModelCatalogResponseType, type WorkspaceModelPolicyContract } from "@opengeni/contracts";
+export type ModelAvailabilityObservation = {
+    status: "available" | "degraded" | "unavailable";
+    reason: "not_entitled" | "provider_unhealthy" | null;
+    checkedAt: string;
+};
+export type ModelCredentialReadinessObservation = {
+    status: "ready";
+    checkedAt: string;
+} | {
+    status: "not_ready";
+    reason: "prerequisites_missing" | "needs_reauth";
+    checkedAt: string;
+} | {
+    status: "error";
+    reason: "resolver_error";
+    checkedAt: string;
+};
+export declare const MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS: number;
+/** Static, client-safe definition projection. No provider secret is reachable. */
+export declare function projectClientModel(model: ConfiguredModel): ClientModel;
+/**
+ * Authenticated workspace catalog. Codex definitions are included only when
+ * the deployment enables that connection type; concrete readiness is supplied
+ * by the existing metadata-only DB seam. API-key presence establishes only
+ * local configuration readiness. Federated/token credentials require a fresh,
+ * successful typed resolver observation; credential health and provider health
+ * are separate inputs and neither is fabricated.
+ */
+export declare function buildWorkspaceModelCatalog(input: {
+    settings: Settings;
+    policy: WorkspaceModelPolicyContract | null;
+    codexSubscriptionActive: boolean;
+    credentialReadinessObservations?: Readonly<Record<string, ModelCredentialReadinessObservation>> | undefined;
+    observations?: Readonly<Record<string, ModelAvailabilityObservation>> | undefined;
+    now?: Date | undefined;
+    credentialReadinessMaxAgeMs?: number | undefined;
+}): WorkspaceModelCatalogResponseType;

package/dist/observability.d.ts

@@ -0,0 +1,3 @@
+import type { EventLogger } from "@opengeni/events";
+import type { Observability } from "@opengeni/observability";
+export declare function observabilityEventLogger(observability: Observability): EventLogger;

package/dist/routes/api-keys.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerApiKeyRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/billing.d.ts

@@ -0,0 +1,16 @@
+import type { Hono } from "hono";
+import Stripe from "stripe";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerBillingRoutes(app: Hono, deps: ApiRouteDeps): void;
+export declare function stripeCheckoutSessionCreateParams(input: {
+    accountId: string;
+    customerId: string;
+    amountCents: number;
+    amountMicros: number;
+    creditsProductId?: string | undefined;
+    publicBaseUrl?: string | undefined;
+    successUrl?: string | undefined;
+    cancelUrl?: string | undefined;
+    idempotencyKey: string;
+}): Stripe.Checkout.SessionCreateParams;
+export declare function stripeCustomerProvider(input: ApiRouteDeps | Stripe.Event): "stripe:live" | "stripe:test";

package/dist/routes/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerCapabilityRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/catalog-assets.d.ts

@@ -0,0 +1,5 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerCatalogAssetRoutes(app: Hono, deps: ApiRouteDeps): void;
+/** Decoded, validated storage key from a `/v1/catalog-assets/...` request path, or null if malformed/unsafe. */
+export declare function catalogAssetKeyFromPath(pathname: string): string | null;

package/dist/routes/codex.d.ts

@@ -0,0 +1,10 @@
+export declare function codexModelsForPicker(liveSlugs: readonly string[]): Array<{
+    id: string;
+    label: string;
+    provider: string;
+    providerLabel: string;
+    api: "responses";
+}>;
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerCodexRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/connections.d.ts

@@ -0,0 +1,3 @@
+import type { ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerConnectionRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/documents.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/enrollments.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerEnrollmentRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/environments.d.ts

@@ -0,0 +1,5 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerVariableSetRoutes(app: Hono, deps: ApiRouteDeps): void;
+/** @deprecated use registerVariableSetRoutes */
+export declare const registerEnvironmentRoutes: typeof registerVariableSetRoutes;

package/dist/routes/files.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void;
+export declare function sanitizeFilename(filename: string): string;

package/dist/routes/github.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerGitHubRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/insights.d.ts

@@ -0,0 +1,3 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerInsightsRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/install.d.ts

@@ -0,0 +1,5 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerInstallRoutes(app: Hono, deps: ApiRouteDeps): void;
+export declare const installExactPaths: ReadonlySet<string>;
+export declare function isInstallRedirectPath(path: string): boolean;

package/dist/routes/machines.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerMachineRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/packs.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerPackRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/preference-registry.d.ts

@@ -0,0 +1,5 @@
+import { type PreferenceRegistryScope } from "@opengeni/contracts";
+import { type AccessGrantAuthorization, type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function authorizePreferenceRegistryScopeMutation(access: AccessGrantAuthorization, scope: PreferenceRegistryScope): void;
+export declare function registerPreferenceRegistryRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/rigs.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerRigRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/scheduled-tasks.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/sessions.d.ts

@@ -0,0 +1,15 @@
+import { type SessionAuthorizationOperation } from "@opengeni/contracts";
+import type { Context, Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+import { type ViewerServices } from "../sandbox/viewer";
+type SessionRouteDeps = ApiRouteDeps & Pick<ViewerServices, "establishSandboxSession">;
+export declare function registerSessionRoutes(app: Hono, deps: SessionRouteDeps): void;
+/**
+ * Map every mounted session-addressed HTTP path to the host-neutral operation
+ * the embedding port authorizes. Returning null is deliberately fail-closed in
+ * host-managed mode; standalone deployments never consult this classifier.
+ */
+export declare function sessionAuthorizationOperationForHttp(method: string, pathname: string, sessionId: string): SessionAuthorizationOperation | null;
+/** Stable, value-free JSON errors for only the create-session boundary. */
+export declare function sessionCreateErrorResponse(c: Context, error: unknown): Response;
+export {};

package/dist/routes/social.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+export declare function registerSocialRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/transcriptions.d.ts

@@ -0,0 +1,3 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerTranscriptionRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/workspace-capture.d.ts

@@ -0,0 +1,59 @@
+import { GetWorkspaceCaptureFileResponse, GetWorkspaceCaptureResponse, WorkspaceCaptureManifest, WorkspaceCaptureStats } from "@opengeni/contracts";
+import type { WorkspaceCaptureRow } from "@opengeni/db";
+export declare const CAPTURE_INLINE_MANIFEST_MAX_BYTES: number;
+export declare const CAPTURE_INLINE_FILE_MAX_BYTES: number;
+export declare const CAPTURE_SIGNED_URL_TTL_SECONDS = 300;
+export type CaptureStoragePort = {
+    getObjectBytes: (key: string) => Promise<{
+        bytes: Uint8Array;
+    } | null>;
+    createGetUrl: (args: {
+        key: string;
+        expiresInSeconds?: number;
+    }) => Promise<{
+        url: string;
+        expiresAt: Date;
+    }>;
+};
+type LoadedManifest = {
+    manifest: WorkspaceCaptureManifest;
+    byteLength: number;
+    stats: WorkspaceCaptureStats;
+};
+/**
+ * Process-local cache for immutable capture manifests. Capture rows point at a
+ * revision-specific object key, so a successfully validated blob is safe to
+ * reuse as long as the row identity still matches. Both entry count and bytes
+ * are bounded; large signed-manifest responses bypass the cache.
+ */
+export declare class WorkspaceCaptureManifestCache {
+    #private;
+    readonly maxEntries: number;
+    readonly maxBytes: number;
+    constructor(maxEntries?: number, maxBytes?: number);
+    get(row: WorkspaceCaptureRow): LoadedManifest | null;
+    getInlineResponse(row: WorkspaceCaptureRow): Extract<GetWorkspaceCaptureResponse, {
+        available: true;
+    }> | null;
+    setInlineResponse(row: WorkspaceCaptureRow, response: Extract<GetWorkspaceCaptureResponse, {
+        available: true;
+    }>): void;
+    set(row: WorkspaceCaptureRow, loaded: LoadedManifest): void;
+}
+/**
+ * Shape the GET …/workspace/capture response from a loaded row. `{available:false}`
+ * when there is no capture yet, the row is not in the `available` state, or its
+ * manifest blob has been GC'd (all graceful cold-fallback states — never errors).
+ * Inline manifest for ≤2MB, signed URL above.
+ */
+export declare function serveWorkspaceCapture(row: WorkspaceCaptureRow | null, storage: CaptureStoragePort, cache?: WorkspaceCaptureManifestCache): Promise<GetWorkspaceCaptureResponse>;
+/**
+ * Shape the GET …/workspace/capture/file response from a loaded row (the row
+ * already resolved to the requested revision, or the latest). Throws
+ * HTTPException(404) when there is no capture, the path is not in the manifest,
+ * or the file was deleted. Returns a metadata-only marker for a tooLarge file (or
+ * a captured file whose after-image blob is missing). Inline content for ≤256KB,
+ * signed URL above.
+ */
+export declare function serveWorkspaceCaptureFile(row: WorkspaceCaptureRow | null, path: string, storage: CaptureStoragePort): Promise<GetWorkspaceCaptureFileResponse>;
+export {};

package/dist/routes/workspace-instruction-policies.d.ts

@@ -0,0 +1,3 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerWorkspaceInstructionPolicyRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/workspace-state.d.ts

@@ -0,0 +1,3 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerWorkspaceStateRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/workspaces.d.ts

@@ -0,0 +1,5 @@
+import type { Hono } from "hono";
+import type { ApiRouteDeps } from "@opengeni/core";
+import { type Settings } from "@opengeni/config";
+export declare function canonicalWorkspacePolicyModelIds(settings: Settings, modelIds: string[] | null | undefined): string[] | null;
+export declare function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void;