@rivus/agent 0.14.3 → 0.15.0

package/dist/chunks/background-session-authority.js

@@ -0,0 +1,230 @@
+//#region src/core/application/background-session/authority/background-session-identity.ts
+const BACKGROUND_SESSION_SESSION_KEY_PREFIX = "background";
+function createBackgroundSessionKey(sessionId) {
+	return `${BACKGROUND_SESSION_SESSION_KEY_PREFIX}:${sessionId}`;
+}
+function createBackgroundSessionStepSourceMessageId(sessionId, stepCount) {
+	return `bg:${sessionId}:step:${stepCount}`;
+}
+//#endregion
+//#region src/core/application/background-session/authority/background-session-authority.ts
+const BACKGROUND_SESSION_TOOL_IDS = [
+	"background.start",
+	"background.wait",
+	"background.list",
+	"background.status",
+	"background.send",
+	"background.stop"
+];
+const BACKGROUND_SESSION_START_TOOL_ID = "background.start";
+const BACKGROUND_SESSION_TOOL_PLUGIN_ID = "rivus-core";
+const BACKGROUND_SESSION_TOOL_VERSION = "1.0.0";
+const BACKGROUND_SESSION_TOOL_DIGESTS = {
+	"background.list": "sha256:c935847595e406d55ca889875b38db66bb1d4d7a34d7b0fb2b85aecf9478c149",
+	"background.send": "sha256:b7ed492e45c794dc286f7f66aca8d046082d11dfdc8787eaf5604765b68a7735",
+	"background.start": "sha256:773690e47f6eef1f1b289216e94cf98e548382d6cffb7b2f034c3ed0635dfcbb",
+	"background.status": "sha256:6aaa328d6cd97d8755a63abbe97286f1061fd2f238f68b1e576ed9a1d2b7e6b1",
+	"background.stop": "sha256:aa0bfdf0c9394058bfcbd8662e7bedd59055f9ddad51c2a1bb61666bd67ebfcb",
+	"background.wait": "sha256:4a0dc80e933ad3c99b6d58421ac9ef733157e39e0ac9b6ad87ac6e65ceaedaab"
+};
+function createBackgroundSessionToolContracts() {
+	return [
+		Object.freeze({
+			description: "Start a background agent session. Use when the request must wait for external changes, observe over time, or continue working after the foreground run ends. Returns a stable session id immediately; the foreground response can finish here. The detached session continues with the granted Skills, CLI, Tools, Project Space, and Memory of this agent.",
+			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.start"],
+			id: "background.start",
+			idempotency: "supported",
+			inputSchema: Object.freeze({
+				additionalProperties: false,
+				properties: Object.freeze({
+					displayName: {
+						type: "string",
+						maxLength: 200
+					},
+					prompt: {
+						type: "string",
+						minLength: 1,
+						maxLength: 2e4
+					}
+				}),
+				required: ["prompt"],
+				type: "object"
+			}),
+			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
+			risk: "mutate",
+			version: BACKGROUND_SESSION_TOOL_VERSION
+		}),
+		Object.freeze({
+			description: "Pause the current background session durably and end the current step. Call with delayMs to resume after a delay, with until to resume at an absolute ISO time, or with neither to wait for user input. After this call no further tool calls are accepted in this step.",
+			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.wait"],
+			id: "background.wait",
+			idempotency: "supported",
+			inputSchema: Object.freeze({
+				additionalProperties: false,
+				properties: Object.freeze({
+					delayMs: {
+						type: "integer",
+						minimum: 1e3,
+						maximum: 864e5
+					},
+					reason: {
+						type: "string",
+						maxLength: 500
+					},
+					until: {
+						type: "string",
+						maxLength: 64
+					}
+				}),
+				type: "object"
+			}),
+			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
+			risk: "mutate",
+			version: BACKGROUND_SESSION_TOOL_VERSION
+		}),
+		Object.freeze({
+			description: "List background sessions owned by this conversation, newest first. Optionally filter by phase and limit the number of results.",
+			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.list"],
+			id: "background.list",
+			idempotency: "supported",
+			inputSchema: Object.freeze({
+				additionalProperties: false,
+				properties: Object.freeze({
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: 50
+					},
+					phase: {
+						enum: [
+							"queued",
+							"running",
+							"waiting",
+							"input-required",
+							"stopping",
+							"stopped",
+							"completed",
+							"failed",
+							"reconciliation-required"
+						],
+						type: "string"
+					}
+				}),
+				type: "object"
+			}),
+			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
+			risk: "observe",
+			version: BACKGROUND_SESSION_TOOL_VERSION
+		}),
+		Object.freeze({
+			description: "Return the current phase, step counts, wake time, and result of one background session owned by this conversation.",
+			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.status"],
+			id: "background.status",
+			idempotency: "supported",
+			inputSchema: Object.freeze({
+				additionalProperties: false,
+				properties: Object.freeze({ sessionId: {
+					type: "string",
+					minLength: 1,
+					maxLength: 200
+				} }),
+				required: ["sessionId"],
+				type: "object"
+			}),
+			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
+			risk: "observe",
+			version: BACKGROUND_SESSION_TOOL_VERSION
+		}),
+		Object.freeze({
+			description: "Send new user instruction text to a background session owned by this conversation and wake it. The input is delivered exactly once in the next step.",
+			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.send"],
+			id: "background.send",
+			idempotency: "supported",
+			inputSchema: Object.freeze({
+				additionalProperties: false,
+				properties: Object.freeze({
+					message: {
+						type: "string",
+						minLength: 1,
+						maxLength: 2e4
+					},
+					sessionId: {
+						type: "string",
+						minLength: 1,
+						maxLength: 200
+					}
+				}),
+				required: ["message", "sessionId"],
+				type: "object"
+			}),
+			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
+			risk: "mutate",
+			version: BACKGROUND_SESSION_TOOL_VERSION
+		}),
+		Object.freeze({
+			description: "Stop a background session owned by this conversation. Persists the cancellation, aborts the active step and its owned process, and delivers a terminal notice.",
+			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.stop"],
+			id: "background.stop",
+			idempotency: "supported",
+			inputSchema: Object.freeze({
+				additionalProperties: false,
+				properties: Object.freeze({
+					reason: {
+						type: "string",
+						maxLength: 500
+					},
+					sessionId: {
+						type: "string",
+						minLength: 1,
+						maxLength: 200
+					}
+				}),
+				required: ["sessionId"],
+				type: "object"
+			}),
+			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
+			risk: "mutate",
+			version: BACKGROUND_SESSION_TOOL_VERSION
+		})
+	];
+}
+function backgroundSessionToolIds() {
+	return [...BACKGROUND_SESSION_TOOL_IDS];
+}
+function isBackgroundSessionToolId(toolId) {
+	return BACKGROUND_SESSION_TOOL_IDS.includes(toolId);
+}
+function extendBackgroundSessionDefinition(definition, digest) {
+	const contracts = createBackgroundSessionToolContracts();
+	const existingIds = new Set(definition.tools.map(({ id }) => id));
+	const additions = contracts.filter((contract) => !existingIds.has(contract.id));
+	const toolGrantSet = Object.freeze({
+		revision: grantRevision(digest, definition.toolGrantSet.revision, additions.map(({ id }) => id)),
+		toolIds: Object.freeze([...definition.toolGrantSet.toolIds, ...additions.map(({ id }) => id)].sort())
+	});
+	return Object.freeze({
+		...definition,
+		tools: Object.freeze([...definition.tools, ...additions]),
+		toolGrantSet
+	});
+}
+function narrowBackgroundSessionDefinition(definition, digest) {
+	const childToolIds = definition.toolGrantSet.toolIds.filter((id) => id !== BACKGROUND_SESSION_START_TOOL_ID);
+	const toolGrantSet = Object.freeze({
+		revision: grantRevision(digest, definition.toolGrantSet.revision, childToolIds),
+		toolIds: Object.freeze(childToolIds)
+	});
+	return Object.freeze({
+		...definition,
+		tools: Object.freeze(definition.tools.filter(({ id }) => id !== BACKGROUND_SESSION_START_TOOL_ID)),
+		toolGrantSet
+	});
+}
+function grantRevision(digest, parentRevision, toolIds) {
+	return digest(JSON.stringify({
+		parentRevision,
+		toolIds: [...toolIds].sort()
+	}));
+}
+//#endregion
+export { backgroundSessionToolIds as a, isBackgroundSessionToolId as c, createBackgroundSessionKey as d, createBackgroundSessionStepSourceMessageId as f, BACKGROUND_SESSION_TOOL_VERSION as i, narrowBackgroundSessionDefinition as l, BACKGROUND_SESSION_TOOL_IDS as n, createBackgroundSessionToolContracts as o, BACKGROUND_SESSION_TOOL_PLUGIN_ID as r, extendBackgroundSessionDefinition as s, BACKGROUND_SESSION_START_TOOL_ID as t, BACKGROUND_SESSION_SESSION_KEY_PREFIX as u };

package/dist/chunks/background-session-control-input.js

@@ -0,0 +1,51 @@
+import { randomUUID } from "node:crypto";
+//#region src/platform/identity/random-id.ts
+function createRandomId() {
+	return randomUUID();
+}
+//#endregion
+//#region src/core/application/background-session/control/background-session-control-input.ts
+function readBackgroundSessionObject(input, allowed, error) {
+	if (input === null || typeof input !== "object" || Array.isArray(input)) throw error("background tool input must be an object");
+	const record = input;
+	const unknown = Object.keys(record).find((key) => !allowed.includes(key));
+	if (unknown) throw error(`field is not allowed: ${unknown}`);
+	return record;
+}
+function readBackgroundSessionString(value, name, error) {
+	if (typeof value !== "string" || value.trim() === "") throw error(`${name} must be a non-empty string`);
+	return value;
+}
+function readBackgroundSessionInteger(value, name, error) {
+	if (!Number.isSafeInteger(value) || value < 1) throw error(`${name} must be a positive integer`);
+	return value;
+}
+function readBackgroundSessionPhase(value, error) {
+	const phases = [
+		"queued",
+		"running",
+		"waiting",
+		"input-required",
+		"stopping",
+		"stopped",
+		"completed",
+		"failed",
+		"reconciliation-required"
+	];
+	if (typeof value !== "string" || !phases.includes(value)) throw error(`phase must be one of ${phases.join(", ")}`);
+	return value;
+}
+function readBackgroundSessionWaitInput(input, error) {
+	const { delayMs, reason, until } = readBackgroundSessionObject(input, [
+		"delayMs",
+		"reason",
+		"until"
+	], error);
+	const args = {};
+	if (delayMs !== void 0) args.delayMs = readBackgroundSessionInteger(delayMs, "delayMs", error);
+	if (reason !== void 0) args.reason = readBackgroundSessionString(reason, "reason", error);
+	if (until !== void 0) args.until = readBackgroundSessionString(until, "until", error);
+	return args;
+}
+//#endregion
+export { readBackgroundSessionWaitInput as a, readBackgroundSessionString as i, readBackgroundSessionObject as n, createRandomId as o, readBackgroundSessionPhase as r, readBackgroundSessionInteger as t };

package/dist/chunks/background-session-service.d.ts

@@ -0,0 +1,382 @@
+//#region src/core/domain/background-session/value-objects/background-session-id.d.ts
+type BackgroundSessionId = string;
+//#endregion
+//#region src/core/domain/background-session/events/background-session-events.d.ts
+type AggregateTransition<TState, TEvent> = Readonly<{
+  events: ReadonlyArray<TEvent>;
+  state: TState;
+}>;
+type BackgroundSessionCompleted = Readonly<{
+  displayName: string;
+  revision: number;
+  sessionId: BackgroundSessionId;
+  text: string;
+  type: "BackgroundSessionCompleted";
+}>;
+type BackgroundSessionFailed = Readonly<{
+  displayName: string;
+  errorMessage: string;
+  revision: number;
+  sessionId: BackgroundSessionId;
+  type: "BackgroundSessionFailed";
+}>;
+type BackgroundSessionStopped = Readonly<{
+  displayName: string;
+  reason?: string;
+  revision: number;
+  sessionId: BackgroundSessionId;
+  type: "BackgroundSessionStopped";
+}>;
+type BackgroundSessionReconciliationRequired = Readonly<{
+  displayName: string;
+  note: string;
+  revision: number;
+  sessionId: BackgroundSessionId;
+  type: "BackgroundSessionReconciliationRequired";
+}>;
+type BackgroundSessionEvent = BackgroundSessionCompleted | BackgroundSessionFailed | BackgroundSessionStopped | BackgroundSessionReconciliationRequired;
+//#endregion
+//#region src/core/domain/background-session/value-objects/memory.d.ts
+declare const BACKGROUND_SESSION_MEMORY_SCOPES: readonly ["conversation", "agent-private", "project", "shared-user-profile"];
+type BackgroundSessionMemoryScope = (typeof BACKGROUND_SESSION_MEMORY_SCOPES)[number];
+declare const BACKGROUND_SESSION_MEMORY_AUDIENCES: readonly ["group", "private"];
+type BackgroundSessionMemoryAudience = (typeof BACKGROUND_SESSION_MEMORY_AUDIENCES)[number];
+interface BackgroundSessionMemoryIdentity {
+  readonly audience: BackgroundSessionMemoryAudience;
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+//#endregion
+//#region src/core/domain/background-session/value-objects/authority.d.ts
+type BackgroundSessionAuthority = Readonly<{
+  agentId: string;
+  profileRevision: string;
+  toolGrantRevision: string;
+  policyEpoch: number;
+  memoryScopes: ReadonlyArray<BackgroundSessionMemoryScope>;
+  projectSpaceId?: string;
+  sessionKey: string;
+}>;
+//#endregion
+//#region src/core/domain/background-session/value-objects/cancellation.d.ts
+type BackgroundSessionCancellation = Readonly<{
+  reason: string;
+  requestedAt: string;
+}>;
+//#endregion
+//#region src/core/domain/background-session/value-objects/lease.d.ts
+type BackgroundSessionLease = Readonly<{
+  owner: string;
+  epoch: number;
+  expiresAt: string;
+}>;
+//#endregion
+//#region src/core/domain/background-session/value-objects/origin.d.ts
+type BackgroundSessionOrigin = Readonly<{
+  endpointId: string;
+  tenantKey: string;
+  conversationId?: string;
+  allowedActorOpenIds: ReadonlyArray<string>;
+  memory?: BackgroundSessionMemoryIdentity;
+}>;
+//#endregion
+//#region src/core/domain/background-session/value-objects/phase.d.ts
+type BackgroundSessionPhase = "queued" | "running" | "waiting" | "input-required" | "stopping" | "stopped" | "completed" | "failed" | "reconciliation-required";
+//#endregion
+//#region src/core/domain/background-session/value-objects/terminal-result.d.ts
+type BackgroundSessionTerminalResult = Readonly<{
+  text: string;
+  stepRunId: string;
+  completedAt: string;
+}>;
+//#endregion
+//#region src/core/domain/background-session/aggregate/snapshot.d.ts
+type BackgroundSessionSnapshot = Readonly<{
+  sessionId: BackgroundSessionId;
+  displayName: string;
+  phase: BackgroundSessionPhase;
+  revision: number;
+  parentRunId: string;
+  sourceMessageId: string;
+  origin: BackgroundSessionOrigin;
+  authority: BackgroundSessionAuthority;
+  prompt: string;
+  stepCount: number;
+  wakeCount: number;
+  currentStepRunId?: string;
+  lastWakeText?: string;
+  pendingInput: ReadonlyArray<string>;
+  wakeAt?: string;
+  lease?: BackgroundSessionLease;
+  cancellation?: BackgroundSessionCancellation;
+  consecutiveFailures: number;
+  result?: BackgroundSessionTerminalResult;
+  errorMessage?: string;
+  reconciliationNote?: string;
+  createdAt: string;
+  updatedAt: string;
+}>;
+//#endregion
+//#region src/core/domain/background-session/aggregate/background-session.d.ts
+type BackgroundSessionTransition = AggregateTransition<BackgroundSession, BackgroundSessionEvent>;
+interface CreateBackgroundSessionInput {
+  readonly sessionId: BackgroundSessionId;
+  readonly displayName: string;
+  readonly prompt: string;
+  readonly parentRunId: string;
+  readonly sourceMessageId: string;
+  readonly origin: BackgroundSessionOrigin;
+  readonly authority: BackgroundSessionAuthority;
+  readonly now: string;
+}
+interface ClaimBackgroundSessionInput {
+  readonly lease: BackgroundSessionLease;
+  readonly stepRunId: string;
+  readonly wakeText: string;
+  readonly now: string;
+}
+interface SuspendBackgroundSessionInput {
+  readonly wakeAt?: string;
+  readonly reason?: string;
+  readonly now: string;
+}
+declare class BackgroundSession implements BackgroundSessionSnapshot {
+  readonly sessionId: BackgroundSessionId;
+  readonly displayName: string;
+  readonly phase: BackgroundSessionPhase;
+  readonly revision: number;
+  readonly parentRunId: string;
+  readonly sourceMessageId: string;
+  readonly origin: BackgroundSessionOrigin;
+  readonly authority: BackgroundSessionAuthority;
+  readonly prompt: string;
+  readonly stepCount: number;
+  readonly wakeCount: number;
+  readonly currentStepRunId?: string;
+  readonly lastWakeText?: string;
+  readonly pendingInput: ReadonlyArray<string>;
+  readonly wakeAt?: string;
+  readonly lease?: BackgroundSessionLease;
+  readonly cancellation?: BackgroundSessionCancellation;
+  readonly consecutiveFailures: number;
+  readonly result?: BackgroundSessionTerminalResult;
+  readonly errorMessage?: string;
+  readonly reconciliationNote?: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  private constructor();
+  static create(input: CreateBackgroundSessionInput): BackgroundSession;
+  static restore(snapshot: unknown): BackgroundSession;
+  claim(input: ClaimBackgroundSessionInput): BackgroundSessionTransition;
+  renewLease(lease: BackgroundSessionLease): BackgroundSessionTransition;
+  releaseLease(): BackgroundSessionTransition;
+  suspend(input: SuspendBackgroundSessionInput): BackgroundSessionTransition;
+  completeStep(input: {
+    readonly text: string;
+    readonly stepRunId: string;
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  failStep(input: {
+    readonly errorMessage: string;
+    readonly now: string;
+    readonly retryable: boolean;
+    readonly wakeAt?: string;
+  }): BackgroundSessionTransition;
+  requestStop(input: {
+    readonly reason: string;
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  completeStop(input: {
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  parkForReconciliation(input: {
+    readonly reason: string;
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  resolveReconciliation(input: {
+    readonly outcome: "continue" | "stop";
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  appendInput(input: {
+    readonly message: string;
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  requeueInterruptedStep(input: {
+    readonly wakeText: string;
+    readonly now: string;
+  }): BackgroundSessionTransition;
+  isLeaseExpired(now: string): boolean;
+  isDue(now: string): boolean;
+  isTerminal(): boolean;
+  toSnapshot(): BackgroundSessionSnapshot;
+  validateTransitionTo(next: BackgroundSession): string | undefined;
+  private snapshotFields;
+  private next;
+  private unchanged;
+  private stopped;
+}
+//#endregion
+//#region src/core/application/background-session/ports/background-session-delivery-store.d.ts
+type BackgroundSessionDeliveryKind = "progress" | "final" | "stopped" | "failed" | "reconciliation";
+interface BackgroundSessionDeliveryRecord {
+  readonly deliveryId: string;
+  readonly sessionId: string;
+  readonly kind: BackgroundSessionDeliveryKind;
+  readonly text: string;
+  readonly state: "pending" | "delivered";
+  readonly revision: number;
+  readonly providerMessageId?: string;
+  readonly createdAt: string;
+}
+interface BackgroundSessionDeliveryStore {
+  enqueue(input: {
+    readonly deliveryId: string;
+    readonly sessionId: string;
+    readonly kind: BackgroundSessionDeliveryKind;
+    readonly text: string;
+    readonly createdAt: string;
+  }): Promise<BackgroundSessionDeliveryRecord>;
+  pending(): Promise<ReadonlyArray<BackgroundSessionDeliveryRecord>>;
+  markDelivered(deliveryId: string, providerMessageId: string): Promise<BackgroundSessionDeliveryRecord | undefined>;
+}
+declare class BackgroundSessionDeliveryConflict extends Error {
+  readonly name = "BackgroundSessionDeliveryConflict";
+  constructor(deliveryId: string, message: string);
+}
+//#endregion
+//#region src/core/application/background-session/ports/background-session-repository.d.ts
+interface BackgroundSessionLeasePrecondition {
+  readonly kind: "absent";
+}
+interface BackgroundSessionLeaseRequirement {
+  readonly kind: "held";
+  readonly owner: string;
+  readonly epoch: number;
+}
+interface BackgroundSessionLeaseStaleOrAbsent {
+  readonly kind: "absent-or-stale";
+}
+interface BackgroundSessionRepository {
+  create(session: BackgroundSession): Promise<BackgroundSession>;
+  get(sessionId: string): Promise<BackgroundSession | undefined>;
+  list(options?: {
+    readonly phase?: BackgroundSessionPhase;
+    readonly limit?: number;
+  }): Promise<ReadonlyArray<BackgroundSession>>;
+  update(input: {
+    readonly sessionId: string;
+    readonly expectedRevision: number;
+    readonly expectedLease?: BackgroundSessionLeasePrecondition | BackgroundSessionLeaseRequirement | BackgroundSessionLeaseStaleOrAbsent;
+    readonly now?: string;
+    readonly build: (session: BackgroundSession) => BackgroundSession;
+  }): Promise<BackgroundSession | undefined>;
+}
+declare class BackgroundSessionRepositoryConflict extends Error {
+  readonly name = "BackgroundSessionRepositoryConflict";
+  constructor(sessionId: string, message: string);
+}
+declare class BackgroundSessionRepositoryCorrupted extends Error {
+  readonly name = "BackgroundSessionRepositoryCorrupted";
+}
+//#endregion
+//#region src/core/application/background-session/authority/background-session-identity.d.ts
+declare const BACKGROUND_SESSION_SESSION_KEY_PREFIX = "background";
+declare function createBackgroundSessionKey(sessionId: string): string;
+declare function createBackgroundSessionStepSourceMessageId(sessionId: string, stepCount: number): string;
+//#endregion
+//#region src/core/application/background-session/commands/background-session-ids.d.ts
+declare function sessionIdFromSessionKey(sessionKey: string): string | undefined;
+declare function terminalDeliveryId(sessionId: string, kind: BackgroundSessionDeliveryKind): string;
+declare function progressDeliveryId(sessionId: string, stepCount: number): string;
+//#endregion
+//#region src/core/application/background-session/commands/background-session-service.d.ts
+interface BackgroundSessionExecutionOrigin {
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly conversationId?: string;
+  readonly endpointId: string;
+  readonly tenantKey: string;
+}
+interface BackgroundSessionExecutionContext {
+  readonly agentId: string;
+  readonly callId: string;
+  readonly instanceId: string;
+  readonly memory?: BackgroundSessionMemoryIdentity & {
+    readonly scopes: ReadonlyArray<BackgroundSessionMemoryScope>;
+  };
+  readonly operationId?: string;
+  readonly origin?: BackgroundSessionExecutionOrigin;
+  readonly policyEpoch: number;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId?: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface BackgroundSessionSummary {
+  readonly sessionId: string;
+  readonly displayName: string;
+  readonly phase: BackgroundSessionPhase;
+  readonly stepCount: number;
+  readonly wakeAt?: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+}
+interface BackgroundSessionDetailResult {
+  readonly completedAt: string;
+  readonly stepRunId: string;
+  readonly text: string;
+}
+interface BackgroundSessionDetail extends BackgroundSessionSummary {
+  readonly parentRunId: string;
+  readonly pendingInput: ReadonlyArray<string>;
+  readonly result?: BackgroundSessionDetailResult;
+  readonly errorMessage?: string;
+  readonly cancellationReason?: string;
+  readonly reconciliationNote?: string;
+}
+declare class BackgroundSessionCallerDenied extends Error {
+  readonly name = "BackgroundSessionCallerDenied";
+  constructor(message: string);
+}
+interface BackgroundSessionService {
+  list(input: {
+    readonly context: BackgroundSessionExecutionContext;
+    readonly limit?: number;
+    readonly phase?: BackgroundSessionPhase;
+  }): Promise<ReadonlyArray<BackgroundSessionSummary>>;
+  resolveReconciliation(input: {
+    readonly outcome: "continue" | "stop";
+    readonly sessionId: string;
+  }): Promise<BackgroundSessionSummary>;
+  send(input: {
+    readonly context: BackgroundSessionExecutionContext;
+    readonly message: string;
+    readonly sessionId: string;
+  }): Promise<BackgroundSessionSummary>;
+  start(input: {
+    readonly authority: BackgroundSessionAuthority;
+    readonly context: BackgroundSessionExecutionContext;
+    readonly displayName?: string;
+    readonly prompt: string;
+    readonly sessionId: string;
+  }): Promise<BackgroundSessionSummary>;
+  status(input: {
+    readonly context: BackgroundSessionExecutionContext;
+    readonly sessionId: string;
+  }): Promise<BackgroundSessionDetail>;
+  stop(input: {
+    readonly context: BackgroundSessionExecutionContext;
+    readonly reason?: string;
+    readonly sessionId: string;
+  }): Promise<BackgroundSessionSummary>;
+  wait(input: {
+    readonly context: BackgroundSessionExecutionContext;
+    readonly delayMs?: number;
+    readonly reason?: string;
+    readonly until?: string;
+  }): Promise<BackgroundSessionSummary>;
+}
+//#endregion
+export { BackgroundSessionAuthority as A, SuspendBackgroundSessionInput as C, BackgroundSessionOrigin as D, BackgroundSessionPhase as E, BackgroundSessionId as M, BackgroundSessionLease as O, CreateBackgroundSessionInput as S, BackgroundSessionTerminalResult as T, BackgroundSessionDeliveryConflict as _, progressDeliveryId as a, BackgroundSession as b, BACKGROUND_SESSION_SESSION_KEY_PREFIX as c, BackgroundSessionLeasePrecondition as d, BackgroundSessionLeaseRequirement as f, BackgroundSessionRepositoryCorrupted as g, BackgroundSessionRepositoryConflict as h, BackgroundSessionSummary as i, BackgroundSessionMemoryScope as j, BackgroundSessionCancellation as k, createBackgroundSessionKey as l, BackgroundSessionRepository as m, BackgroundSessionDetail as n, sessionIdFromSessionKey as o, BackgroundSessionLeaseStaleOrAbsent as p, BackgroundSessionService as r, terminalDeliveryId as s, BackgroundSessionCallerDenied as t, createBackgroundSessionStepSourceMessageId as u, BackgroundSessionDeliveryRecord as v, BackgroundSessionSnapshot as w, ClaimBackgroundSessionInput as x, BackgroundSessionDeliveryStore as y };