@opengeni/core 0.12.10 → 0.14.4

package/dist/access/index.d.ts

@@ -0,0 +1,22 @@
+import type { Settings } from "@opengeni/config";
+import { type AccountGrant, type AccessContext, type AccessGrant, type Permission } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+import type { Context } from "hono";
+import type { ManagedAuth } from "../managed-auth-type";
+export type AccessDeps = {
+    db: Database;
+    settings: Settings;
+    managedAuth?: ManagedAuth | null;
+};
+export declare function requireAccessContext(c: Context, deps: AccessDeps): Promise<AccessContext>;
+export declare function requireAccessGrant(c: Context, deps: AccessDeps, workspaceId: string, permission?: Permission): Promise<AccessGrant>;
+export type AccessGrantAuthorization = {
+    grant: AccessGrant;
+    accountGrant: AccountGrant | null;
+    authenticatedSubjectId: string;
+    contextIntegrity: boolean;
+};
+export declare function accessGrantAuthorizationFromContext(context: AccessContext, grant: AccessGrant): AccessGrantAuthorization;
+export declare function requireAccessGrantAuthorization(c: Context, deps: AccessDeps, workspaceId: string, permission?: Permission): Promise<AccessGrantAuthorization>;
+export declare function requirePermission(grant: AccessGrant, permission: Permission): void;
+export declare function hasPermission(permissions: Permission[], permission: Permission): boolean;

package/dist/application/new-session-drafts.d.ts

@@ -0,0 +1,14 @@
+import { type AccessGrant, type NewSessionDraft as NewSessionDraftValue } from "@opengeni/contracts";
+import type { AppDependencies } from "../dependencies";
+type NewSessionDraftDependencies = Pick<AppDependencies, "settings" | "db" | "objectStorage">;
+/** Read the authenticated actor's server-authoritative pre-session composer state. */
+export declare function getActorNewSessionDraft(deps: Pick<NewSessionDraftDependencies, "settings" | "db">, grant: AccessGrant, workspaceId: string): Promise<NewSessionDraftValue>;
+/**
+ * Validate and save one exact actor-private draft revision. Create-time-only
+ * checks (live machine target, rig/variable-set state, and permission
+ * delegation) intentionally remain in createSessionForRequest: a recoverable
+ * draft may represent incomplete options, while no invalid option can become a
+ * session without passing that single canonical create boundary.
+ */
+export declare function saveActorNewSessionDraft(deps: NewSessionDraftDependencies, grant: AccessGrant, workspaceId: string, rawInput: unknown): Promise<NewSessionDraftValue>;
+export {};

package/dist/application/session-commands.d.ts

@@ -0,0 +1,107 @@
+import type { ComposerDraft, DeleteSessionQueueItemRequest, EditSessionQueueItemRequest, MoveSessionQueueItemRequest, SaveComposerDraftRequest, SessionAuthorizationPort, SessionAuthorizationSurface, SessionControlRequest, SessionControlResponse, SessionQueueMutationResponse, SteerSessionQueueItemRequest, WorkspaceInferenceControlRequest, WorkspaceInferenceControlResponse } from "@opengeni/contracts";
+import { type Database, type SessionCommandReceiptRow } from "@opengeni/db";
+import { type EventBus } from "@opengeni/events";
+import type { SessionWorkflowClient } from "../dependencies";
+import { type ResolvedSessionAuthorization } from "../session-authorization";
+export type HumanSessionCommandContext = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    /** See AgentSessionCommandContext.authorizationSurface. */
+    authorizationSurface?: SessionAuthorizationSurface;
+};
+export type AgentSessionCommandContext = {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    callerSessionId: string;
+    callerTurnId: string;
+    callerAttemptId: string;
+    callerExecutionGeneration: number;
+    /**
+     * The trusted adapter surface that owns this command's one authorization
+     * decision. Direct core callers omit it and retain the canonical `core`
+     * surface; adapters that delegate the complete command set it explicitly so
+     * they do not authorize once at the edge and then repeat the host call here.
+     */
+    authorizationSurface?: SessionAuthorizationSurface;
+};
+type SessionAuthorizationCommandDeps = {
+    db: Database;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+};
+export declare function sendAgentSessionMessage(deps: {
+    db: Database;
+    bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: AgentSessionCommandContext, input: {
+    targetSessionId: string;
+    text: string;
+    idempotencyKey: string;
+}): Promise<import("@opengeni/db").AgentInternalUpdateCommandResult>;
+export declare function steerAgentSession(deps: {
+    db: Database;
+    bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: AgentSessionCommandContext, input: {
+    targetSessionId: string;
+    instruction: string;
+    idempotencyKey: string;
+}): Promise<import("@opengeni/db").AgentInternalUpdateCommandResult>;
+export declare function controlAgentSessionWorkstream(deps: {
+    db: Database;
+    bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: AgentSessionCommandContext, input: {
+    targetSessionId: string;
+    action: "pause" | "resume";
+    idempotencyKey: string;
+    reason?: string | null;
+}): Promise<{
+    receipt: SessionCommandReceiptRow;
+    control: import("@opengeni/db").EffectiveSessionControl;
+    sessionControlEventId: string;
+    workspaceControlEventId: string;
+    interruptionCount: number;
+    wakeCount: number;
+    replay: boolean;
+    authorization: ResolvedSessionAuthorization | null;
+}>;
+export declare function moveHumanQueuePrompt(deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: HumanSessionCommandContext, turnId: string, input: MoveSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+export declare function deleteHumanQueuePrompt(deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: HumanSessionCommandContext, turnId: string, input: DeleteSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+export declare function editHumanQueuePrompt(deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: HumanSessionCommandContext, turnId: string, input: EditSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+export declare function steerHumanQueuePrompt(deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: HumanSessionCommandContext, turnId: string, input: SteerSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+export declare function controlHumanSessionWorkstream(deps: {
+    db: Database;
+    bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+}, context: HumanSessionCommandContext, input: SessionControlRequest): Promise<SessionControlResponse>;
+export declare function controlHumanWorkspace(deps: {
+    db: Database;
+    bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+}, context: Omit<HumanSessionCommandContext, "sessionId">, input: WorkspaceInferenceControlRequest): Promise<WorkspaceInferenceControlResponse>;
+export declare function getHumanComposerDraft(deps: SessionAuthorizationCommandDeps, context: HumanSessionCommandContext): Promise<ComposerDraft>;
+export declare function saveHumanComposerDraft(deps: SessionAuthorizationCommandDeps, context: HumanSessionCommandContext, input: SaveComposerDraftRequest): Promise<ComposerDraft>;
+export {};

package/dist/billing/limits.d.ts

@@ -0,0 +1,29 @@
+import type { LimitAction, LimitDecision, SessionTurnSource, TurnInitiator, TurnInitiatorContext } from "@opengeni/contracts";
+import type { ApiRouteDeps } from "../dependencies";
+export type LimitDependencies = Pick<ApiRouteDeps, "db" | "settings">;
+export type LimitCheckInput = {
+    accountId: string;
+    workspaceId?: string;
+    action: LimitAction;
+    quantity?: number;
+    model?: string | null;
+};
+export declare function requireLimit(deps: LimitDependencies, input: LimitCheckInput): Promise<void>;
+export declare function checkLimit(deps: LimitDependencies, input: LimitCheckInput): Promise<LimitDecision>;
+export declare function recordWorkspaceUsage(deps: LimitDependencies, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId?: string | null;
+    eventType: "agent_run.created" | "file.uploaded" | "document.indexed" | "scheduled_task.fired";
+    quantity: number;
+    unit: string;
+    sourceResourceType: string;
+    sourceResourceId: string;
+    sessionId?: string | null;
+    turnId?: string | null;
+    turnAttemptId?: string | null;
+    initiator?: TurnInitiator | null;
+    initiatorContext?: TurnInitiatorContext;
+    origin?: SessionTurnSource | null;
+    idempotencyKey: string;
+}): Promise<void>;

package/dist/dependencies.d.ts

@@ -0,0 +1,137 @@
+import type { Settings } from "@opengeni/config";
+import type { ConnectionCredentialsPort, Document, GitHubAppApiPort, ScheduledTask, SessionAuthorizationPort, TurnInitiator } from "@opengeni/contracts";
+import type { Database } from "@opengeni/db";
+import type { DocumentServices } from "@opengeni/documents";
+import type { EventBus } from "@opengeni/events";
+import type { Observability } from "@opengeni/observability";
+import type { createObjectStorage } from "@opengeni/storage";
+import type { ManagedAuth } from "./managed-auth-type";
+import type { ApiSandboxClient, ResumeBoxByIdInput, ResumedSandboxSession } from "./sandbox-types";
+import type { TranscriptionService } from "./transcription";
+export type SessionWorkflowClient = {
+    signalUserMessage: (input: {
+        sessionId: string;
+        eventId: string;
+        workflowId: string;
+    }) => Promise<void>;
+    wakeSessionWorkflow: (input: {
+        accountId: string;
+        workspaceId: string;
+        sessionId: string;
+        workflowId: string;
+        wakeRevision: number;
+        interruptionRequested?: boolean;
+    }) => Promise<void>;
+    /** Trigger one bounded drain of already-committed workflow-wake revisions. */
+    requestSessionWorkflowWakeDispatch: () => Promise<void>;
+    signalCodexCapacity?: (input: {
+        accountId: string;
+        workspaceId: string;
+        sessionId: string;
+        workflowId: string;
+        wakeRevision: number;
+        workflowWakeRevision: number;
+    }) => Promise<void>;
+    signalApprovalDecision: (input: {
+        accountId: string;
+        workspaceId: string;
+        sessionId: string;
+        eventId: string;
+        workflowId: string;
+        workflowWakeRevision: number;
+    }) => Promise<void>;
+    syncScheduledTask: (input: {
+        task: ScheduledTask;
+    }) => Promise<void>;
+    deleteScheduledTaskSchedule: (input: {
+        temporalScheduleId: string;
+    }) => Promise<void>;
+    triggerScheduledTask: (input: {
+        task: ScheduledTask;
+        agentRunUsageIdempotencyKey: string;
+        triggerWorkflowId: string;
+        initiator: TurnInitiator;
+    }) => Promise<void>;
+    startRigVerification: (input: {
+        workspaceId: string;
+        changeId?: string;
+        versionId?: string;
+        workflowId?: string;
+    }) => Promise<void>;
+    check?: () => Promise<void>;
+};
+export type DocumentIndexClient = {
+    indexDocument: (input: {
+        accountId: string;
+        workspaceId: string;
+        documentId: string;
+    }) => Promise<Document | void>;
+};
+export type AppDependencies = {
+    settings: Settings;
+    db: Database;
+    bus: EventBus;
+    workflowClient: SessionWorkflowClient;
+    /** Optional provider override for deterministic API/object-storage tests. */
+    objectStorage?: ObjectStorageDependency;
+    documentIndexer?: DocumentIndexClient;
+    documentServices?: DocumentServices;
+    observability?: Observability;
+    readinessChecks?: Partial<Record<"db" | "nats" | "temporal", () => Promise<void> | void>>;
+    githubStateSecret?: string;
+    /**
+     * Optional host-provided GitHub App API seam. Embedded hosts can authorize
+     * users, inspect installations, and list repositories with their own GitHub
+     * App credentials; standalone deployments fall back to @opengeni/github.
+     */
+    githubAppApi?: GitHubAppApiPort;
+    /**
+     * Optional host-owned connection credential seam. API-side consumers use
+     * the MCP leg for Toolspace/Code Mode; worker consumers bind the same port
+     * for model MCP, Git, and sandbox-secret resolution.
+     */
+    connectionCredentials?: ConnectionCredentialsPort | null;
+    /**
+     * Optional embedding-host session ACL. Unset preserves standalone workspace
+     * authorization; once bound, every session-addressed surface fails closed on
+     * an unavailable or invalid host decision.
+     */
+    sessionAuthorization?: SessionAuthorizationPort | null;
+    managedAuth?: ManagedAuth | null;
+    /** Injectable Codex HTTP transport for deterministic API/provider tests. */
+    codexFetch?: typeof fetch;
+    /** Injectable Slack Web API transport for deterministic bot-connection tests. */
+    slackFetch?: typeof fetch;
+    /** Injectable Google OAuth/Drive transport for deterministic connector tests. */
+    googleDriveFetch?: typeof fetch;
+    /** Optional host-owned voice-input transcription service. */
+    transcription?: TranscriptionService | null;
+    sandboxClient?: ApiSandboxClient;
+    /**
+     * Resume a box by id from a serialized resume_state envelope (the lease's
+     * `resume_state` + `resume_backend_id` from P1.1) and return a live session
+     * for a single in-process op. resume → use → drop; the lease owns lifecycle,
+     * the returned handle does NOT own the box. Throws SandboxResumeError on a
+     * backend mismatch or a resume failure.
+     */
+    resumeBoxById?: (input: ResumeBoxByIdInput) => Promise<ResumedSandboxSession>;
+};
+export type ObjectStorageDependency = ReturnType<typeof createObjectStorage>;
+export type ApiRouteDeps = AppDependencies & {
+    objectStorage: ObjectStorageDependency;
+    githubStateSecret: string;
+    documentIndexer: DocumentIndexClient;
+    getDocumentServices: () => DocumentServices;
+    resumeBoxById: (input: ResumeBoxByIdInput) => Promise<ResumedSandboxSession>;
+};
+/**
+ * The exact dependency slice used by `acceptSessionUserMessage`.
+ *
+ * Keeping this narrower than `ApiRouteDeps` lets control-plane callers reuse
+ * the canonical admission path without constructing unrelated HTTP, document,
+ * or sandbox services. The public API still passes its `ApiRouteDeps` superset.
+ */
+export type AcceptSessionUserMessageDependencies = Pick<AppDependencies, "settings" | "db" | "bus" | "sessionAuthorization"> & {
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+    objectStorage: ObjectStorageDependency;
+};

package/dist/domain/capabilities.d.ts

@@ -0,0 +1,62 @@
+import { type Settings } from "@opengeni/config";
+import { CapabilityCatalogItem, type AccessGrant, type CapabilityCatalogResponse, type CapabilityInstallation, type CreateCapabilityCatalogItemRequest, type EnableCapabilityRequest } from "@opengeni/contracts";
+import { type Database, type EnabledMcpCapabilityServer } from "@opengeni/db";
+declare const officialMcpRegistryUrl = "https://registry.modelcontextprotocol.io";
+export declare function buildCapabilityCatalog(input: {
+    db: Database;
+    workspaceId: string;
+    settings: Settings;
+}): Promise<CapabilityCatalogResponse>;
+export declare function createCatalogItem(input: {
+    db: Database;
+    accountId: string;
+    workspaceId: string;
+    payload: CreateCapabilityCatalogItemRequest;
+}): Promise<CapabilityCatalogItem>;
+export declare function enableCapability(input: {
+    db: Database;
+    grant: AccessGrant;
+    accountId: string;
+    workspaceId: string;
+    settings: Settings;
+    capabilityId: string;
+    payload: EnableCapabilityRequest;
+    probeMcpServer?: McpCapabilityProbe;
+}): Promise<CapabilityInstallation>;
+export type McpCapabilityProbeInput = {
+    id: string;
+    name: string;
+    url: string;
+    timeoutMs: number;
+    headers?: Record<string, string>;
+};
+export type McpCapabilityProbeResult = {
+    toolCount: number;
+};
+export type McpCapabilityProbe = (input: McpCapabilityProbeInput) => Promise<McpCapabilityProbeResult>;
+export declare function validateMcpCapabilityConnection(item: CapabilityCatalogItem, probe?: McpCapabilityProbe, headers?: Record<string, string>): Promise<Record<string, unknown>>;
+export declare function disableCapability(input: {
+    db: Database;
+    accountId: string;
+    workspaceId: string;
+    settings: Settings;
+    capabilityId: string;
+}): Promise<CapabilityInstallation>;
+export declare function settingsWithEnabledCapabilityMcpServers(db: Database, workspaceId: string, settings: Settings): Promise<Settings>;
+/**
+ * Register Codex Apps as an optional runtime MCP when the deployment enables
+ * it. Registration only makes the server selectable; the session tool policy
+ * decides whether the model sees it, and Codex credential resolution
+ * independently decides whether calls can authenticate.
+ */
+export declare function settingsWithCodexAppsMcpServer(settings: Settings): Settings;
+export declare function settingsWithMcpCapabilityServers(settings: Settings, enabled: EnabledMcpCapabilityServer[]): Settings;
+export declare function discoverMcpRegistryCapabilities(input: {
+    query?: string;
+    limit?: number;
+    fetchImpl?: McpRegistryFetch;
+    timeoutMs?: number;
+}): Promise<CapabilityCatalogItem[]>;
+export { officialMcpRegistryUrl };
+type McpRegistryFetch = (input: URL, init?: RequestInit) => Promise<Response>;
+export declare function applyCapabilityEnablement(item: CapabilityCatalogItem, installation: CapabilityInstallation | undefined, activePackIds: Set<string>): CapabilityCatalogItem;

package/dist/domain/environments.d.ts

@@ -0,0 +1,33 @@
+import { type Settings } from "@opengeni/config";
+import type { AccessGrant, VariableSet } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+export declare const MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
+export declare const MAX_VARIABLES_PER_ENVIRONMENT = 100;
+export declare function assertAllowedVariableSetVariableName(name: string): void;
+/** @deprecated use assertAllowedVariableSetVariableName */
+export declare const assertAllowedEnvironmentVariableName: typeof assertAllowedVariableSetVariableName;
+export declare function requireVariableSetEncryption(settings: Settings): Uint8Array;
+/** @deprecated use requireVariableSetEncryption */
+export declare const requireEnvironmentEncryption: typeof requireVariableSetEncryption;
+export declare function requireVariableSetForApi(db: Database, workspaceId: string, variableSetId: string): Promise<VariableSet>;
+/**
+ * Validates an variableSet attachment supplied in a request payload (session
+ * create, scheduled task create/update, pack enable). Requires the
+ * `variable-sets:use` permission unless the attachment was already authorized
+ * (pack-installation-inherited attachments), and maps a missing or
+ * cross-variable set to 422 because the id is payload, not the route
+ * target. RLS plus the workspace_id clause make cross-workspace ids
+ * indistinguishable from missing ones.
+ */
+export declare function validateVariableSetAttachment(deps: {
+    settings: Settings;
+    db: Database;
+}, grant: AccessGrant, workspaceId: string, variableSetId: string, options?: {
+    preauthorized?: boolean;
+}): Promise<VariableSet>;
+export declare function recordVariableSetAuditEvent(db: Database, input: {
+    grant: AccessGrant;
+    action: "variable_set.created" | "variable_set.updated" | "variable_set.deleted" | "variable_set.variable.set" | "variable_set.variable.deleted";
+    variableSetId: string;
+    variableName?: string;
+}): Promise<void>;

package/dist/domain/insights.d.ts

@@ -0,0 +1,11 @@
+import { type Settings } from "@opengeni/config";
+import { type InsightsRange, type WorkspaceInsightsResponse } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+export type GetWorkspaceInsightsInput = {
+    workspaceId: string;
+    range: InsightsRange;
+    provider?: string | null;
+    model?: string | null;
+    now?: Date;
+};
+export declare function getWorkspaceInsights(db: Database, settings: Settings, input: GetWorkspaceInsightsInput): Promise<WorkspaceInsightsResponse>;

package/dist/domain/packs.d.ts

@@ -0,0 +1,27 @@
+import { CapabilityPack, type ScheduledTaskAgentConfig, type SocialConnection } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+export declare const MARKETING_SOCIAL_PACK_ID = "marketing-social-daily-analysis";
+export declare function listCapabilityPacks(): CapabilityPack[];
+export declare function getCapabilityPack(packId: string): CapabilityPack | null;
+export declare function isBuiltInCapabilityPack(packId: string): boolean;
+/**
+ * Built-in packs plus the manifests registered for this workspace. Stored
+ * manifests were validated at registration time; rows that no longer parse
+ * (for example after a contract tightening) are skipped instead of breaking
+ * the whole catalog.
+ */
+export declare function listWorkspaceCapabilityPacks(db: Database, workspaceId: string): Promise<CapabilityPack[]>;
+export declare function resolveCapabilityPack(db: Database, workspaceId: string, packId: string): Promise<CapabilityPack | null>;
+/**
+ * v1 pack-scoped runtime rule: at most one enabled pack per workspace may
+ * declare a `sandboxImage` — there is deliberately no image composition or
+ * layering. Enforced when a pack is enabled (both the packs endpoint and the
+ * generic capability enable path) and re-checked at session start by the
+ * worker, which also covers manifests re-registered after enablement.
+ */
+export declare function assertPackSandboxImageCompatible(db: Database, workspaceId: string, pack: CapabilityPack): Promise<void>;
+export declare function buildMarketingDailyAnalysisAgentConfig(input: {
+    connections: SocialConnection[];
+    documentBaseIds: string[];
+    promptInstructions?: string;
+}): ScheduledTaskAgentConfig;

package/dist/domain/resources.d.ts

@@ -0,0 +1,32 @@
+import type { Settings } from "@opengeni/config";
+import { mergeToolRefs, stableJson, type ResourceRef, type ToolRef } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+export declare function validateToolRefs(tools: ToolRef[], settings: McpSettings): ToolRef[];
+type McpSettings = Pick<Settings, "mcpServers">;
+export declare function enabledCapabilityMcpToolRefs(settings: McpSettings, runtimeSettings: McpSettings): ToolRef[];
+export declare function withDefaultEnabledCapabilityMcpTools(tools: ToolRef[], settings: McpSettings, runtimeSettings: McpSettings): ToolRef[];
+/** Drop stored refs that are no longer present in the current runtime registry. */
+export declare function availableToolRefs(tools: ToolRef[], settings: McpSettings): ToolRef[];
+/** A child or fixed-policy follow-up may narrow its allow-list, never widen it. */
+export declare function assertToolRefsSubset(requested: ToolRef[], allowed: ToolRef[], message?: string): void;
+/** Validate runtime availability and then enforce the durable policy fence. */
+export declare function validateToolRefsForSessionPolicy(input: {
+    requested: ToolRef[];
+    settings: McpSettings;
+    allowedTools: ToolRef[];
+    message: string;
+}): ToolRef[];
+export declare function normalizeResources(resources: ResourceRef[]): ResourceRef[];
+export declare function mergeResourceRefs(existing: ResourceRef[], additions: ResourceRef[]): ResourceRef[];
+export declare function validateGitHubRepositorySelectionShapes(resources: ResourceRef[]): number[];
+/** @deprecated Use validateGitHubRepositorySelectionShapes for multi-installation sessions. */
+export declare function validateGitHubRepositorySelectionShape(resources: ResourceRef[]): number | null;
+export declare function validateGitHubRepositorySelection(db: Database, workspaceId: string, resources: ResourceRef[]): Promise<void>;
+/**
+ * A 422 from repository selection validation is an authoritative stale or
+ * revoked identity. Other failures (for example a database/catalog outage)
+ * leave the result unknown and must not cause draft hydration to delete it.
+ */
+export declare function isAuthoritativeGitHubRepositorySelectionError(error: unknown): boolean;
+export declare function validateFileResources(db: Database, workspaceId: string, resources: ResourceRef[]): Promise<void>;
+export { mergeToolRefs, stableJson };

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

@@ -0,0 +1,72 @@
+import type { Settings } from "@opengeni/config";
+import type { AccessGrant, ScheduledTask, CreateScheduledTaskRequest as CreateScheduledTaskPayload, UpdateScheduledTaskRequest as UpdateScheduledTaskPayload } from "@opengeni/contracts";
+import { type Database, type UpdateScheduledTaskInput } from "@opengeni/db";
+import type { SessionWorkflowClient } from "../dependencies";
+import type { ObjectStorageDependency } from "../dependencies";
+/**
+ * Whether a raw scheduled-task payload explicitly set agentConfig.tools.
+ * Zod's `.default([])` erases the distinction between "absent" and
+ * "explicitly empty", so callers detect it on the raw payload — the same
+ * contract sessions use: absent tools mean "give me the workspace defaults
+ * (enabled capability MCP servers)", an explicit list (even empty) is taken
+ * verbatim.
+ */
+export declare function scheduledTaskToolsProvided(rawPayload: unknown): boolean;
+export declare function createValidatedScheduledTask(input: {
+    settings: Settings;
+    db: Database;
+    objectStorage: ObjectStorageDependency;
+    grant: AccessGrant;
+    payload: CreateScheduledTaskPayload;
+    toolsProvided?: boolean;
+    variableSetPreauthorized?: boolean;
+}): Promise<ScheduledTask>;
+export declare function validatedScheduledTaskUpdate(input: {
+    settings: Settings;
+    db: Database;
+    objectStorage: ObjectStorageDependency;
+    grant: AccessGrant;
+    existing: ScheduledTask;
+    payload: UpdateScheduledTaskPayload;
+    /** See createValidatedScheduledTask; only consulted when agentConfig is updated. */
+    toolsProvided?: boolean;
+}): Promise<UpdateScheduledTaskInput>;
+export declare function requireScheduledTaskForApi(db: Database, workspaceId: string, taskId: string): Promise<ScheduledTask>;
+export declare function restoreScheduledTask(db: Database, task: ScheduledTask): Promise<ScheduledTask>;
+export declare function syncCreatedScheduledTask(input: {
+    db: Database;
+    workflowClient: SessionWorkflowClient;
+    task: ScheduledTask;
+}): Promise<void>;
+export declare function syncUpdatedScheduledTask(input: {
+    db: Database;
+    workflowClient: SessionWorkflowClient;
+    previous: ScheduledTask;
+    task: ScheduledTask;
+}): Promise<void>;
+export declare function scheduledTaskTemporalScheduleId(taskId: string): string;
+/**
+ * Stable token that identifies a single logical manual trigger. A client that
+ * retries a `/trigger` POST (network blip, lambda re-invocation) passes the
+ * SAME token so the retry is idempotent — one usage charge, one workflow run.
+ * When the client supplies nothing we mint one UUID PER REQUEST and reuse it
+ * for both the idempotency key and the workflowId, so a single request stays
+ * internally consistent while two genuinely-distinct manual triggers (no token,
+ * fired a second apart) still each get their own run. The token is sanitized to
+ * the Temporal workflow-id-safe charset so a client value cannot smuggle a
+ * collision into a different task's id space.
+ */
+export declare function scheduledTaskTriggerToken(clientTriggerId?: string | null): string;
+/**
+ * Deterministic Temporal workflow id for a manual trigger. Derived purely from
+ * the task id and the stable trigger token, so a retry with the same token maps
+ * to the same id and `workflowIdReusePolicy: "REJECT_DUPLICATE"` collapses the
+ * second start into a no-op instead of spawning a second run.
+ */
+export declare function manualScheduledTaskTriggerWorkflowId(taskId: string, triggerToken: string): string;
+/**
+ * Deterministic usage idempotency key for a manual trigger's agent_run.created
+ * charge. Shares the stable trigger token with the workflow id so the charge
+ * and the run dedupe together under retry.
+ */
+export declare function manualScheduledTaskTriggerUsageKey(workspaceId: string, taskId: string, triggerToken: string): string;

package/dist/domain/session-tool-policy.d.ts

@@ -0,0 +1,31 @@
+import type { Settings } from "@opengeni/config";
+import { type Session, type SessionEffectiveToolPolicy, type SessionToolPolicy, type ToolRef } from "@opengeni/contracts";
+import type { Database } from "@opengeni/db";
+export type ResolvedSessionToolPolicy = {
+    toolRefs: ToolRef[];
+    effectivePolicy: SessionEffectiveToolPolicy;
+};
+export type SessionToolPolicyInput = {
+    toolPolicy: SessionToolPolicy;
+    sessionTools: ToolRef[];
+    availableMcpServerIds: Iterable<string>;
+    /** Current omitted-tools defaults, intentionally narrower than all servers. */
+    defaultMcpServerIds?: Iterable<string>;
+};
+/** Every configured runtime MCP defaults on; mandatory carrier IDs are separate. */
+export declare function defaultSessionMcpServerIds(servers: Iterable<{
+    id: string;
+}>): string[];
+/**
+ * Resolve the same ID-only policy used by API projections and worker turns.
+ * This function never receives endpoint URLs, credentials, schemas, or live
+ * probe results. `availableMcpServerIds` is the resolved runtime registry;
+ * `defaultMcpServerIds` is the current configured omitted-tools default.
+ */
+export declare function resolveSessionToolPolicy(input: SessionToolPolicyInput): ResolvedSessionToolPolicy;
+/** Current full runtime registry IDs, including configured static servers. */
+export declare function workspaceSessionToolPolicyServerIds(db: Database, workspaceId: string, settings: Settings): Promise<string[]>;
+/** Current omitted-tools defaults: every configured runtime MCP is on. */
+export declare function workspaceSessionToolPolicyDefaultServerIds(db: Database, workspaceId: string, settings: Settings): Promise<string[]>;
+/** Add a bounded, secret-safe effective projection to a session response. */
+export declare function sessionWithEffectiveToolPolicy(session: Session, workspaceServerIds: Iterable<string>, workspaceDefaultServerIds?: Iterable<string>): Session;