@gestaltrun/dsh-im-runtime 0.0.0-stage → 0.1.5

package/lib/types/runtime.d.ts

@@ -0,0 +1,668 @@
+/** Durable IM account, route, and simulation-target service. */
+import { type SqliteLockingMode } from './sqlite-connection.ts';
+import { type ImClockSource } from './time.ts';
+import type { ImInjectSimulationOperatorRequest, ImSimulationOperatorReceipt } from './simulation-operator.ts';
+import type { ImUploadBinding } from './upload-types.ts';
+import type { SqliteJournalMode } from './nas-host-lease.ts';
+import { Context, Service } from '@deepseek-ai/cordis';
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import './session-events.ts';
+import type { WorkspaceId } from '@deepseek-ai/dsh-workspace';
+import { type ZodType } from 'zod';
+import { type ImCheckpointActivity, type ImCheckpointTransport } from './checkpoint.ts';
+import type { ImExecutionAggregate } from './delivery-schema.ts';
+import { ImInputDrain, type ImInputPause } from './input-drain.ts';
+import { type ImAccountCheckpointRecovery } from './checkpoint-recovery.ts';
+import { type ImAccountPlacementSlice } from './account-placement.ts';
+import { type ImAdmissionAnnotator, type ImAdmissionAnnotationInput } from './admission-annotations.ts';
+import type { ImSendMediaMessageRequest } from './delivery-types.ts';
+import { ImTyping } from './typing.ts';
+import { ImRoutePolicies } from './policies.ts';
+import type { ImPolicyCheckKind, ImPolicyCheckRequest, ImPolicyDecision } from './policies.ts';
+import { ImTransports } from './transports.ts';
+import type { ImAutomaticSendAuthorization } from './transport.ts';
+import type { ImBeginOutboundAttemptRequest, ImBeginOutboundAttemptResult, ImAgentTaskId, ImAgentTaskView, ImCancelPendingAiRequest, ImCommitProviderCursorRequest, ImConversationCursor, ImConversationProjection, ImConversationRecords, ImCustomerSessionListRequest, ImCustomerSessionPage, ImCustomerListPage, ImCustomerListRequest, ImCustomerReadAckRequest, ImDeliveryChange, ImDeliveryOperationId, ImDeliveryScope, ImGetOutboundRequest, ImHandlingControl, ImHistoryPage, ImHistoryQueryRequest, ImImportJsonlHistoryRequest, ImImportJsonlHistoryResult, ImInboundMessageView, ImInboundSenderEvidence, ImInboundOperationQuery, ImInboundPageResult, ImIngestInboundPageRequest, ImMarkSubmittedRequest, ImMarkSubmittedResult, ImManualMessageQuery, ImManualMessageQueryRequest, ImManualMessageResult, ImMessageId, ImMessageSource, ImOutboundPage, ImOutboundQueryRequest, ImOutboundAttemptId, ImOutboundRouteBinding, ImOutboundView, ImPendingInboundRequest, ImProviderCursorCommitResult, ImProviderCursorOperationQuery, ImProviderCursorOwner, ImProviderCursorView, ImRealDeliveryScope, ImRealSessionBinding, ImRegisterOutboundRequest, ImRetryManualMessageRequest, ImSendManualMessageRequest, ImSessionReconciliationResult, ImSenderAttribution, ImSetHandlingControlRequest, ImSettleOutboundAttemptRequest, ImSettleSimulationOutboundRequest, ImSimulationDeliveryScope, ImSimulationInstanceId, ImScopeId } from './delivery-types.ts';
+import type { ImAccountId, ImAccountCandidate, ImAccountSetupId, ImAccountSetupPreview, ImCancelAccountSetupResult, ImConfirmAccountSetupRequest, ImAccountLifecycleRequest, ImAccountSetupRequest, ImAccountMutationResult, ImAccountOperationQuery, ImAccountView, ImAssignedActorCandidate, ImConversationCandidate, ImConversationCandidatePage, ImConversationKind, ImDirectRecipient, ImCreateRouteRequest, ImDeleteRouteRequest, ImOperationId, ImPlatform, ImPlatformLoginAttemptId, ImPlatformLoginStatus, ImRebindRouteRequest, ImRemoveSimulationTargetRequest, ImRevision, ImRouteId, ImRouteMutationResult, ImRouteOperationQuery, ImRouteResolution, ImRouteTarget, ImRouteView, ImRuntimeChange, ImRuntimeSnapshot, ImSaveRouteRequest, ImSaveSimulationTargetRequest, ImSetAccountPausedRequest, ImSimulationTargetMutationResult, ImSimulationTargetOperationQuery, ImCreateSimulationInstanceRequest, ImCreateManualSimulationInstanceRequest, ImSimulationInjectionQuery, ImInjectSimulationManagedHumanRequest, ImInjectSimulationMemberRequest, ImImportSimulationHistoryRequest, ImImportSimulationHistoryResult, ImSimulationInstanceView, ImSimulationSessionScope, ImSimulationTargetView } from './types.ts';
+import type { ImRuntimeService } from './service-types.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * Synchronous controller veto immediately before an automatic external submission.
+         * @param request - Current route controller and conversation.
+         * @returns A refusal to block submission, or void to delegate.
+         * @mode bail
+         */
+        'imRuntime/authorize-submission'(request: ImPolicyCheckRequest): Extract<ImPolicyDecision, {
+            allow: false;
+        }> | void;
+    }
+}
+/** Stable Wangwang refusal when a direct send has no observed counterpart sender. */
+export declare const WANGWANG_DIRECT_RECIPIENT_UNAVAILABLE = "WANGWANG_DIRECT_RECIPIENT_UNAVAILABLE";
+/** Runtime admission, listener recovery, storage, and checkpoint settings. */
+export interface Config {
+    /** IANA shop time zone for inbound records and clock context; defaults to Asia/Shanghai. */
+    readonly timeZone?: string;
+    /** Milliseconds before a verified typing observation disappears; defaults to 5000. */
+    readonly typingTimeoutMs?: number;
+    /** Maximum decoded bytes in one selected media file; SDK and platform limits may be lower. */
+    readonly mediaMaxBytes?: number;
+    /** Delay between durable upload retries; network failures never stop IM delivery. */
+    readonly uploadRetryMs?: number;
+    /** Explicit test run marks real-provider messages as test traffic. */
+    readonly uploadTestRunId?: string | undefined;
+    /** Maximum inbound messages copied into one Agent input. */
+    readonly admissionBatchSize?: number;
+    /** Time that unconfirmed provider setup material remains in Host memory. */
+    readonly accountSetupTtlMs?: number;
+    /** Sqlite file for conversation, cursor, and execution records. */
+    readonly deliverySqlitePath?: string | undefined;
+    /** SQLite 日志模式，本地缺省 WAL，NAS 配置为 DELETE。 */
+    readonly deliveryJournalMode?: SqliteJournalMode;
+    /** Connection locking policy; EXCLUSIVE requires sole ownership until close. Defaults to NORMAL. */
+    readonly deliveryLockingMode?: SqliteLockingMode;
+    /** Page-cache budget in KiB, from 1 through 2147483647; omitted keeps SQLite defaults. */
+    readonly deliveryCacheSizeKiB?: number | undefined;
+    /** 投递库语句遇锁等待毫秒数；NAS 交接窗口内旧实例短暂持锁时等待而非立即失败。整数 0–60000，缺省 2000。 */
+    readonly deliveryBusyTimeoutMs?: number;
+    /** 投递库迁移单步遇锁重试的时间预算毫秒数；超限抛 `IM_DELIVERY_SQLITE_BUSY` 且版本号保持不变。整数 0–600000，缺省 30000。 */
+    readonly deliveryMigrationRetryBudgetMs?: number;
+    /** 云端必须等待 nasHostLease 准入；缺失服务时启动失败。 */
+    readonly requireNasLease?: boolean;
+    /** Private evaluation resources and simulation upload queue when the cloud Host has no lease; requires placement standby. */
+    readonly standbyStorageRoot?: string | undefined;
+    /** 交接目标在导入和 prepareResume 完成前停止监听与新 turn，由 Host 显式释放。 */
+    readonly placementStandby?: boolean;
+    /** Minimum interval between hosting checkpoint reports for one Host. Cursor advances inside the interval share one report. */
+    readonly checkpointIntervalMs?: number;
+    /** Delay before the first listener reconnect attempt, in milliseconds. */
+    readonly listenerReconnectInitialMs?: number;
+    /** Maximum exponential reconnect delay, in milliseconds. */
+    readonly listenerReconnectMaxMs?: number;
+    /** Maximum reconnect starts before stable reception; zero disables retries. */
+    readonly listenerReconnectMaxAttempts?: number;
+    /** Continuous running time before retry reset, in milliseconds; a page committed while running resets it earlier. */
+    readonly listenerReconnectStableMs?: number;
+}
+interface ResolvedConfig {
+    readonly timeZone: string;
+    readonly typingTimeoutMs: number;
+    readonly mediaMaxBytes: number;
+    readonly uploadRetryMs: number;
+    readonly uploadTestRunId?: string;
+    readonly admissionBatchSize: number;
+    readonly accountSetupTtlMs: number;
+    readonly deliveryJournalMode: SqliteJournalMode;
+    readonly deliveryLockingMode: SqliteLockingMode;
+    readonly deliveryCacheSizeKiB: number | null;
+    readonly deliveryBusyTimeoutMs: number;
+    readonly deliveryMigrationRetryBudgetMs: number;
+    readonly requireNasLease: boolean;
+    readonly standbyStorageRoot?: string | undefined;
+    readonly placementStandby: boolean;
+    readonly checkpointIntervalMs: number;
+    readonly listenerReconnectInitialMs: number;
+    readonly listenerReconnectMaxMs: number;
+    readonly listenerReconnectMaxAttempts: number;
+    readonly listenerReconnectStableMs: number;
+    readonly deliverySqlitePath?: string | undefined;
+}
+/** Host service implementing the durable configuration half of IM takeover. */
+export declare class ImRuntime extends Service implements ImRuntimeService {
+    static inject: string[];
+    static Config: ZodType<Config>;
+    private readonly admissionAnnotations;
+    private readonly simulationClocks;
+    private uploadBinding;
+    private uploadQueue;
+    private settleUploads;
+    private wakeUploads;
+    private readonly restartOwner;
+    private nasLease;
+    /** Instance-private evaluation resource root; absent for formal storage. */
+    standbyStorageRoot: string | undefined;
+    private evaluationAccounts?;
+    private evaluationTail;
+    private accounts?;
+    private simulationTargets?;
+    private simulationInstances?;
+    private deliveryRecords?;
+    private readonly mediaLifetime;
+    private mediaSender?;
+    private delivery?;
+    /** Host 输入排空；不改变持久化的账号和托管意图。 */
+    readonly inputDrain: ImInputDrain;
+    private readonly placementSdkImports;
+    private placementStandby;
+    private readonly placementImports;
+    private readonly placementRecoveries;
+    private readonly placementImportPauses;
+    /** Input holds of rejected placement-import attempts; the next attempt reuses them instead of adding a hold release cannot reach. */
+    private readonly placementRetryPauses;
+    private readonly placementStopped;
+    private readonly accountInputs;
+    private agentScope;
+    private agentAccounts;
+    private coordinator;
+    private simulationController;
+    private readonly pendingAutomaticPauses;
+    private checkpointReporter;
+    private readonly automaticSendEpochs;
+    private generation;
+    private deliveryGeneration;
+    private simulationTail;
+    private readonly activeListeners;
+    private readonly listenerStates;
+    private readonly listenerTails;
+    private readonly listenerRetries;
+    private readonly listenerAttempts;
+    private listenersDisposed;
+    private readonly pendingAccountSetups;
+    private readonly setupAccounts;
+    private reservedPlacementAccountId;
+    private readonly observations;
+    readonly transports: ImTransports;
+    readonly policies: ImRoutePolicies;
+    /** Transient sidebar typing; independent of durable delivery and Agent input. */
+    readonly typing: ImTyping;
+    /** Shop time zone used by inbound records and customer-service context. */
+    get timeZone(): string;
+    readonly config: ResolvedConfig;
+    /** @param ctx - Cordis context carrying StorageDomain and Credentials. @param config - validated Agent admission limits. */
+    constructor(ctx: Context, config?: Config);
+    /** @param annotator - Optional product analysis. @returns Disposer that prevents further calls. */
+    registerAdmissionAnnotator(annotator: ImAdmissionAnnotator): () => Promise<void>;
+    /** @param input - Frozen message batch. @param signal - Coordinator lifetime. @returns Results frozen into the pending admission before append. */
+    annotateAdmission(input: ImAdmissionAnnotationInput, signal: AbortSignal): Promise<readonly import('./delivery-types.ts').ImAdmissionAnnotation[]>;
+    /** Open the authoritative configuration domain before publishing the service. */
+    protected [Service.init](): Promise<void>;
+    private initializeMediaResources;
+    /**
+     * Bind the product's authenticated customer-message transport. Standby uploads only evaluation simulation messages from private storage. A journal in each SQLite mutation bridges crashes before the external queue is synced.
+     * @param binding - capture eligibility and credential-free destination, plus cancellable transport.
+     * @returns async disposer that aborts and awaits the current request before SQLite closes.
+     */
+    bindMessageUpload(binding: ImUploadBinding): () => Promise<void>;
+    private reportUpload;
+    /**
+     * Send throttled hosting checkpoints through this transport.
+     * @param transport - server reporter. A later bind replaces the previous one.
+     * @param activity - product-owned intent, admission and model availability.
+     * @returns disposer that stops reporting.
+     */
+    bindCheckpointTransport(transport: ImCheckpointTransport, activity?: (accountId: ImAccountId) => Omit<ImCheckpointActivity, 'inFlight'>): () => void;
+    /** @param accountId - account whose held lease epoch changed. */
+    resumeCheckpoint(accountId: ImAccountId): void;
+    /** @param accountId - account whose automatic reception state changed. */
+    noteCheckpoint(accountId: ImAccountId): void;
+    private checkpointFacts;
+    snapshot(): ImRuntimeSnapshot;
+    subscribe(listener: (change: ImRuntimeChange) => void): () => void;
+    startPlatformLogin(platform: ImPlatform, signal?: AbortSignal): Promise<ImPlatformLoginStatus>;
+    platformLoginStatus(platform: ImPlatform, attemptId: ImPlatformLoginAttemptId): ImPlatformLoginStatus;
+    cancelPlatformLogin(platform: ImPlatform, attemptId: ImPlatformLoginAttemptId): Promise<ImPlatformLoginStatus>;
+    listAccountCandidates(platform: ImPlatform, signal?: AbortSignal): Promise<readonly ImAccountCandidate[]>;
+    discoverConversations(accountId: ImAccountId, signal?: AbortSignal): Promise<ImConversationCandidatePage>;
+    inspectConversation(accountId: ImAccountId, conversationId: string, conversationKind: ImConversationKind, signal?: AbortSignal): Promise<ImConversationCandidate>;
+    /** @param accountId - configured account. @param signal - caller lifetime. @returns assigned service accounts when the platform exposes them. */
+    listAssignedActors(accountId: ImAccountId, signal?: AbortSignal): Promise<readonly ImAssignedActorCandidate[]>;
+    previewAccountSetup(request: ImAccountSetupRequest, signal?: AbortSignal): Promise<ImAccountSetupPreview>;
+    confirmAccountSetup(request: ImConfirmAccountSetupRequest): Promise<ImAccountMutationResult>;
+    cancelAccountSetup(setupId: ImAccountSetupId): ImCancelAccountSetupResult;
+    /** @returns After all evaluation consumers and storage handles have closed; call from the placement owner after evaluation and CLI join. */
+    closeEvaluationResources(): Promise<void>;
+    /** @returns After this runtime reloads against an admitted NAS lease; consumers must be reacquired by the caller. */
+    reloadWithNasLease(): Promise<void>;
+    /** @inheritdoc */
+    holdsNasLease(): boolean;
+    /** @inheritdoc */
+    ensureEvaluationAccount(sellerId: string, workspaceId: WorkspaceId): Promise<{
+        readonly account: ImAccountView;
+        readonly route: ImRouteView;
+    }>;
+    /** @inheritdoc */
+    isEvaluationAccount(accountId: ImAccountId, sellerId?: string): boolean;
+    /** @inheritdoc */
+    releaseEvaluationAccountRoute(accountId: ImAccountId, observedRevision: ImRevision): Promise<boolean>;
+    private evaluationOperation;
+    private evaluationAccountTable;
+    addAccount(request: ImAccountSetupRequest, signal?: AbortSignal): Promise<ImAccountView>;
+    setAccountPaused(request: ImSetAccountPausedRequest): Promise<ImAccountMutationResult>;
+    disconnectAccount(request: ImAccountLifecycleRequest): Promise<ImAccountMutationResult>;
+    /** @inheritdoc */
+    setSdkConnectionIntent(accountId: ImAccountId, intent: ImAccountView['sdkConnectionIntent'], expectedIntent?: {
+        readonly revision: ImAccountView['sdkConnectionIntentRevision'];
+    }): Promise<boolean>;
+    reconnectAccount(request: ImAccountLifecycleRequest): Promise<ImAccountMutationResult>;
+    /** @inheritdoc */
+    retainedAccounts(): readonly {
+        readonly account: ImAccountView;
+        readonly replacedHidden: boolean;
+    }[];
+    /** @inheritdoc */
+    hideReplacedAccount(request: ImAccountLifecycleRequest): Promise<ImAccountMutationResult>;
+    /** @inheritdoc */
+    restoreReplacedAccount(request: ImAccountLifecycleRequest, setup: ImAccountSetupRequest, signal?: AbortSignal): Promise<ImAccountMutationResult>;
+    /**
+     * Delete one configured account after comparing its observed revision.
+     * @param request - account identity and revision observed before confirmation.
+     * @returns the durable deletion receipt.
+     */
+    deleteAccount(request: ImAccountLifecycleRequest): Promise<ImAccountMutationResult>;
+    /**
+     * Install verified credentials for the same merchant under the observed revision.
+     * @param request - account and revision observed before the OAuth allocation started.
+     * @param setup - Host-only credentials for that same merchant; never a replacement merchant.
+     * @param signal - generation lifetime during verification and installation.
+     * @returns a durable receipt; a concurrent lifecycle command wins without changing credentials.
+     */
+    renewAccount(request: ImAccountLifecycleRequest, setup: ImAccountSetupRequest, signal?: AbortSignal): Promise<ImAccountMutationResult>;
+    private renewCredentials;
+    refreshAccount(request: ImAccountLifecycleRequest, signal?: AbortSignal): Promise<ImAccountMutationResult>;
+    queryAccountOperation(accountId: ImAccountId, operationId: ImOperationId): ImAccountOperationQuery;
+    createRoute(request: ImCreateRouteRequest): Promise<ImRouteMutationResult>;
+    saveRoute(request: ImSaveRouteRequest): Promise<ImRouteMutationResult>;
+    rebindRoute(request: ImRebindRouteRequest): Promise<ImRouteMutationResult>;
+    deleteRoute(request: ImDeleteRouteRequest): Promise<ImRouteMutationResult>;
+    queryRouteOperation(account: ImAccountId, operationId: ImOperationId): ImRouteOperationQuery;
+    /**
+     * Keep history flowing for one account without an enabled admit route.
+     * @param accountId - connected account.
+     * @param observation - conversation kind and target to receive.
+     * @returns disposer that drops the lease and reconciles the listener.
+     */
+    registerObservation(accountId: ImAccountId, observation: {
+        readonly conversationKind: ImConversationKind;
+        readonly target: ImRouteTarget;
+    }): () => void;
+    /**
+     * Authorize one admission or automated send when the route declared a controller.
+     * Ordinary routes without a controller are allowed.
+     * @param kind - check moment.
+     * @param route - frozen route.
+     * @param scope - conversation identity.
+     */
+    authorizeRoutePolicy(kind: ImPolicyCheckKind, route: ImRouteView, scope: import('./delivery-types.ts').ImDeliveryScope): Promise<ImPolicyDecision>;
+    resolveRoute(account: ImAccountId, conversationKind: ImConversationKind, conversationId: string, assignedActorId?: string): ImRouteResolution;
+    /** Whether this real conversation currently admits automatic handling. */
+    private conversationAdmits;
+    /** @param scope - durable real conversation. @returns last admitted presentation, including the assigned service account when known. */
+    getConversationPresentation(scope: ImRealDeliveryScope): import('./delivery-types.ts').ImConversationPresentation | undefined;
+    saveSimulationTarget(request: ImSaveSimulationTargetRequest): Promise<ImSimulationTargetMutationResult>;
+    /** @inheritdoc */
+    saveFormalSimulationTarget(request: ImSaveSimulationTargetRequest): Promise<ImSimulationTargetMutationResult>;
+    private saveTarget;
+    removeSimulationTarget(request: ImRemoveSimulationTargetRequest): Promise<ImSimulationTargetMutationResult>;
+    /** @inheritdoc */
+    removeFormalSimulationTarget(request: ImRemoveSimulationTargetRequest): Promise<ImSimulationTargetMutationResult>;
+    private removeTarget;
+    private requireNonEvaluationTargets;
+    querySimulationTargetOperation(workspaceId: WorkspaceId, operationId: ImOperationId): ImSimulationTargetOperationQuery;
+    listSimulationInstances(): readonly ImSimulationInstanceView[];
+    getSimulationInstance(instanceId: ImSimulationInstanceId): ImSimulationInstanceView | undefined;
+    holdSimulationBuyer(instanceId: ImSimulationInstanceId): () => void;
+    deliverSimulationBuyerReplies(instanceId: ImSimulationInstanceId): Promise<number>;
+    registerSimulationClock(instanceId: ImSimulationInstanceId, source: ImClockSource): () => void;
+    private deliveryTime;
+    currentTime(sessionId: SessionId): number;
+    scopeForSession(sessionId: SessionId): ImSimulationSessionScope | undefined;
+    realScopeForSession(sessionId: SessionId): ImRealSessionBinding | undefined;
+    realBindingForScope(scopeId: ImScopeId): ImRealSessionBinding | undefined;
+    sendManualMessage(request: ImSendManualMessageRequest, signal?: AbortSignal): Promise<ImManualMessageResult>;
+    private sendManualMediaMessage;
+    /** @param request - Host-authorized media bytes and owning scope; automatic calls require the frozen task route. @param signal - operation cancellation. @returns durable media outbox result; uncertain submission is never repeated. */
+    sendMediaMessage(request: ImSendMediaMessageRequest, signal?: AbortSignal): Promise<ImOutboundView>;
+    private dispatchMediaMessage;
+    /** @param request - manual Session or scope identity and an owned file request. @returns a fresh download URL, requiring the current online IM generation. */
+    mediaDownloadUrl(request: ImManualMessageQueryRequest): Promise<string>;
+    queryManualMessage(request: ImManualMessageQueryRequest): ImManualMessageQuery;
+    confirmManualMessage(request: ImManualMessageQueryRequest, signal?: AbortSignal): Promise<ImManualMessageResult>;
+    retryManualMessage(request: ImRetryManualMessageRequest, signal?: AbortSignal): Promise<ImManualMessageResult>;
+    createManualSimulationInstance(request: ImCreateManualSimulationInstanceRequest): Promise<ImSimulationInstanceView>;
+    createSimulationInstance(request: ImCreateSimulationInstanceRequest): Promise<ImSimulationInstanceView>;
+    /** @inheritdoc */
+    createFormalSimulationInstance(request: ImCreateSimulationInstanceRequest): Promise<ImSimulationInstanceView>;
+    injectSimulationMember(request: ImInjectSimulationMemberRequest): Promise<ImInboundMessageView>;
+    injectSimulationManagedHuman(request: ImInjectSimulationManagedHumanRequest): Promise<ImInboundMessageView>;
+    injectSimulationOperator(request: ImInjectSimulationOperatorRequest): Promise<ImSimulationOperatorReceipt>;
+    querySimulationInjection(request: ImSimulationInjectionQuery): ImInboundOperationQuery;
+    beginStopSimulation(instanceId: ImSimulationInstanceId): Promise<ImSimulationInstanceView>;
+    beginStopSimulationForSession(sessionId: SessionId): Promise<ImSimulationInstanceView>;
+    waitSimulationStopped(instanceId: ImSimulationInstanceId): Promise<ImSimulationInstanceView>;
+    subscribeDelivery(listener: (change: ImDeliveryChange) => void): () => void;
+    ingestInboundPage(request: ImIngestInboundPageRequest): Promise<ImInboundPageResult>;
+    queryInboundOperation(scope: ImDeliveryScope, operationId: ImDeliveryOperationId): ImInboundOperationQuery;
+    getConversationCursor(scope: ImDeliveryScope): ImConversationCursor;
+    projectConversations<T extends object>(project: (records: ImConversationRecords) => T): ImConversationProjection<T>;
+    getProviderCursor(owner: ImProviderCursorOwner): ImProviderCursorView;
+    commitProviderCursor(request: ImCommitProviderCursorRequest): Promise<ImProviderCursorCommitResult>;
+    queryProviderCursorOperation(owner: ImProviderCursorOwner, operationId: ImDeliveryOperationId): ImProviderCursorOperationQuery;
+    queryHistory(request: ImHistoryQueryRequest): ImHistoryPage;
+    /**
+     * List customer rows for one account and source from the rebuildable index.
+     * @param request - account, real/simulation filter, optional substring, and reader.
+     */
+    listCustomers(request: ImCustomerListRequest): ImCustomerListPage;
+    /** @param request - account, source, search and cursor. @returns customer Session references without unread calculations. */
+    listCustomerSessions(request: ImCustomerSessionListRequest): ImCustomerSessionPage;
+    /**
+     * Advance one reader's live inbound watermark with max semantics.
+     * @param request - reader, scope, and observed arrival sequence.
+     */
+    ackCustomerRead(request: ImCustomerReadAckRequest): void;
+    /**
+     * Persist one scope's automatic-handling pause fact.
+     * @param request - scope and pause fields.
+     */
+    setHandlingControl(request: ImSetHandlingControlRequest): ImHandlingControl;
+    /**
+     * Read one scope's automatic-handling pause fact.
+     * @param scopeId - complete conversation identity.
+     */
+    getHandlingControl(scopeId: ImScopeId): ImHandlingControl | undefined;
+    /**
+     * Project an unresolved durable forward pause into automatic-processing authorization.
+     * @param scopeId - Customer whose journal pause is unresolved.
+     * @param pending - True before attempting persistence; false only after reconciling the durable pause and journal acknowledgement.
+     * Pending projections survive their caller's disposal until reconciliation or runtime shutdown; they do not change the persisted handling control.
+     */
+    setAutomaticHandlingPausePending(scopeId: ImScopeId, pending: boolean): void;
+    /** @param scopeId - Complete customer scope. @returns Whether a pending journal pause or durable handling control blocks automatic processing. */
+    isAutomaticHandlingBlocked(scopeId: ImScopeId): boolean;
+    private recordHandlingPaused;
+    /**
+     * Open a persisted Agent Session and append `im/handling-paused`.
+     * When no Session log exists, skip the event: handling control remains the
+     * SQLite row from `setHandlingControl`, which is the source of truth for
+     * pause/resume even if a later Agent Session is created.
+     */
+    private appendHandlingPausedToPersisted;
+    /**
+     * Resolve a stored conversation identity from its scope id.
+     * @param scopeId - complete conversation identity.
+     */
+    getDeliveryScope(scopeId: ImScopeId): ImDeliveryScope | undefined;
+    pendingInbound(request: ImPendingInboundRequest): readonly ImInboundMessageView[];
+    getAgentTask(scope: ImDeliveryScope): ImAgentTaskView | undefined;
+    /** @param scope - complete conversation identity. @param messageId - stored inbound identity. @returns stored message. */
+    getInboundMessage(scope: ImDeliveryScope, messageId: ImMessageId): ImInboundMessageView;
+    messageSource(scope: ImDeliveryScope, messageId: ImMessageId): ImMessageSource;
+    markSubmitted(request: ImMarkSubmittedRequest): Promise<ImMarkSubmittedResult>;
+    /** Consume live pending that a route policy just refused, without an Agent turn. */
+    suppressUnadmitted(scope: ImDeliveryScope): Promise<void>;
+    /** Advance watermarks of conversations this newly enabled route would now admit. */
+    private suppressUnadmittedMatchedBy;
+    sessionUserMessage(scope: ImDeliveryScope, messageId: ImMessageId): UserMessage;
+    reconcileSession(sessionId: SessionId): Promise<ImSessionReconciliationResult>;
+    importJsonlHistory(request: ImImportJsonlHistoryRequest): Promise<ImImportJsonlHistoryResult>;
+    importSimulationHistory(request: ImImportSimulationHistoryRequest): Promise<ImImportSimulationHistoryResult>;
+    registerOutbound(request: ImRegisterOutboundRequest): Promise<ImOutboundView>;
+    /** @param request - scope-fixed automated intent. @param binding - task generation recorded before Agent execution. @returns durable intent or a route-changed rejection. */
+    registerAgentOutbound(request: ImRegisterOutboundRequest, binding: ImOutboundRouteBinding): Promise<ImOutboundView>;
+    /**
+     * Bind automatic provider preparation to one scope's handling epoch and durable attempt.
+     * @param request - Owning dispatch attempt.
+     * @param signal - Tool cancellation, retained after external submission.
+     * @returns Provider authorization; dispose after settlement. Submission rechecks controller policy; customer pause revokes only unsubmitted preparation.
+     */
+    automaticSendAuthorization(request: ImBeginOutboundAttemptRequest & {
+        readonly attemptId: ImOutboundAttemptId;
+    }, signal: AbortSignal): ImAutomaticSendAuthorization;
+    beginOutboundAttempt(request: ImBeginOutboundAttemptRequest): Promise<ImBeginOutboundAttemptResult>;
+    settleOutboundAttempt(request: ImSettleOutboundAttemptRequest): Promise<ImOutboundView>;
+    settleSimulationOutbound(request: ImSettleSimulationOutboundRequest): Promise<ImOutboundView>;
+    getOutbound(request: ImGetOutboundRequest): ImOutboundView | undefined;
+    queryOutbound(request: ImOutboundQueryRequest): ImOutboundPage;
+    cancelPendingAi(request: ImCancelPendingAiRequest): Promise<readonly ImOutboundView[]>;
+    /** @param accountId - authenticated transport account. @param messageId - observed SDK platform message. @param clientId - observed SDK UUID. @returns exact identifier matches in live single-chat history or confirmed outbox; never matches text. */
+    matchSdkMessage(accountId: ImAccountId, messageId: string, clientId?: string): readonly import('./read-types.ts').ImSdkMessageMatch[];
+    findSentOutbound(scope: ImRealDeliveryScope, externalMessageId: string): ImOutboundView | undefined;
+    private confirmUnknownOutbound;
+    private storedInbound;
+    private inboundSender;
+    classifyInboundSender(scope: ImRealDeliveryScope, evidence: ImInboundSenderEvidence): ImSenderAttribution;
+    private isNativeActor;
+    /** @param workspaceId - simulated-user Workspace. @returns its current target setting. */
+    simulationTargetForWorkspace(workspaceId: WorkspaceId): ImSimulationTargetView | undefined;
+    /** @param target - current workspace target setting. @returns its exact route when still present. */
+    routeForSimulationTarget(target: ImSimulationTargetView): ImRouteView | undefined;
+    /** @param target - current workspace target setting. @returns its exact safe account when still present. */
+    accountForSimulationTarget(target: ImSimulationTargetView): ImAccountView | undefined;
+    /** @param accountId - Simulation-owned account reference. @returns Formal or evaluation identity, excluding replaced accounts; never use for formal authorization. */
+    accountForSimulation(accountId: ImAccountId): ImAccountView | undefined;
+    /** @param accountId - Simulation-owned account reference. @param routeId - Exact route reference. @returns Its live formal or fixed evaluation route; never use for formal route mutation. */
+    routeForSimulation(accountId: ImAccountId, routeId: ImRouteId): ImRouteView | undefined;
+    /** @param scope - claimed frozen simulation scope. @returns whether its exact instance accepts delivery. */
+    isSimulationScopeRunning(scope: ImSimulationDeliveryScope): boolean;
+    /** Emit a post-commit instance notification for BFF followers. @param instanceId - changed instance. */
+    publishSimulationInstanceChange(instanceId: ImSimulationInstanceId): void;
+    private requireRealSessionBinding;
+    private requireManualBinding;
+    private assertNamedManualAccount;
+    /**
+     * Hosting controllers shop-match human-manual send the same way they
+     * shop-match `requireOwnedScope`. Ordinary routes without a controller skip.
+     */
+    private authorizeManualSend;
+    private realBindingForScopeSeat;
+    private bindingFromTask;
+    /**
+     * Direct peer that a send may use.
+     * Wangwang uses an observed external sender before the latest platform-provided peer saved on the conversation. The conversation id is never a recipient. Other platforms keep a stored peer, then an observed sender.
+     * @param scope - conversation being sent or displayed.
+     * @param stored - recipient frozen on the task, when one exists.
+     * @returns usable peer, or absence when neither sender evidence nor a platform peer exists.
+     */
+    usableDirectRecipient(scope: ImDeliveryScope, stored?: ImDirectRecipient): ImDirectRecipient | undefined;
+    /**
+     * Store the Wangwang peer a send is allowed to use, including clearing one unsupported by sender evidence or the platform.
+     * @param sessionId - Agent Session that owns the task, when one exists.
+     * @param recipient - usable peer, or absence.
+     */
+    rememberDirectRecipient(sessionId: SessionId | undefined, recipient: ImDirectRecipient | undefined): Promise<void>;
+    private composeRealBinding;
+    private requireManualAccount;
+    private outboundOwner;
+    private assertManualRequestOwner;
+    private manualMessageResult;
+    private dispatchManualMessage;
+    private finishManualMessage;
+    /**
+     * Persist a DSH operator send as live inbound so Agent admission does not wait for a provider echo.
+     * @param scope - conversation that owns the outbound.
+     * @param outbound - settled human-manual intent.
+     */
+    private admitManualOutbound;
+    private settleManualResult;
+    private prepareVerifiedAccount;
+    private persistPreparedAccount;
+    /** 把首次开通生成的账号固定给后续确认。重复调用必须是同一个 id。 */
+    reservePlacementAccount(accountId: ImAccountId): void;
+    private accountIdForSetup;
+    private expireAccountSetup;
+    private releaseAccountSetup;
+    private clearAccountSetups;
+    private assertFormalAccess;
+    private accountTable;
+    private simulationTargetTable;
+    private simulationInstanceTable;
+    private requireSimulationController;
+    private simulationScope;
+    private deliveryStore;
+    private deliveryRecordsStore;
+    /**
+     * Insert one execution when its task id is absent.
+     * @param task - durable Agent task generation.
+     * @returns the stored record, which may already exist.
+     */
+    persistExecution(task: ImExecutionAggregate): Promise<ImExecutionAggregate>;
+    /**
+     * Overwrite one execution record.
+     * @param task - complete stored generation.
+     */
+    putExecution(task: ImExecutionAggregate): Promise<void>;
+    /**
+     * Read one execution by task id.
+     * @param id - durable task identity.
+     * @returns the stored generation, or absence.
+     */
+    getExecution(id: ImAgentTaskId): ImExecutionAggregate | undefined;
+    /**
+     * Apply one serialized transform to a stored execution.
+     * @param id - durable task identity.
+     * @param fn - synchronous transform of the current record.
+     * @returns the stored next record.
+     */
+    updateExecution(id: ImAgentTaskId, fn: (current: ImExecutionAggregate) => ImExecutionAggregate): Promise<ImExecutionAggregate>;
+    /** @returns 当前客服托管路由登记的最新 Session；只查账号与会话索引。 */
+    hostingRecoveryTasks(): readonly ImExecutionAggregate[];
+    /**
+     * List task generations for one conversation in generation order.
+     * @param scopeId - complete conversation identity.
+     * @returns stored generations for that scope.
+     */
+    executionsForScope(scopeId: import('./delivery-types.ts').ImScopeId): readonly ImExecutionAggregate[];
+    /**
+     * Resolve the latest execution bound to one Agent Session.
+     * @param sessionId - IM Agent Session.
+     * @returns that Session's newest task, or absence.
+     */
+    executionForSession(sessionId: SessionId): ImExecutionAggregate | undefined;
+    private assertUnusedIdentity;
+    private requireAccount;
+    private accountError;
+    private updateAccountRoute;
+    private enqueueSimulation;
+    /** Persist a connection intent separately from pause and process listener state. */
+    private setConnectionIntent;
+    /** Store one provider authorization observation under the account revision CAS. */
+    private storeRefreshResult;
+    private publish;
+    private publishDelivery;
+    /** Serialize listener state changes for one configured account. */
+    private scheduleListener;
+    /** Start or stop the provider listener from durable account, route, and observation facts. */
+    private reconcileListener;
+    /** Stop one exact listener before publishing a later start for the same account. */
+    private stopListener;
+    /** Consume a listener's terminal result before scheduling replacement work. */
+    private observeListener;
+    /** Release the completed provider generation on the same queue as starts and stops. */
+    private finishListener;
+    /** Cancel stability observation for one exact listener generation. */
+    private cancelListenerStableTimer;
+    /** Reset retries only for the running generation that demonstrated stable reception. */
+    private markListenerStable;
+    /** Cancel the sole retry callback owned by an account. */
+    private cancelListenerRetry;
+    /** Retain a safe error code and spend the retry budget until reception stabilizes. */
+    private retryListener;
+    /** Stop one ready provider handle and consume its terminal signal without exposing provider errors. */
+    private closeListenerHandle;
+    /** Drain every provider listener owned by this runtime. */
+    private stopAllListeners;
+    /**
+     * 关闭新页面、Agent 输入及 turn；已准入工作可结束，不取消 turn。
+     * @returns 暂停所有权；调用者在取消、保留期到期或卸载时 resume。
+     */
+    pauseInput(): ImInputPause;
+    /** @param accountId - 交接账号；不改变持久化连接或路由代次。 @returns 仅该账号的输入暂停所有权；其他账号和个人 Workspace 继续运行。 */
+    pauseAccountInput(accountId: ImAccountId): ImInputPause;
+    /**
+     * 取消排空超时的账号任务，保留尚未准入的输入。
+     * @param accountId - 已持有独立输入暂停的账号；子 Agent 按当前进程的实际所有权归属。
+     */
+    cancelAccountActivityForPlacement(accountId: ImAccountId): void;
+    /**
+     * 停止已排空的来源账号，或仍持有目标启动暂停的账号。
+     * @param accountId - 本次显式交接的账号。
+     * @returns SDK 已登出且踢线意图已提交，监听已确认停止、未发出的自动回复已标记取消；保留在线意图，失败保留停止门，目标也不能释放启动暂停。
+     */
+    stopAccountForPlacement(accountId: ImAccountId): Promise<void>;
+    /** @param accountId - 已鉴权的真实旺旺账号。 @param workspaceId - 来源客服内置 Workspace。 @returns 独立切片，凭据引用按本账号成功续签收据核验并映射为规范键；预复制可读取，最终导出前调用方必须排空并停止监听。 */
+    exportAccountForPlacement(accountId: ImAccountId, workspaceId: WorkspaceId): ImAccountPlacementSlice;
+    /**
+     * Stop one account and release its live Sessions before an authenticated incoming transfer.
+     * @param accountId - Account selected by the incoming lease, including a previously exported local account.
+     * @param signal - Drain budget and incoming transfer lifetime.
+     * @returns Account import standby is held; failures retain the stop gate and cannot activate reception. A later call retries a rejected attempt with its retained input hold.
+     */
+    beginAccountPlacementImport(accountId: ImAccountId, signal: AbortSignal): Promise<void>;
+    private beginPlacementImport;
+    /**
+     * Activate an imported account only after the caller obtains fresh lease authorization and prepares its Agents.
+     * @param accountId - Account whose import standby was successfully established.
+     */
+    releaseAccountPlacement(accountId: ImAccountId): void;
+    /**
+     * Check whether local delivery records permit cursor-only recovery before lease acquisition.
+     * @param accountId - Account with an established import hold and stopped history listener.
+     * @param checkpoint - Parsed checkpoint; pending or unknown bodies cannot be reconstructed.
+     * @param signal - Preflight lifetime.
+     * @returns Existing nonnull local cursors match exactly; rejection leaves delivery records and the hold unchanged.
+     */
+    validateAccountCheckpointRecovery(accountId: ImAccountId, checkpoint: ImAccountCheckpointRecovery['checkpoint'], signal: AbortSignal): Promise<void>;
+    /**
+     * Adopt cursor-only cloud recovery while account import standby remains held.
+     * @param accountId - Account fenced by the completed outbound handoff and fresh incoming lease.
+     * @param request - Parsed checkpoint and caller-verified continuous source fence; no cloud Session is reconstructed.
+     * @param signal - Incoming activation lifetime.
+     * @returns Old local Sessions remain untouched; fresh task generations and their logged recovery notice are ready, reception still paused.
+     */
+    recoverAccountPlacement(accountId: ImAccountId, request: ImAccountCheckpointRecovery, signal: AbortSignal): Promise<void>;
+    private recoverCheckpointAccount;
+    /** @param slice - 已通过网络解析和目标 epoch 鉴权的账号切片。 @param workspaceId - 目标端已物化的客服内置 Workspace。 @returns 配置与投递事实已提交，接待仍停止；部分提交失败不恢复接待，调用者按原交接核验。 */
+    importAccountForPlacement(slice: ImAccountPlacementSlice, workspaceId: WorkspaceId): Promise<void>;
+    /**
+     * 使用本端 preset 和模型准入恢复本账号的当前任务；不转移来源 Agent 配置。
+     * @param accountId - 已导入或已在本端接待的当前账号。
+     * @param prepare - 在同一空闲 Agent 上按已核验的当前任务完成续写准备。
+     * @param signal - 本次激活及身份寿命。
+     * @returns 当前任务已准备，仍持有启动暂停；模型不可用或任一失败均不释放暂停。
+     */
+    prepareAccountPlacement(accountId: ImAccountId, prepare: (agent: Agent, task: ImAgentTaskView) => Promise<void>, signal: AbortSignal): Promise<void>;
+    /**
+     * 等待本账号当前监听的建立与 Provider 初始追平；不以启动调度代替就绪。
+     * @param accountId - 已释放启动暂停的导入账号。
+     * @param signal - 激活预算及身份寿命。
+     * @returns 需要接收时监听已就绪；暂停、断开或无接收路由时保持原意图，不擅自开启。
+     */
+    waitAccountPlacementReady(accountId: ImAccountId, signal: AbortSignal): Promise<void>;
+    /** Host 在控制面授权、导入与 prepareResume 完成后调用；幂等释放自己的启动暂停，不释放其他暂停。 */
+    releasePlacementStartup(): void;
+    private publishPlacementSdkRecovery;
+    /**
+     * 读取 Host 与账号的共同暂停状态。
+     * @param accountId - 当前真实或模拟账号。
+     * @returns 任一暂停或已停止时为 true。
+     */
+    inputPaused(accountId: ImAccountId, kind?: ImDeliveryScope['kind']): boolean;
+    /**
+     * 同步预约 Host 与账号的输入计数。
+     * @param accountId - 当前准入账号。
+     * @returns 两份计数的释放函数；任一暂停时不准入。
+     */
+    tryEnterInput(accountId: ImAccountId, kind?: ImDeliveryScope['kind']): (() => void) | undefined;
+    /**
+     * 为已准入输入保留首个 step 的工作计数。
+     * @param accountId - 当前准入账号。
+     * @param sessionId - 已确认归属该账号的 Session。
+     * @returns 输入提交后的两份预约释放函数。
+     */
+    reserveInput(accountId: ImAccountId, sessionId: SessionId): () => void;
+    private accountInput;
+    private accountOwnsAgent;
+    private agentAccount;
+    /** Bind page receipts and stability evidence to one exact listener generation. */
+    private transportSink;
+    private receiveRealtime;
+    /** Persist every conversation page before committing the provider-owned cursor. */
+    private receiveTransportPage;
+    private persistTransportPage;
+    private persistTransportConversation;
+    /** Publish process listener facts without scheduling another reconciliation. */
+    private publishListener;
+}
+export default ImRuntime;