@opengeni/api-router 0.22.2 → 0.26.1

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

@@ -0,0 +1,518 @@
+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: "manual";
+    }>;
+    projection: {
+        type: "manual";
+        truncated: false;
+        fields: Record<string, never>;
+    };
+} | {
+    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: "manual";
+    } | {
+        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";
+    action: {
+        kind: "agent_turn";
+        sourceId?: never;
+        sourceGeneration?: never;
+        sourceLifecycleGeneration?: never;
+        destination?: never;
+        initiatingSubjectId?: never;
+        allDescendants?: never;
+        connection?: never;
+        limits?: never;
+    } | {
+        kind: "knowledge_source_sync";
+        sourceId: string;
+        sourceGeneration: number;
+        sourceLifecycleGeneration: number;
+        destination: {
+            kind: "organization";
+            workspaceId: null;
+            subjectId: null;
+        } | {
+            kind: "workspace";
+            workspaceId: string;
+            subjectId: null;
+        } | {
+            kind: "personal";
+            workspaceId: string | null;
+            subjectId: string;
+        };
+        initiatingSubjectId: string;
+        allDescendants: boolean;
+        connection: {
+            connectionId: string;
+            connectionVersion: number;
+            providerDomain: string;
+            kind: "api_key" | "app_install" | "delegated" | "oauth2";
+            ownerSubjectId: string;
+        };
+        limits: {
+            maxItems: number;
+            maxBytes: number;
+            maxFileBytes: number;
+            maxProviderRequests: number;
+            maxElapsedSeconds: number;
+            maxConcurrency: number;
+            maxFailureDetails: number;
+        };
+    };
+    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: "manual";
+            truncated: false;
+            fields: Record<string, never>;
+        } | {
+            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: "manual";
+    } | {
+        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";
+    action: {
+        kind: "agent_turn";
+        sourceId?: never;
+        sourceGeneration?: never;
+        sourceLifecycleGeneration?: never;
+        destination?: never;
+        initiatingSubjectId?: never;
+        allDescendants?: never;
+        connection?: never;
+        limits?: never;
+    } | {
+        kind: "knowledge_source_sync";
+        sourceId: string;
+        sourceGeneration: number;
+        sourceLifecycleGeneration: number;
+        destination: {
+            kind: "organization";
+            workspaceId: null;
+            subjectId: null;
+        } | {
+            kind: "workspace";
+            workspaceId: string;
+            subjectId: null;
+        } | {
+            kind: "personal";
+            workspaceId: string | null;
+            subjectId: string;
+        };
+        initiatingSubjectId: string;
+        allDescendants: boolean;
+        connection: {
+            connectionId: string;
+            connectionVersion: number;
+            providerDomain: string;
+            kind: "api_key" | "app_install" | "delegated" | "oauth2";
+            ownerSubjectId: string;
+        };
+        limits: {
+            maxItems: number;
+            maxBytes: number;
+            maxFileBytes: number;
+            maxProviderRequests: number;
+            maxElapsedSeconds: number;
+            maxConcurrency: number;
+            maxFailureDetails: number;
+        };
+    };
+    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: "manual";
+            truncated: false;
+            fields: Record<string, never>;
+        } | {
+            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: "manual";
+        } | {
+            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";
+        action: {
+            kind: "agent_turn";
+            sourceId?: never;
+            sourceGeneration?: never;
+            sourceLifecycleGeneration?: never;
+            destination?: never;
+            initiatingSubjectId?: never;
+            allDescendants?: never;
+            connection?: never;
+            limits?: never;
+        } | {
+            kind: "knowledge_source_sync";
+            sourceId: string;
+            sourceGeneration: number;
+            sourceLifecycleGeneration: number;
+            destination: {
+                kind: "organization";
+                workspaceId: null;
+                subjectId: null;
+            } | {
+                kind: "workspace";
+                workspaceId: string;
+                subjectId: null;
+            } | {
+                kind: "personal";
+                workspaceId: string | null;
+                subjectId: string;
+            };
+            initiatingSubjectId: string;
+            allDescendants: boolean;
+            connection: {
+                connectionId: string;
+                connectionVersion: number;
+                providerDomain: string;
+                kind: "api_key" | "app_install" | "delegated" | "oauth2";
+                ownerSubjectId: string;
+            };
+            limits: {
+                maxItems: number;
+                maxBytes: number;
+                maxFileBytes: number;
+                maxProviderRequests: number;
+                maxElapsedSeconds: number;
+                maxConcurrency: number;
+                maxFailureDetails: number;
+            };
+        };
+        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: "manual";
+                truncated: false;
+                fields: Record<string, never>;
+            } | {
+                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/server.d.ts

@@ -1,11 +1,9 @@
-import { type AccessGrant } from "@opengeni/contracts";
+import { type AccessGrant, type SessionAuthorizationActor } 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;
@@ -33,6 +31,19 @@ export declare function isHumanDirectedTurn(turn: {
  * 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 memorySlackPublicationActor(actor: Extract<SessionAuthorizationActor, {
+    kind: "agent_attempt";
+}>, sessionId: string, fallbackOwnerLabel: string | null): {
+    actor: {
+        kind: "human" | "service";
+        subjectId: string;
+        initiatingHumanSubjectId: string | null;
+        sessionId: string;
+        turnId: string;
+        attemptId: string;
+    };
+    ownerLabel: string | null;
+};
 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): {

package/dist/memory-slack-delivery.d.ts

@@ -0,0 +1,9 @@
+import { type ClaimedMemorySlackPublication } from "@opengeni/db";
+import { type ApiRouteDeps } from "@opengeni/core";
+export declare function drainMemorySlackPublicationsOnce(deps: ApiRouteDeps): Promise<boolean>;
+export declare function startMemorySlackPublicationPump(deps: ApiRouteDeps, options?: {
+    intervalMs?: number;
+    maxPerTick?: number;
+}): () => Promise<void>;
+export declare function formatMemorySlackPublicationMessage(deps: Pick<ApiRouteDeps, "settings">, publication: ClaimedMemorySlackPublication): string;
+export declare function memorySlackDestinationDrift(error: unknown): boolean;

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

@@ -0,0 +1,8 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { FetchLike } from "@opengeni/network";
+import type { Hono } from "hono";
+export type ApiIntegrationRouteOverrides = Readonly<{
+    fetchImpl?: FetchLike;
+}>;
+export declare function apiIntegrationRequiresConnection(authScheme: Record<string, unknown>): boolean;
+export declare function registerApiIntegrationRoutes(app: Hono, deps: ApiRouteDeps, overrides?: ApiIntegrationRouteOverrides): void;

package/dist/routes/browser-identities.d.ts

@@ -0,0 +1,5 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+export declare function registerBrowserIdentityRoutes(app: Hono, deps: ApiRouteDeps): void;
+export declare function browserIdentityRouteError(error: unknown): HTTPException;

package/dist/routes/browser-sessions.d.ts

@@ -0,0 +1,6 @@
+import { InteractionActor, type AccessGrant } from "@opengeni/contracts";
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerBrowserSessionRoutes(app: Hono, deps: ApiRouteDeps): void;
+export declare function validateBrowserRequestOrigin(value: string | undefined, allowedPattern: string): string | null;
+export declare function interactionActorForGrant(grant: AccessGrant): ReturnType<typeof InteractionActor.parse>;

package/dist/routes/company-profile.d.ts

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

package/dist/routes/computer-sessions.d.ts

@@ -0,0 +1,6 @@
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+/** Public ComputerSession resource surface. Physical app/window authority stays
+ * in the same placement controller used by BrowserSession; this route owns only
+ * durable authorization, placement fencing, lifecycle receipts, and routing. */
+export declare function registerComputerSessionRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/editable-artifacts.d.ts

@@ -0,0 +1,44 @@
+import type { AccessGrant } from "@opengeni/contracts";
+import { type AccessDeps, type EditableArtifactActor, type EditableArtifactApplicationPort, type EditableArtifactDurableExportService, type EditableArtifactOfficeImportPort, type EditableArtifactModality } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare const EDITABLE_ARTIFACT_HTTP_REQUEST_MAX_BYTES: number;
+export declare const EDITABLE_ARTIFACT_EXPORT_REQUEST_MAX_BYTES: number;
+export declare const EDITABLE_ARTIFACT_LIVE_TICKET_REQUEST_MAX_BYTES: number;
+export type EditableArtifactRouteScope = Readonly<{
+    accountId: string;
+    workspaceId: string;
+}>;
+export type EditableArtifactRouteActor = EditableArtifactActor;
+/**
+ * Authenticated transport context. Until a distinct editable-artifact
+ * capability is introduced, the existing workspace `artifacts:read` and
+ * `artifacts:publish` capabilities intentionally gate read and write here too;
+ * the application still performs the durable per-artifact authorization.
+ */
+export type EditableArtifactRouteAuthority = Readonly<{
+    scope: EditableArtifactRouteScope;
+    actor: EditableArtifactRouteActor;
+}>;
+export type MintEditableArtifactLiveTicketOutput = Readonly<{
+    artifactId: string;
+    modality: EditableArtifactModality;
+    replicaId: string;
+    token: string;
+    expiresAt: string;
+    protocolVersion: number;
+}>;
+export type EditableArtifactRouteDependencies = AccessDeps & Readonly<{
+    editableArtifacts?: EditableArtifactApplicationPort;
+    editableArtifactExports?: EditableArtifactDurableExportService;
+    editableArtifactOfficeImports?: EditableArtifactOfficeImportPort;
+    /** Test/embedding seam; returned ids are still authorized one by one. */
+    editableArtifactSessionArtifactIds?: (scope: EditableArtifactRouteScope, sourceSessionId: string, limit: number) => Promise<readonly string[]>;
+}>;
+export type EditableArtifactApplicationErrorCode = "not_found" | "forbidden" | "conflict" | "unsupported_protocol" | "limit_exceeded" | "unavailable";
+/** A bounded, deliberate failure emitted by the injected application boundary. */
+export declare class EditableArtifactApplicationError extends Error {
+    readonly code: EditableArtifactApplicationErrorCode;
+    constructor(code: EditableArtifactApplicationErrorCode);
+}
+export declare function registerEditableArtifactRoutes(app: Hono, deps: EditableArtifactRouteDependencies): void;
+export declare function editableArtifactActorForGrant(grant: AccessGrant, rawReplicaId: string): EditableArtifactRouteActor;

package/dist/routes/integration-features.d.ts

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

package/dist/routes/memory-slack-publications.d.ts

@@ -0,0 +1,6 @@
+import { type MemorySlackPublication as MemorySlackPublicationRecord } from "@opengeni/contracts";
+import { type ApiRouteDeps } from "@opengeni/core";
+import type { Hono } from "hono";
+export declare function registerMemorySlackPublicationRoutes(app: Hono, deps: ApiRouteDeps): void;
+/** Defensively protects legacy rows without rewriting their durable projection. */
+export declare function sanitizeMemorySlackPublicationHistory(publication: MemorySlackPublicationRecord): MemorySlackPublicationRecord;

package/dist/routes/plugins.d.ts

@@ -0,0 +1,8 @@
+import { type ApiRouteDeps, type GitHubSkillSourceClient } from "@opengeni/core";
+import type { FetchLike } from "@opengeni/network";
+import type { Hono } from "hono";
+export type PluginRouteOverrides = Readonly<{
+    fetchImpl?: FetchLike;
+    github?: GitHubSkillSourceClient;
+}>;
+export declare function registerPluginRoutes(app: Hono, deps: ApiRouteDeps, overrides?: PluginRouteOverrides): void;