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

package/lib/tools.js

@@ -0,0 +1,2 @@
+import { n as registerImAgentTools, r as registerSimulationTools } from "./runtime-C0-S-_CC.js";
+export { registerImAgentTools, registerSimulationTools };

package/lib/types/agent-coordinator.d.ts

@@ -0,0 +1,84 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ImDeliveryScope } from './delivery-types.ts';
+import type { ImRuntime } from './runtime.ts';
+/** Runtime-owned coordinator; one serialized driver and one timer exist per complete scope. */
+export declare class ImAgentCoordinator {
+    private readonly ctx;
+    private readonly runtime;
+    private readonly tails;
+    private readonly timers;
+    private readonly handles;
+    private readonly toolDisposers;
+    private readonly closedScopes;
+    private readonly scopeClosures;
+    private readonly shutdown;
+    private readonly bundleLeases;
+    private readonly bundleLeaseDisposers;
+    private disposed;
+    private disposeCreated;
+    private disposeDisposed;
+    /** @param ctx - injected Agent, Workspace, preset, tools, Session, and persistence scope. @param runtime - IM authority. */
+    constructor(ctx: Context, runtime: ImRuntime);
+    /** Recover existing pending conversations and pending Session evidence. */
+    start(scopes: readonly ImDeliveryScope[]): void;
+    /** Queue one post-commit scope observation without inheriting an Agent initiator. */
+    notify(scope: ImDeliveryScope): void;
+    /** Close one simulation driver, cancel its Agent, and await only its derived work. */
+    stopScope(scope: ImDeliveryScope): Promise<void>;
+    /** Stop timers, drain admission drivers, and dispose every Agent this coordinator owns. */
+    dispose(): Promise<void>;
+    /** Evaluate current durable input and submit one eligible batch. */
+    private drive;
+    /** Continue one frozen admission after checking its Session log for an earlier append. */
+    private submitAdmission;
+    /** Pending pause and epoch changes revoke a batch, including during asynchronous policy or Agent setup. */
+    private admissionRevoked;
+    private discardAdmission;
+    /** Simulation admission uses its instance's frozen route, independent of live route edits. */
+    private admissionRoute;
+    /**
+     * Hold a bundled Workspace lease during Agent setup or one turn so template upgrade waits.
+     * @param workspaceId - task Workspace.
+     */
+    private acquireBundleLease;
+    /**
+     * Keep one bundle lease through this turn; turn/end releases it before the next prompt admission.
+     * @param agent - admitted Agent.
+     * @param release - disposer from {@link acquireBundleLease}.
+     */
+    private holdBundleLease;
+    /**
+     * Release one Agent's bundle lease. Idempotent.
+     * @param sessionId - Agent Session.
+     */
+    private dropBundleLease;
+    /** Resolve a route generation without storing it before a trigger admits input. */
+    private taskForCurrentBinding;
+    /** Persist a newly admitted route generation, or return its existing record. */
+    private persistTask;
+    /** Read task generations for one complete conversation identity in generation order. */
+    private tasksForScope;
+    /** Read one configured admission batch while excluding AI echoes. */
+    private pending;
+    /** Persist AI echoes without creating another Agent input. */
+    private discardNonAdmitted;
+    /** Reconcile only when the durable Session exists; persistence failures stop this driver. */
+    private reconcileTask;
+    /** Return every true member of the configured OR trigger. */
+    private triggerReasons;
+    /** Arm the persisted-message deadline; later messages never slide it. */
+    private scheduleInterval;
+    /** Store the exact batch and reasons before Agent lifecycle work starts. */
+    private freezeAdmission;
+    /** Reuse a live Agent or resume/create its frozen Session and scoped preset. */
+    private agentFor;
+    /** GUI resume uses preset-only setup; attach the frozen conversation tools then. */
+    private attachTools;
+    /** Build one identified Session message whose source reconstructs the whole batch. */
+    private admissionMessage;
+    /** Await the exact Session append and its persistence barrier before returning. */
+    private submit;
+    /** Remove only the pending batch whose identity was submitted. */
+    private clearAdmission;
+    private clearTimer;
+}

package/lib/types/agent-prompt.d.ts

@@ -0,0 +1,18 @@
+/** Model-facing IM takeover labels and the scoped system-prompt section. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ImDeliveryScope, ImInboundMessageView } from './delivery-types.ts';
+import type { ImRuntime } from './runtime.ts';
+/**
+ * Render one inbound row for Agent admission or history.
+ * @param message - stored inbound with classified sender evidence.
+ * @returns one labeled line; counterpart is platform-neutral. The role marker is `[role] body`, never `[role]: body`.
+ */
+export declare function formatInbound(message: ImInboundMessageView): string;
+/**
+ * Register the takeover standing rules on one Agent context.
+ * @param ctx - unpublished Agent context that owns the section.
+ * @param runtime - Host runtime that supplies frozen account and destination labels.
+ * @param scope - complete admitted conversation identity.
+ * @returns disposer for the section.
+ */
+export declare function registerImTakeoverPrompt(ctx: Context, runtime: ImRuntime, scope: ImDeliveryScope): () => void;

package/lib/types/delivery-schema.d.ts

@@ -0,0 +1,52 @@
+import { type ZodType } from 'zod';
+import type { ImAdmissionId, ImAgentTaskView, ImInboundOperationResult, ImDeliveryScope, ImInboundMessageInput, ImInboundMessageView, ImMessageId, ImOutboundView, ImScopeId, ImProviderCursorCommitResult, ImProviderCursorId, ImProviderCursorOwner, ImTriggerReason } from './delivery-types.ts';
+export declare const imDeliveryScopeSchema: ZodType<ImDeliveryScope>;
+/** Parser for provider and JSONL inbound records. */
+export declare const imInboundMessageInputSchema: ZodType<ImInboundMessageInput>;
+interface StoredDeliveryOperation {
+    readonly fingerprint: string;
+    readonly result: ImInboundOperationResult;
+}
+/** One durable record per complete conversation scope. */
+export interface ImDeliveryAggregate {
+    readonly scope: ImDeliveryScope;
+    readonly scopeId: ImScopeId;
+    readonly nextMessageSequenceNumber: number;
+    readonly nextOutboundSequenceNumber: number;
+    readonly cursor: import('./delivery-types.ts').ImConversationCursor;
+    readonly presentation?: import('./delivery-types.ts').ImConversationPresentation;
+    readonly messages: Readonly<Record<string, ImInboundMessageView>>;
+    readonly messageIdsByExternalId: Readonly<Record<string, ImMessageId>>;
+    readonly operations: Readonly<Record<string, StoredDeliveryOperation>>;
+    readonly outbounds: Readonly<Record<string, ImOutboundView>>;
+}
+export declare const imDeliveryAggregateSchema: ZodType<ImDeliveryAggregate>;
+/** One provider feed cursor plus queryable CAS receipts. */
+export interface ImProviderCursorAggregate {
+    readonly id: ImProviderCursorId;
+    readonly owner: ImProviderCursorOwner;
+    readonly cursor: string | null;
+    readonly updatedAt: string;
+    readonly operations: Readonly<Record<string, {
+        readonly fingerprint: string;
+        readonly result: ImProviderCursorCommitResult;
+    }>>;
+}
+/** Parser for one provider-owned feed cursor plus its CAS receipts. */
+export declare const imProviderCursorAggregateSchema: ZodType<ImProviderCursorAggregate>;
+/** Batch frozen before Agent creation or steering begins. */
+export interface ImPendingAdmission {
+    /** Customer pause generation frozen before asynchronous admission work. */
+    readonly handlingEpoch?: number;
+    readonly admissionId: ImAdmissionId;
+    readonly messageIds: readonly ImMessageId[];
+    readonly triggerReasons: readonly ImTriggerReason[];
+    readonly createdAt: string;
+}
+/** Durable execution assignment for one conversation scope. */
+export interface ImExecutionAggregate extends ImAgentTaskView {
+    readonly pendingAdmission?: ImPendingAdmission;
+}
+/** Parser for one route-bound Agent task generation. */
+export declare const imExecutionAggregateSchema: ZodType<ImExecutionAggregate>;
+export {};

package/lib/types/delivery-sqlite.d.ts

@@ -0,0 +1,187 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { type ImDeliveryAggregate, type ImExecutionAggregate, type ImProviderCursorAggregate } from './delivery-schema.ts';
+import type { ImAgentTaskId, ImCustomerListPage, ImCustomerListRequest, ImCustomerReadAckRequest, ImDeliveryScope, ImHandlingControl, ImOutboundRequestId, ImOutboundView, ImProviderCursorId, ImScopeId, ImSetHandlingControlRequest } from './delivery-types.ts';
+import type { ImAccountId } from './types.ts';
+export declare const IM_DELIVERY_UNIT = "gestaltrun_im_delivery";
+export declare const IM_DELIVERY_UNIT_VERSION = 1;
+/** Monotonic physical layout version stored in `PRAGMA user_version`. */
+export declare const IM_DELIVERY_SCHEMA_VERSION = 2;
+/**
+ * Durable delivery records with key lookups and small parsed-document caches.
+ * Physical unit tables stay compatible with the sqlite KV layout already on disk.
+ */
+export declare class ImDeliverySqlite {
+    /** Test-only: throw after this many scopes have been committed during 1→2 backfill. */
+    static injectBackfillCrashAfter: number | undefined;
+    /** Test-only: override the committed backfill batch size. */
+    static backfillBatchSize: number | undefined;
+    /** Test-only: fail the next customer-index write so putScope can prove rollback. */
+    static failNextCustomerIndexWrite: boolean;
+    private readonly db;
+    private readonly scopeSelect;
+    private readonly scopeUpsert;
+    private readonly cursorSelect;
+    private readonly cursorUpsert;
+    private readonly executionSelect;
+    private readonly executionUpsert;
+    private readonly scopeCache;
+    private readonly executionCache;
+    private closed;
+    private constructor();
+    /**
+     * Open or create the delivery database and ensure unit tables plus lookup indexes.
+     * @param path - sqlite file path, or `:memory:`.
+     * @returns the opened record store.
+     */
+    static open(path: string): Promise<ImDeliverySqlite>;
+    /**
+     * Read one conversation aggregate by scope id.
+     * @param id - complete conversation identity.
+     * @returns the stored aggregate, or absence.
+     */
+    getScope(id: ImScopeId): ImDeliveryAggregate | undefined;
+    /**
+     * Persist one conversation aggregate and refresh its lookup indexes.
+     * @param id - complete conversation identity.
+     * @param value - stored aggregate.
+     */
+    putScope(id: ImScopeId, value: ImDeliveryAggregate): Promise<void>;
+    /**
+     * Read one provider cursor by id.
+     * @param id - provider feed identity.
+     * @returns the stored cursor, or absence.
+     */
+    getCursor(id: ImProviderCursorId): ImProviderCursorAggregate | undefined;
+    /**
+     * Persist one provider cursor.
+     * @param id - provider feed identity.
+     * @param value - stored cursor.
+     */
+    putCursor(id: ImProviderCursorId, value: ImProviderCursorAggregate): Promise<void>;
+    /**
+     * Read one Agent task generation by id.
+     * @param id - durable task identity.
+     * @returns the stored generation, or absence.
+     */
+    getExecution(id: ImAgentTaskId): ImExecutionAggregate | undefined;
+    /**
+     * Persist one Agent task generation and refresh its lookup indexes.
+     * @param id - durable task identity.
+     * @param value - stored generation.
+     */
+    putExecution(id: ImAgentTaskId, value: ImExecutionAggregate): Promise<void>;
+    /**
+     * Apply one 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>;
+    /**
+     * List conversations that currently have pending live inbound.
+     * @returns scopes whose pendingCount is greater than zero.
+     */
+    pendingScopes(): ImDeliveryScope[];
+    /**
+     * List conversations with an interrupted platform send.
+     * @returns scope ids that currently have a dispatching outbound.
+     */
+    dispatchingScopeIds(): readonly ImScopeId[];
+    /**
+     * List conversations owned by one configured account.
+     * @param accountId - durable IM account.
+     * @returns stored scopes for that account.
+     */
+    scopesForAccount(accountId: ImAccountId): ImDeliveryScope[];
+    /**
+     * Resolve the newest execution bound to one Agent Session.
+     * @param sessionId - IM Agent Session.
+     * @returns that Session's newest task, or absence.
+     */
+    executionForSession(sessionId: SessionId): ImExecutionAggregate | undefined;
+    /**
+     * Resolve the newest execution for one conversation.
+     * @param scopeId - complete conversation identity.
+     * @returns the highest-generation task, or absence.
+     */
+    latestExecutionForScope(scopeId: ImScopeId): ImExecutionAggregate | undefined;
+    /**
+     * List task generations for one conversation in generation order.
+     * @param scopeId - complete conversation identity.
+     * @returns stored generations for that scope.
+     */
+    executionsForScope(scopeId: ImScopeId): ImExecutionAggregate[];
+    /**
+     * Record a provider actor id that belongs to one configured account.
+     * @param accountId - durable IM account.
+     * @param actorId - provider actor observed on a native-client or echo frame.
+     */
+    rememberNativeActor(accountId: ImAccountId, actorId: string): void;
+    /**
+     * Report whether one provider actor belongs to a configured account.
+     * @param accountId - durable IM account.
+     * @param actorId - provider actor id.
+     * @returns true when that actor was stored for the account.
+     */
+    isNativeActor(accountId: ImAccountId, actorId: string): boolean;
+    /**
+     * Locate the conversation that owns one outbound request.
+     * @param requestId - outbound identity.
+     * @returns that request's scope and stored outbound, or absence.
+     */
+    outboundOwner(requestId: ImOutboundRequestId): {
+        readonly scope: ImDeliveryScope;
+        readonly outbound: ImOutboundView;
+    } | undefined;
+    /**
+     * Report whether the delivery unit currently has no records.
+     * @returns true when scopes, cursors, and executions are empty.
+     */
+    empty(): boolean;
+    /**
+     * Delete every delivery record and lookup index.
+     */
+    deleteAll(): Promise<void>;
+    /** Release the sqlite connection. Idempotent. */
+    close(): void;
+    private backfillIndexes;
+    private backfillNativeActors;
+    private markLookupReady;
+    private markNativeReady;
+    private insertScopeIndexes;
+    private clearScopeIndexes;
+    private insertNativeActors;
+    private insertExecutionIndexes;
+    private clearExecutionIndexes;
+    private rememberScope;
+    private rememberExecution;
+    /**
+     * List customer rows for one account and source, grouped by customer key.
+     * @param request - account, real/simulation filter, optional substring, and reader.
+     */
+    listCustomers(request: ImCustomerListRequest): ImCustomerListPage;
+    /**
+     * Advance one reader's 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;
+    private requireHandlingControl;
+    private customerMatches;
+    private likeMatch;
+    private customerRow;
+    private latestExecutionRow;
+    private updateSummaryExecution;
+    private changeWatermark;
+    private assertIndexReady;
+    private assertOpen;
+}