@opengeni/api-router 0.21.14 → 0.23.1

package/dist/mcp/scheduled-task-view.d.ts

@@ -0,0 +1,350 @@
+import type { ScheduledTask, ScheduledTaskScheduleSpec } from "@opengeni/contracts";
+export declare const SCHEDULED_TASK_MCP_MAX_BYTES: number;
+export declare const SCHEDULED_TASK_NAME_MAX_BYTES = 512;
+export declare const SCHEDULED_TASK_PROMPT_MAX_BYTES: number;
+export declare const SCHEDULED_TASK_SCHEDULE_FIELD_MAX_BYTES = 256;
+type Utf8Projection = {
+    value: string;
+    originalBytes: number;
+    deliveredBytes: number;
+    truncated: boolean;
+};
+export type ScheduledTaskUtf8ProjectionFact = Omit<Utf8Projection, "value">;
+type ScheduledTaskScheduleProjection = {
+    schedule: Extract<ScheduledTaskScheduleSpec, {
+        type: "once";
+    }>;
+    projection: {
+        type: "once";
+        truncated: boolean;
+        fields: {
+            runAt: ScheduledTaskUtf8ProjectionFact;
+            timeZone: ScheduledTaskUtf8ProjectionFact;
+        };
+    };
+} | {
+    schedule: Extract<ScheduledTaskScheduleSpec, {
+        type: "interval";
+    }>;
+    projection: {
+        type: "interval";
+        truncated: boolean;
+        fields: {
+            startAt: ScheduledTaskUtf8ProjectionFact | null;
+            endAt: ScheduledTaskUtf8ProjectionFact | null;
+        };
+    };
+} | {
+    schedule: Extract<ScheduledTaskScheduleSpec, {
+        type: "calendar";
+    }>;
+    projection: {
+        type: "calendar";
+        truncated: boolean;
+        fields: {
+            timeZone: ScheduledTaskUtf8ProjectionFact;
+        };
+    };
+};
+export declare function projectScheduledTaskUtf8(value: string, maxBytes: number): Utf8Projection;
+export declare function projectScheduledTaskSchedule(schedule: ScheduledTaskScheduleSpec): ScheduledTaskScheduleProjection;
+export declare function scheduledTaskMcpSummary(task: ScheduledTask): {
+    id: string;
+    name: string;
+    status: "active" | "paused";
+    schedule: {
+        type: "once";
+        runAt: string;
+        timeZone: string;
+    } | {
+        type: "interval";
+        everySeconds: number;
+        startAt?: string | undefined;
+        endAt?: string | undefined;
+    } | {
+        type: "calendar";
+        timeZone: string;
+        hour: number;
+        minute: number;
+        daysOfWeek?: ("FRIDAY" | "MONDAY" | "SATURDAY" | "SUNDAY" | "THURSDAY" | "TUESDAY" | "WEDNESDAY")[] | undefined;
+    };
+    runMode: "existing_session" | "new_session_per_run" | "reusable_session";
+    overlapPolicy: "allow_concurrent" | "buffer_one" | "skip";
+    targetSessionId: string | null;
+    reusableSessionId: string | null;
+    variableSetId: string | null;
+    rigId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    configuration: {
+        model: string | null;
+        reasoningEffort: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | null;
+        sandboxBackend: "blaxel" | "cloudflare" | "daytona" | "docker" | "e2b" | "local" | "modal" | "none" | "runloop" | "selfhosted" | "vercel" | null;
+        hasGoal: boolean;
+        promptBytes: number;
+        resourceCount: number;
+        toolCount: number;
+        metadataKeyCount: number;
+        taskMetadataKeyCount: number;
+    };
+    projection: {
+        bounded: boolean;
+        name: ScheduledTaskUtf8ProjectionFact;
+        schedule: {
+            type: "once";
+            truncated: boolean;
+            fields: {
+                runAt: ScheduledTaskUtf8ProjectionFact;
+                timeZone: ScheduledTaskUtf8ProjectionFact;
+            };
+        } | {
+            type: "interval";
+            truncated: boolean;
+            fields: {
+                startAt: ScheduledTaskUtf8ProjectionFact | null;
+                endAt: ScheduledTaskUtf8ProjectionFact | null;
+            };
+        } | {
+            type: "calendar";
+            truncated: boolean;
+            fields: {
+                timeZone: ScheduledTaskUtf8ProjectionFact;
+            };
+        };
+        model: ScheduledTaskUtf8ProjectionFact | null;
+        createdAt: ScheduledTaskUtf8ProjectionFact;
+        updatedAt: ScheduledTaskUtf8ProjectionFact;
+        bytes: number;
+        maxBytes: number;
+    };
+};
+export declare function boundScheduledTaskDetailMcp(task: ScheduledTask): {
+    id: string;
+    name: string;
+    status: "active" | "paused";
+    schedule: {
+        type: "once";
+        runAt: string;
+        timeZone: string;
+    } | {
+        type: "interval";
+        everySeconds: number;
+        startAt?: string | undefined;
+        endAt?: string | undefined;
+    } | {
+        type: "calendar";
+        timeZone: string;
+        hour: number;
+        minute: number;
+        daysOfWeek?: ("FRIDAY" | "MONDAY" | "SATURDAY" | "SUNDAY" | "THURSDAY" | "TUESDAY" | "WEDNESDAY")[] | undefined;
+    };
+    runMode: "existing_session" | "new_session_per_run" | "reusable_session";
+    overlapPolicy: "allow_concurrent" | "buffer_one" | "skip";
+    targetSessionId: string | null;
+    reusableSessionId: string | null;
+    variableSetId: string | null;
+    rigId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    configuration: {
+        model: string | null;
+        reasoningEffort: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | null;
+        sandboxBackend: "blaxel" | "cloudflare" | "daytona" | "docker" | "e2b" | "local" | "modal" | "none" | "runloop" | "selfhosted" | "vercel" | null;
+        hasGoal: boolean;
+        promptBytes: number;
+        resourceCount: number;
+        toolCount: number;
+        metadataKeyCount: number;
+        taskMetadataKeyCount: number;
+    };
+    projection: {
+        bounded: boolean;
+        name: ScheduledTaskUtf8ProjectionFact;
+        schedule: {
+            type: "once";
+            truncated: boolean;
+            fields: {
+                runAt: ScheduledTaskUtf8ProjectionFact;
+                timeZone: ScheduledTaskUtf8ProjectionFact;
+            };
+        } | {
+            type: "interval";
+            truncated: boolean;
+            fields: {
+                startAt: ScheduledTaskUtf8ProjectionFact | null;
+                endAt: ScheduledTaskUtf8ProjectionFact | null;
+            };
+        } | {
+            type: "calendar";
+            truncated: boolean;
+            fields: {
+                timeZone: ScheduledTaskUtf8ProjectionFact;
+            };
+        };
+        model: ScheduledTaskUtf8ProjectionFact | null;
+        createdAt: ScheduledTaskUtf8ProjectionFact;
+        updatedAt: ScheduledTaskUtf8ProjectionFact;
+        bytes: number;
+        maxBytes: number;
+    };
+    entity: {
+        agentConfig: {
+            prompt: string;
+            resources: Record<string, unknown>[];
+            tools: Record<string, unknown>[];
+            metadataKeys: string[];
+            model: string | null;
+            reasoningEffort: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | null;
+            sandboxBackend: "blaxel" | "cloudflare" | "daytona" | "docker" | "e2b" | "local" | "modal" | "none" | "runloop" | "selfhosted" | "vercel" | null;
+            goal: {
+                text: string;
+                successCriteria: string | null;
+                maxAutoContinuations: number | null;
+            } | null;
+        };
+        taskMetadataKeys: string[];
+    };
+    detailProjection: {
+        bounded: boolean;
+        fullEntityAvailableViaRest: boolean;
+        reducedForBytes: boolean;
+        terminal: boolean;
+        prompt: ScheduledTaskUtf8ProjectionFact;
+        goalText: ScheduledTaskUtf8ProjectionFact | null;
+        goalSuccessCriteria: ScheduledTaskUtf8ProjectionFact | null;
+        resources: {
+            originalCount: number;
+            deliveredCount: number;
+            originalBytes: number;
+            truncatedIdentityFieldCount: number;
+        };
+        tools: {
+            originalCount: number;
+            deliveredCount: number;
+            originalBytes: number;
+            truncatedIdentityFieldCount: number;
+        };
+        metadata: {
+            originalKeyCount: number;
+            deliveredKeyCount: number;
+            originalBytes: number;
+            truncatedKeyCount: number;
+            valuesIncluded: boolean;
+        };
+        taskMetadata: {
+            originalKeyCount: number;
+            deliveredKeyCount: number;
+            originalBytes: number;
+            truncatedKeyCount: number;
+            valuesIncluded: boolean;
+        };
+        bytes: number;
+        maxBytes: number;
+    };
+};
+export declare function boundScheduledTaskMcpPage(input: {
+    tasks: ScheduledTask[];
+    limit: number;
+    offset: number;
+    sourceHasMore: boolean;
+    maxBytes?: number;
+}): {
+    tasks: {
+        id: string;
+        name: string;
+        status: "active" | "paused";
+        schedule: {
+            type: "once";
+            runAt: string;
+            timeZone: string;
+        } | {
+            type: "interval";
+            everySeconds: number;
+            startAt?: string | undefined;
+            endAt?: string | undefined;
+        } | {
+            type: "calendar";
+            timeZone: string;
+            hour: number;
+            minute: number;
+            daysOfWeek?: ("FRIDAY" | "MONDAY" | "SATURDAY" | "SUNDAY" | "THURSDAY" | "TUESDAY" | "WEDNESDAY")[] | undefined;
+        };
+        runMode: "existing_session" | "new_session_per_run" | "reusable_session";
+        overlapPolicy: "allow_concurrent" | "buffer_one" | "skip";
+        targetSessionId: string | null;
+        reusableSessionId: string | null;
+        variableSetId: string | null;
+        rigId: string | null;
+        createdAt: string;
+        updatedAt: string;
+        configuration: {
+            model: string | null;
+            reasoningEffort: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | null;
+            sandboxBackend: "blaxel" | "cloudflare" | "daytona" | "docker" | "e2b" | "local" | "modal" | "none" | "runloop" | "selfhosted" | "vercel" | null;
+            hasGoal: boolean;
+            promptBytes: number;
+            resourceCount: number;
+            toolCount: number;
+            metadataKeyCount: number;
+            taskMetadataKeyCount: number;
+        };
+        projection: {
+            bounded: boolean;
+            name: ScheduledTaskUtf8ProjectionFact;
+            schedule: {
+                type: "once";
+                truncated: boolean;
+                fields: {
+                    runAt: ScheduledTaskUtf8ProjectionFact;
+                    timeZone: ScheduledTaskUtf8ProjectionFact;
+                };
+            } | {
+                type: "interval";
+                truncated: boolean;
+                fields: {
+                    startAt: ScheduledTaskUtf8ProjectionFact | null;
+                    endAt: ScheduledTaskUtf8ProjectionFact | null;
+                };
+            } | {
+                type: "calendar";
+                truncated: boolean;
+                fields: {
+                    timeZone: ScheduledTaskUtf8ProjectionFact;
+                };
+            };
+            model: ScheduledTaskUtf8ProjectionFact | null;
+            createdAt: ScheduledTaskUtf8ProjectionFact;
+            updatedAt: ScheduledTaskUtf8ProjectionFact;
+            bytes: number;
+            maxBytes: number;
+        };
+    }[];
+    page: {
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset: number | null;
+    };
+    projection: {
+        bounded: boolean;
+        rowsDroppedForBytes: boolean;
+        droppedRowCount: number;
+        droppedRows: {
+            id: string;
+            nextAction: {
+                tool: string;
+                arguments: {
+                    id: string;
+                    includeEntity: boolean;
+                };
+            };
+        }[];
+        sourceRowsConsumed: number;
+        rowsReturned: number;
+        terminal: boolean;
+        reason?: string;
+        bytes: number;
+        maxBytes: number;
+    };
+};
+export {};

package/dist/mcp/toolspace.d.ts

@@ -49,6 +49,15 @@ export declare function prepareToolspaceMcpSurface(input: {
     deps: ApiRouteDeps;
     grant: AccessGrant;
 }): Promise<ToolspaceMcpSurface | null>;
+export type ToolspacePublicErrorFields = {
+    errorClass: "ToolspaceOperationError";
+    errorCode: ToolspacePublicFailureCode;
+    status?: number;
+    origin: "toolspace";
+};
+type ToolspacePublicFailureCode = "toolspace_operation_failed" | "tool_list_too_large" | "tool_result_too_large";
+/** Allowlisted projection for public telemetry; product data stays exact. */
+export declare function toolspacePublicErrorFields(error: unknown, errorCode?: ToolspacePublicFailureCode): ToolspacePublicErrorFields;
 export declare function toolspaceCanProxyServerId(serverId: string): boolean;
 export declare function connectionBrokerFetch(baseFetch: FetchLike, input: {
     deps: ApiRouteDeps;

package/dist/routes/transcription-recordings.d.ts

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

package/dist/sandbox/auth-callout.d.ts

@@ -4,6 +4,8 @@ import { type ResponderConnection } from "@opengeni/events";
 import type { Observability } from "@opengeni/observability";
 /** The NATS subject nats-server publishes authorization requests on (ADR-26). */
 export declare const AUTH_CALLOUT_SUBJECT = "$SYS.REQ.USER.AUTH";
+/** Keep live NATS credentials short-lived while never outliving the bearer. */
+export declare const NATS_USER_JWT_TTL_SECONDS: number;
 export interface AuthCalloutDeps {
     db: Database;
     settings: Settings;

package/dist/sandbox/channel-a.d.ts

@@ -3,7 +3,7 @@ import type { Session } from "@opengeni/contracts";
 import { type Database, type LeaseSnapshot } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 import { type Observability } from "@opengeni/observability";
-import { SandboxChannelAService, type RoutingSandboxSession } from "@opengeni/runtime/sandbox";
+import { SandboxChannelAService, type EstablishedSandboxSession, type RoutingSandboxSession } from "@opengeni/runtime/sandbox";
 export type ChannelAServices = {
     db: Database;
     settings: Settings;
@@ -24,6 +24,10 @@ export type ChannelAHandle = {
     routingSession: RoutingSandboxSession;
     requestId: string;
 };
+/** Reuse the exact lease-fenced provider handle across API-direct surfaces.
+ * Stream capability negotiation and the first Files/Changes reads commonly run
+ * back-to-back; sharing this handle avoids paying the same Modal resume twice. */
+export declare function establishCachedChannelAHandle(workspaceId: string, sessionId: string, lease: LeaseSnapshot, establish: () => Promise<EstablishedSandboxSession>): Promise<EstablishedSandboxSession>;
 /**
  * Run a Channel-A op against a live box, API-direct. Acquires an exact direct holder
  * (warming the box when cold), resumes by id, builds the service, runs `fn`, and

package/dist/transcription/segmenter.d.ts

@@ -0,0 +1,10 @@
+import type { TranscriptionSegmenter } from "@opengeni/core";
+export declare class TranscriptionSegmenterError extends Error {
+    readonly code: "unavailable" | "invalid_audio" | "cancelled" | "too_large" | "unknown";
+    readonly retryable: boolean;
+    readonly name = "TranscriptionSegmenterError";
+    constructor(message: string, code: "unavailable" | "invalid_audio" | "cancelled" | "too_large" | "unknown", retryable: boolean);
+}
+export declare function createFfmpegTranscriptionSegmenter(input: {
+    ffmpegPath: string;
+}): TranscriptionSegmenter;

package/dist/transcription/service.d.ts

@@ -7,4 +7,9 @@ export declare function createTranscriptionService(input: {
     fetch?: typeof fetch;
     codexFetch?: typeof fetch;
     probeCodex?: (context?: TranscriptionAvailabilityContext) => boolean | Promise<boolean>;
+    /** Test seam for exercising timeout and late-completion behavior quickly. */
+    providerRequestTimeoutMilliseconds?: number;
+    /** Test seam for evaluating persisted absolute deadlines after delayed setup. */
+    now?: () => Date;
 }): TranscriptionService;
+export declare function remainingTranscriptionProviderRequestMilliseconds(providerDeadlineAt: Date, now: Date): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/api-router",
-  "version": "0.21.14",
+  "version": "0.23.1",
   "description": "OpenGeni HTTP surface: the Hono adapter/router (createApp), routes, MCP HTTP transport, and HTTP access adapters over @opengeni/core. An engine-distribution surface — its runtime closure includes engine-internal packages.",
   "license": "Apache-2.0",
   "repository": {
@@ -43,18 +43,18 @@
     "@hono/zod-validator": "^0.7.6",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opengeni/agent-proto": "^0.3.0",
-    "@opengeni/codex": "^0.2.11",
-    "@opengeni/config": "^0.10.14",
-    "@opengeni/contracts": "^0.38.3",
-    "@opengeni/core": "^0.20.16",
-    "@opengeni/db": "^0.27.11",
-    "@opengeni/documents": "^0.5.7",
-    "@opengeni/events": "^0.3.77",
-    "@opengeni/github": "^0.4.30",
+    "@opengeni/codex": "^0.2.13",
+    "@opengeni/config": "^0.12.1",
+    "@opengeni/contracts": "^0.40.0",
+    "@opengeni/core": "^0.21.10",
+    "@opengeni/db": "^0.28.9",
+    "@opengeni/documents": "^0.5.18",
+    "@opengeni/events": "^0.3.88",
+    "@opengeni/github": "^0.4.38",
     "@opengeni/network": "^0.2.0",
-    "@opengeni/observability": "^0.4.16",
-    "@opengeni/runtime": "^0.18.15",
-    "@opengeni/storage": "^0.2.67",
+    "@opengeni/observability": "^0.5.6",
+    "@opengeni/runtime": "^0.18.24",
+    "@opengeni/storage": "^0.2.75",
     "@temporalio/client": "^1.17.0",
     "better-auth": "^1.6.14",
     "hono": "^4.12.18",

package/src/app.ts

@@ -13,6 +13,7 @@ import {
   OPENGENI_CORRELATION_HEADER,
   resolveWorkspaceMemoryEnabled,
   VOICE_INPUT_ACCEPTED_MIME_TYPES,
+  TRANSCRIPTION_RECORDING_PROVIDER_SEGMENT_SECONDS,
   type AccessGrant,
   type ErrorCode,
 } from "@opengeni/contracts";
@@ -77,6 +78,7 @@ import { registerInsightsRoutes } from "./routes/insights";
 import { registerTranscriptionRoutes } from "./routes/transcriptions";
 import { projectClientModel } from "./model-catalog";
 import { createTranscriptionService } from "./transcription/service";
+import { createFfmpegTranscriptionSegmenter } from "./transcription/segmenter";
 import { registerSlackInteractionRoutes } from "./integrations/slack-interactions";
 
 export type {
@@ -103,8 +105,15 @@ export { replaySessionEvents, sseSessionStream, sseWorkspaceControlStream } from
 export const API_MAX_REQUEST_BODY_BYTES = 8 * 1024 * 1024;
 
 /** Effective Hono bodyLimit — API JSON ceiling or voice multipart + multipart overhead. */
-export function apiRequestBodyLimitBytes(settings: { voiceInputMaxSizeBytes: number }): number {
-  return Math.max(API_MAX_REQUEST_BODY_BYTES, settings.voiceInputMaxSizeBytes + 64 * 1024);
+export function apiRequestBodyLimitBytes(settings: {
+  voiceInputMaxSizeBytes: number;
+  voiceInputResumableMaxChunkSizeBytes?: number;
+}): number {
+  return Math.max(
+    API_MAX_REQUEST_BODY_BYTES,
+    settings.voiceInputMaxSizeBytes + 64 * 1024,
+    (settings.voiceInputResumableMaxChunkSizeBytes ?? 0) + 64 * 1024,
+  );
 }
 const API_PUBLIC_ERROR_MESSAGE_MAX_BYTES = 512;
 
@@ -204,6 +213,12 @@ export function createAppComposition(deps: AppDependencies): {
           ...(deps.codexFetch ? { codexFetch: deps.codexFetch } : {}),
         })
       : deps.transcription;
+  const transcriptionSegmenter =
+    deps.transcriptionSegmenter === undefined
+      ? createFfmpegTranscriptionSegmenter({
+          ffmpegPath: deps.settings.voiceInputFfmpegPath,
+        })
+      : deps.transcriptionSegmenter;
   const routeDeps: ApiRouteDeps = {
     ...deps,
     observability,
@@ -214,6 +229,7 @@ export function createAppComposition(deps: AppDependencies): {
     documentIndexer,
     getDocumentServices,
     transcription,
+    transcriptionSegmenter,
     ...(sandboxClient ? { sandboxClient } : {}),
     resumeBoxById,
   };
@@ -291,7 +307,6 @@ export function createAppComposition(deps: AppDependencies): {
     const start = performance.now();
     const span = observability.startSpan(`HTTP ${c.req.method} ${route}`, {
       "http.request.method": c.req.method,
-      "url.path": url.pathname,
       "opengeni.route": route,
     });
     try {
@@ -350,7 +365,7 @@ export function createAppComposition(deps: AppDependencies): {
         spanId: span.spanId,
         correlationId,
         errorCode,
-        errorClass: error instanceof Error ? error.name : "NonErrorThrown",
+        errorClass: "HttpOperationError",
       });
       throw error;
     }
@@ -440,6 +455,24 @@ export function createAppComposition(deps: AppDependencies): {
           maxDurationSeconds: deps.settings.voiceInputMaxDurationSeconds,
           maxSizeBytes: deps.settings.voiceInputMaxSizeBytes,
           acceptedMimeTypes: [...VOICE_INPUT_ACCEPTED_MIME_TYPES],
+          ...(deps.settings.voiceInputResumableEnabled &&
+          objectStorage &&
+          transcription &&
+          transcriptionSegmenter &&
+          (await transcription.available()) &&
+          (await transcriptionSegmenter.available())
+            ? {
+                resumable: {
+                  maxDurationSeconds: deps.settings.voiceInputResumableMaxDurationSeconds,
+                  maxSizeBytes: deps.settings.voiceInputResumableMaxSizeBytes,
+                  maxChunkSizeBytes: deps.settings.voiceInputResumableMaxChunkSizeBytes,
+                  providerSegmentSeconds: Math.min(
+                    TRANSCRIPTION_RECORDING_PROVIDER_SEGMENT_SECONDS,
+                    deps.settings.voiceInputMaxDurationSeconds,
+                  ),
+                },
+              }
+            : {}),
         },
         productAccessMode: deps.settings.productAccessMode,
         auth: clientAuthConfig(deps.settings),
@@ -803,12 +836,12 @@ async function runReadinessChecks<const Checks extends Readonly<Record<string, R
       try {
         await withTimeout(Promise.resolve().then(check), timeoutMs);
         return [name, { ok: true }] as const;
-      } catch (error) {
+      } catch {
         return [
           name,
           {
             ok: false,
-            error: error instanceof Error ? error.message : String(error),
+            error: "dependency_unavailable",
           },
         ] as const;
       }

package/src/auth/managed-auth.ts

@@ -151,22 +151,6 @@ export function createManagedAuth(settings: Settings, db: Database): ManagedAuth
   }) as ManagedAuth;
 }
 
-export async function managedSessionAccessContext(
-  auth: ManagedAuth,
-  db: Database,
-  headers: Headers,
-) {
-  const session = await auth.api.getSession({ headers });
-  if (!session?.user) {
-    return null;
-  }
-  return await ensureManagedAccessForUser(db, {
-    userId: session.user.id,
-    email: session.user.email,
-    name: session.user.name,
-  });
-}
-
 function betterAuthBaseUrl(settings: Settings) {
   const allowedHosts = splitCsv(settings.betterAuthAllowedHosts);
   if (allowedHosts.length === 0) {