@rivus/gateway 0.16.2 → 0.17.0

package/dist/chunks/rivus-daemon-cli.d.ts

@@ -0,0 +1,1115 @@
+import { AgentHarness, AgentInvocationOrigin, AgentRunId, AgentRunUpdate, AttachmentAccess, PromptCommand, RegisteredRivusSkill, RegisteredRivusTool, RivusMemoryScope, RivusResolvedToolDescriptor, RivusRuntimeToolGrantSet, RivusRuntimeToolId, RivusSkillDescriptor, RivusSkillGrantSet, RivusToolDescriptor, RivusToolGrantSet, SessionKey, UserInput } from "@rivus/runtime";
+import { Effect } from "effect";
+//#region src/core/application/recovery/contracts/recovery-control.d.ts
+type RecoveryToolOperationOutcome = {
+  readonly result: unknown;
+  readonly status: "applied";
+} | {
+  readonly status: "not-applied";
+};
+interface DeadLetterRecoveryItem {
+  readonly acceptedAt: string;
+  readonly attempts: number;
+  readonly deliveryId: string;
+  readonly endpointId: string;
+  readonly failureCode: "delivery_failed";
+  readonly failureSummary: string;
+  readonly failedAt: string;
+  readonly revision: number;
+}
+interface DeadLetterRequeueResult {
+  readonly acceptedAt: string;
+  readonly attempts: 0;
+  readonly availableAt: string;
+  readonly deliveryId: string;
+  readonly endpointId: string;
+  readonly recoveredAt: string;
+  readonly recoveredBy: string;
+  readonly revision: number;
+  readonly status: "pending";
+}
+interface RecoverySnapshot {
+  readonly deadLetters: ReadonlyArray<DeadLetterRecoveryItem>;
+  readonly toolOperations: ReadonlyArray<ToolOperationRecoveryItem>;
+}
+interface ToolOperationRecoveryItem {
+  readonly agentId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly failureCode: "tool_outcome_unknown";
+  readonly failureSummary: string;
+  readonly revision: number;
+  readonly status: "reconciliation-required";
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface ToolOperationResolutionResult {
+  readonly agentId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly reconciledAt: string;
+  readonly reconciledBy: string;
+  readonly revision: number;
+  readonly status: "aborted" | "completed";
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface RecoveryControl {
+  inspect(): Effect.Effect<RecoverySnapshot, unknown>;
+  requeueDeadLetter(input: {
+    readonly actorId: string;
+    readonly deliveryId: string;
+    readonly endpointId: string;
+    readonly expectedRevision: number;
+    readonly note: string;
+  }): Effect.Effect<DeadLetterRequeueResult, unknown>;
+  resolveToolOperation(input: {
+    readonly actorId: string;
+    readonly expectedRevision: number;
+    readonly instanceId: string;
+    readonly note: string;
+    readonly operationId: string;
+    readonly outcome: RecoveryToolOperationOutcome;
+  }): Effect.Effect<ToolOperationResolutionResult, unknown>;
+}
+//#endregion
+//#region src/core/domain/automation-occurrence/aggregate/snapshot.d.ts
+type AutomationOccurrenceStatus = "running" | "failed" | "generated" | "suppressed" | "delivered";
+interface AutomationOccurrenceSnapshot {
+  readonly automationId: string;
+  readonly body?: string;
+  readonly error?: string;
+  readonly mandateId: string;
+  readonly occurrence: string;
+  readonly presentation?: unknown;
+  readonly providerMessageId?: string;
+  readonly revision: number;
+  readonly runId?: string;
+  readonly status: AutomationOccurrenceStatus;
+  readonly suppressionReason?: string;
+  readonly tickId: string;
+}
+//#endregion
+//#region src/core/domain/automation-occurrence/aggregate/automation-occurrence.d.ts
+interface CreateAutomationOccurrenceInput {
+  readonly automationId: string;
+  readonly mandateId: string;
+  readonly occurrence: string;
+  readonly tickId: string;
+}
+interface GenerateAutomationOccurrenceInput {
+  readonly body: string;
+  readonly presentation?: unknown;
+  readonly runId: string;
+}
+interface SuppressAutomationOccurrenceInput {
+  readonly reason: string;
+  readonly runId: string;
+}
+declare class AutomationOccurrence {
+  #private;
+  private constructor();
+  static create(input: CreateAutomationOccurrenceInput): AutomationOccurrence;
+  static restore(value: unknown): AutomationOccurrence;
+  get automationId(): string;
+  get mandateId(): string;
+  get occurrence(): string;
+  get revision(): number;
+  get status(): AutomationOccurrenceStatus;
+  get tickId(): string;
+  restart(): AutomationOccurrence;
+  fail(error: string): AutomationOccurrence;
+  generate(input: GenerateAutomationOccurrenceInput): AutomationOccurrence;
+  suppress(input: SuppressAutomationOccurrenceInput): AutomationOccurrence;
+  deliver(providerMessageId: string): AutomationOccurrence;
+  validateTransitionTo(next: AutomationOccurrence): boolean;
+  toSnapshot(): AutomationOccurrenceSnapshot;
+  private requireRunning;
+  private next;
+}
+//#endregion
+//#region src/core/application/automation/presentation/automation-line-chart.d.ts
+interface AutomationLineChart {
+  readonly title: string;
+  readonly labels: ReadonlyArray<string>;
+  readonly unit: string;
+  readonly seriesLayout?: "overlay" | "separate";
+  readonly series: ReadonlyArray<{
+    readonly name: string;
+    readonly values: ReadonlyArray<number>;
+  }>;
+}
+//#endregion
+//#region src/core/application/automation/presentation/automation-presentation.d.ts
+declare const AUTOMATION_PRESENTATION_SCHEMA_VERSION: 1;
+type AutomationPresentationKind = "daily-ai" | "generic" | "industry" | "news" | "subscriptions";
+interface AutomationPresentationSource {
+  readonly label: string;
+  readonly url: string;
+}
+interface AutomationPresentationItem {
+  readonly headline: string;
+  readonly note?: string;
+  readonly sources: ReadonlyArray<AutomationPresentationSource>;
+}
+interface AutomationPresentationSection {
+  readonly id: string;
+  readonly items: ReadonlyArray<AutomationPresentationItem>;
+  readonly title: string;
+}
+interface AutomationPresentation {
+  readonly lineChart?: AutomationLineChart;
+  readonly footnote?: string;
+  readonly kind?: AutomationPresentationKind;
+  readonly meta: ReadonlyArray<string>;
+  readonly schemaVersion: typeof AUTOMATION_PRESENTATION_SCHEMA_VERSION;
+  readonly sections: ReadonlyArray<AutomationPresentationSection>;
+  readonly summary?: string;
+  readonly title: string;
+}
+//#endregion
+//#region src/core/application/automation/scheduling/automation-scheduler.d.ts
+interface ScheduledAutomationRunInput {
+  readonly occurrence: string;
+  readonly sessionKey: string;
+  readonly text: string;
+  readonly tickId: string;
+}
+interface AutomationScheduler {
+  running(): boolean;
+  runDue(at: Date): Effect.Effect<AutomationOccurrence | undefined, unknown>;
+  start(): Effect.Effect<void>;
+  stop(): Effect.Effect<void>;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-agent-definition.d.ts
+interface RivusAgentProfile {
+  readonly id: string;
+  readonly displayName: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+  };
+  readonly runtimeTools?: {
+    readonly allow: ReadonlyArray<RivusRuntimeToolId>;
+  };
+}
+interface RegisteredRivusAgentProfile extends RivusAgentProfile {
+  readonly pluginId: string;
+}
+interface RivusAgentDeployment {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly memory?: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeTools?: {
+    readonly allow: ReadonlyArray<RivusRuntimeToolId>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+}
+interface ResolvedRivusAgentDefinition {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly projectSpaceRevision?: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly profileRevision: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeToolGrantSet: RivusRuntimeToolGrantSet;
+  readonly skillGrantSet: RivusSkillGrantSet;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+  readonly toolGrantSet: RivusToolGrantSet;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-automation-template.d.ts
+interface RivusAutomationTemplate {
+  readonly id: string;
+  readonly profileId: string;
+  readonly requestedSkillIds: ReadonlyArray<string>;
+  readonly requestedToolIds: ReadonlyArray<string>;
+  readonly createInput: (tick: RivusAutomationTickContext) => RivusAutomationInput;
+  readonly createPresentation?: (output: RivusAutomationOutput) => AutomationPresentation;
+}
+interface RivusAutomationTickContext {
+  readonly occurrence: string;
+}
+interface RivusAutomationInput {
+  readonly text: string;
+}
+interface RivusAutomationOutput {
+  readonly occurrence: string;
+  readonly text: string;
+}
+interface RegisteredRivusAutomation extends RivusAutomationTemplate {
+  readonly pluginId: string;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-plugin.d.ts
+declare const RIVUS_PLUGIN_API_VERSION = "1";
+interface RivusPluginManifest {
+  readonly apiVersion: string;
+  readonly id: string;
+  readonly version: string;
+}
+interface RegisteredRivusPlugin extends RivusPluginManifest {}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-plugin-contracts.d.ts
+interface RivusPluginRegistry {
+  registerAgentProfile(profile: RivusAgentProfile): void;
+  registerTool(tool: RivusToolDescriptor): void;
+  registerSkill(skill: RivusSkillDescriptor): void;
+  registerAutomation(template: RivusAutomationTemplate): void;
+}
+interface RivusPlugin {
+  readonly manifest: RivusPluginManifest;
+  register(registry: RivusPluginRegistry): void;
+}
+interface RivusPluginCatalogSnapshot {
+  readonly plugins: ReadonlyArray<RegisteredRivusPlugin>;
+  readonly profiles: ReadonlyArray<RegisteredRivusAgentProfile>;
+  readonly tools: ReadonlyArray<RegisteredRivusTool>;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly automations: ReadonlyArray<RegisteredRivusAutomation>;
+}
+interface RivusPluginCatalog {
+  registerPlugin(plugin: RivusPlugin): void;
+  snapshot(): RivusPluginCatalogSnapshot;
+}
+//#endregion
+//#region src/core/application/agent-host/contracts/agent-instance.d.ts
+type AgentInstanceBinding = {
+  readonly kind: "endpoint";
+  readonly endpointId: string;
+} | {
+  readonly kind: "automation";
+  readonly automationId: string;
+} | {
+  readonly kind: "background-session";
+  readonly agentId: string;
+};
+interface AgentInstanceRecord {
+  readonly agentId: string;
+  readonly binding: AgentInstanceBinding;
+  readonly bindingKey: string;
+  readonly instanceId: string;
+  readonly runtimeGenerationId: string;
+}
+//#endregion
+//#region src/core/application/agent-host/contracts/agent-host-runtime.d.ts
+interface AgentRuntimeInput {
+  readonly attachmentAccess?: AttachmentAccess;
+  readonly invocation?: AgentInvocationOrigin;
+  readonly onUpdate?: (update: AgentRunUpdate) => Effect.Effect<void, unknown>;
+  readonly payload?: unknown;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+  readonly userInput?: UserInput;
+}
+interface AgentRuntimeCancellation {
+  readonly reason?: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+interface AgentRuntimeSteering {
+  readonly attachmentAccess?: AttachmentAccess;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+  readonly userInput?: UserInput;
+}
+//#endregion
+//#region src/core/application/agent-host/registry/agent-instance-registry.d.ts
+interface AgentInstanceRegistryOptions {
+  readonly initialRecords?: ReadonlyArray<AgentInstanceRecord>;
+}
+//#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/application/background-session/supervision/background-session-supervisor.d.ts
+interface BackgroundSessionSupervisorStatus {
+  readonly capacity: number;
+  readonly counters: {
+    readonly completed: number;
+    readonly deliveriesDelivered: number;
+    readonly failed: number;
+    readonly started: number;
+    readonly staleLeaseEventsDropped: number;
+    readonly stopped: number;
+  };
+  readonly inFlightSteps: number;
+  readonly oldestDueAt?: string;
+  readonly owner: string;
+  readonly phaseCounts: Readonly<Record<BackgroundSessionPhase, number>>;
+  readonly reconciliationCount: number;
+  readonly repositoryHealthy: boolean;
+  readonly running: boolean;
+}
+//#endregion
+//#region src/core/application/deployment/contracts/manifest.d.ts
+interface RivusBackgroundSessionsDeployment {
+  readonly enabled: boolean;
+  readonly leaseMs: number;
+  readonly leaseRenewalIntervalMs: number;
+  readonly maxConsecutiveFailures: number;
+  readonly maxConcurrentSessions: number;
+  readonly required: boolean;
+  readonly retryBackoffMs: number;
+  readonly sessionLifetimeMs: number;
+  readonly stepTimeoutMs: number;
+}
+type RivusAutomationDeliveryTargetType = "chat_id" | "open_id" | "user_id" | "union_id" | "email";
+interface RivusAutomationDelivery {
+  readonly endpointId: string;
+  readonly targetRef: string;
+  readonly targetType: RivusAutomationDeliveryTargetType;
+}
+interface RivusAutomationDeployment {
+  readonly agentId: string;
+  readonly delivery: RivusAutomationDelivery;
+  readonly enabled: boolean;
+  readonly id: string;
+  readonly required: boolean;
+  readonly schedule: string;
+  readonly templateId: string;
+  readonly timeZone: string;
+}
+interface RivusEndpointDeployment {
+  readonly agentId: string;
+  readonly baseUrl: string;
+  readonly cardStreamLeaseMs: number;
+  readonly credentialRef: string;
+  readonly enabled: boolean;
+  readonly experimental?: RivusEndpointExperimentalFeatures;
+  readonly groupPolicy: "mention-only" | "ignore-unmentioned" | "default-responder";
+  readonly id: string;
+  readonly progressDisplay?: "hidden" | "collapsed" | "expanded";
+  readonly required: boolean;
+  readonly sessionNamespace: string;
+  readonly streamMinIntervalMs: number;
+}
+interface RivusEndpointExperimentalFeatures {
+  readonly cotMessages: boolean;
+}
+//#endregion
+//#region src/core/application/deployment/contracts/deployment.d.ts
+interface ResolvedRivusAutomationDefinition extends RivusAutomationDeployment {
+  readonly runtimeDefinition: ResolvedRivusAgentDefinition;
+  readonly template: RegisteredRivusAutomation;
+}
+interface ResolvedRivusProjectSpace {
+  readonly id: string;
+  readonly root: string;
+  readonly workingDirectory: string;
+  readonly skillPaths: ReadonlyArray<string>;
+  readonly revision: string;
+}
+interface DeploymentLifecycleAdapterPort {
+  running(): boolean;
+  start(): Effect.Effect<void, unknown>;
+  stop(): Effect.Effect<void, unknown>;
+}
+interface RivusDeploymentEndpointPort extends DeploymentLifecycleAdapterPort {}
+interface RivusDeploymentAutomationPort extends DeploymentLifecycleAdapterPort {}
+interface RivusDeploymentBackgroundSessionPort extends DeploymentLifecycleAdapterPort {
+  status?(): BackgroundSessionSupervisorStatus;
+}
+interface CreateRivusDeploymentEndpointPortInput {
+  readonly agentId: string;
+  readonly cancel: (input: AgentRuntimeCancellation) => Effect.Effect<boolean, unknown>;
+  readonly definition: RivusEndpointDeployment;
+  readonly endpointId: string;
+  readonly handle: (input: AgentRuntimeInput) => Effect.Effect<unknown, unknown>;
+  readonly instanceId: string;
+  /** Resolved runtime grants are needed before the first attachment is prepared. */
+  readonly runtimeDefinition?: ResolvedRivusAgentDefinition;
+  readonly projectSpace?: ResolvedRivusProjectSpace;
+  readonly projectSpaceId?: string;
+  readonly steer: (input: AgentRuntimeSteering) => Effect.Effect<boolean, unknown>;
+}
+interface RivusDeploymentEndpointFactoryPort {
+  create(input: CreateRivusDeploymentEndpointPortInput): Effect.Effect<RivusDeploymentEndpointPort, unknown>;
+}
+interface CreateRivusDeploymentAutomationPortInput {
+  readonly automationId: string;
+  readonly definition: ResolvedRivusAutomationDefinition;
+  readonly deliveryEndpoint: RivusEndpointDeployment;
+  readonly instanceId: string;
+  readonly run: (input: ScheduledAutomationRunInput) => Effect.Effect<unknown, unknown>;
+}
+interface RivusDeploymentAutomationFactoryPort {
+  create(input: CreateRivusDeploymentAutomationPortInput): Effect.Effect<RivusDeploymentAutomationPort, unknown>;
+}
+interface RivusDeploymentBackgroundSessionCancellation {
+  readonly agentId: string;
+  readonly reason?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+}
+interface CreateRivusDeploymentBackgroundSessionPortInput {
+  readonly agentIds: ReadonlyArray<string>;
+  readonly cancel: (input: RivusDeploymentBackgroundSessionCancellation) => Effect.Effect<boolean, unknown>;
+  readonly config: RivusBackgroundSessionsDeployment;
+  readonly run: (input: {
+    readonly agentId: string;
+    readonly invocation: NonNullable<AgentRuntimeInput["invocation"]>;
+    readonly onUpdate?: AgentRuntimeInput["onUpdate"];
+    readonly sessionKey: string;
+    readonly text: string;
+  }) => Effect.Effect<unknown, unknown>;
+}
+interface RivusDeploymentBackgroundSessionFactoryPort {
+  create(input: CreateRivusDeploymentBackgroundSessionPortInput): Effect.Effect<RivusDeploymentBackgroundSessionPort, unknown>;
+}
+interface CreateRivusDeploymentRuntimePortInput extends AgentInstanceRecord {
+  readonly catalog: RivusPluginCatalog;
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly projectSpace?: ResolvedRivusProjectSpace;
+}
+interface RivusDeploymentRuntimeFactoryPort {
+  create(input: CreateRivusDeploymentRuntimePortInput): Effect.Effect<RivusDeploymentRuntimePort, unknown>;
+}
+interface RivusDeploymentRuntimePort {
+  readonly concurrency?: "managed";
+  readonly cancel?: (input: AgentRuntimeCancellation) => Effect.Effect<boolean, unknown>;
+  readonly dispose?: () => Effect.Effect<void, unknown>;
+  readonly run: (input: AgentRuntimeInput) => Effect.Effect<unknown, unknown>;
+  readonly steer?: (input: AgentRuntimeSteering) => Effect.Effect<boolean, unknown>;
+}
+//#endregion
+//#region src/core/domain/human-interaction/aggregate/snapshot.d.ts
+type HumanInteractionId = string;
+type HumanInteractionToolRisk = "observe" | "mutate" | "irreversible" | "host-control";
+interface HumanInteractionActor {
+  readonly openId: string;
+  readonly tenantKey: string;
+}
+interface HumanInteractionFact {
+  readonly label: string;
+  readonly value: string;
+}
+interface ToolApprovalBinding {
+  readonly agentId: string;
+  readonly callId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly risk: HumanInteractionToolRisk;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly tenantKey: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface HumanInteractionBase {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly createdAt: string;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact>;
+  readonly id: HumanInteractionId;
+  readonly instanceId: string;
+  readonly revision: number;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly summary: string;
+  readonly tenantKey: string;
+  readonly title: string;
+}
+interface PendingHumanInteractionState {
+  readonly status: "pending";
+}
+interface ApprovedHumanInteractionState {
+  readonly actor: HumanInteractionActor;
+  readonly consumedAt?: string;
+  readonly resolvedAt: string;
+  readonly status: "approved";
+}
+interface RejectedHumanInteractionState {
+  readonly actor: HumanInteractionActor;
+  readonly resolvedAt: string;
+  readonly status: "rejected";
+}
+interface SelectedHumanInteractionState {
+  readonly actor: HumanInteractionActor;
+  readonly optionId: string;
+  readonly resolvedAt: string;
+  readonly status: "selected";
+}
+interface ExpiredHumanInteractionState {
+  readonly expiredAt: string;
+  readonly status: "expired";
+}
+interface CancelledHumanInteractionState {
+  readonly cancelledAt: string;
+  readonly reason?: string;
+  readonly status: "cancelled";
+}
+type ToolApprovalInteractionState = PendingHumanInteractionState | ApprovedHumanInteractionState | RejectedHumanInteractionState | ExpiredHumanInteractionState | CancelledHumanInteractionState;
+interface ToolApprovalInteraction extends HumanInteractionBase {
+  readonly kind: "tool-approval";
+  readonly request: Omit<ToolApprovalBinding, "agentId" | "instanceId" | "runId" | "sessionKey" | "tenantKey">;
+  readonly state: ToolApprovalInteractionState;
+}
+interface UserDecisionOption {
+  readonly description: string;
+  readonly id: string;
+  readonly label: string;
+}
+type UserDecisionInteractionState = PendingHumanInteractionState | SelectedHumanInteractionState | RejectedHumanInteractionState | ExpiredHumanInteractionState | CancelledHumanInteractionState;
+interface UserDecisionInteraction extends HumanInteractionBase {
+  readonly kind: "user-decision";
+  readonly options: ReadonlyArray<UserDecisionOption>;
+  readonly recommendedOptionId?: string;
+  readonly state: UserDecisionInteractionState;
+}
+type HumanInteraction = ToolApprovalInteraction | UserDecisionInteraction;
+type HumanInteractionSnapshot = HumanInteraction;
+//#endregion
+//#region src/adapters/feishu/protocol/feishu-receive-message.d.ts
+interface FeishuReceiveMessagePayload {
+  readonly header?: {
+    readonly tenant_key?: string;
+  };
+  readonly event: {
+    readonly sender?: {
+      readonly sender_id?: {
+        readonly open_id?: string;
+      };
+      readonly sender_type?: string;
+      readonly tenant_key?: string;
+    };
+    readonly message: {
+      readonly create_time?: string;
+      readonly message_id: string;
+      readonly chat_id: string;
+      readonly chat_type?: string;
+      readonly thread_id?: string;
+      readonly parent_id?: string;
+      readonly root_id?: string;
+      readonly message_type: string;
+      readonly mentions?: ReadonlyArray<{
+        readonly id?: Readonly<Record<string, string>>;
+        readonly key?: string;
+        readonly name?: string;
+      }>;
+      readonly content: string;
+    };
+  };
+}
+//#endregion
+//#region src/adapters/feishu/conversation-session/feishu-session-key.d.ts
+interface FeishuSessionReference {
+  readonly tenantKey: string;
+  readonly chatId: string;
+  readonly threadId?: string;
+  readonly agentId: string;
+}
+//#endregion
+//#region src/adapters/feishu/intake/feishu-message-intake.d.ts
+type FeishuMessageIntakeSummary = FeishuPromptMessageIntakeSummary | FeishuNewSessionMessageIntakeSummary | FeishuCancelMessageIntakeSummary;
+interface FeishuMessageIntakeBaseSummary {
+  readonly messageId: string;
+  readonly sessionKey: SessionKey;
+  readonly sessionReference: FeishuSessionReference;
+}
+interface FeishuPromptMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "prompt";
+  readonly text: string;
+}
+interface FeishuNewSessionMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "new_session";
+  readonly previousSessionKey: SessionKey;
+}
+interface FeishuCancelMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "cancel_run";
+  readonly reason: string;
+  readonly runId?: AgentRunId;
+}
+//#endregion
+//#region src/adapters/feishu/intake/feishu-card-action-intake.d.ts
+interface FeishuCardActionTriggerPayload {
+  readonly action?: {
+    readonly tag?: string;
+    readonly value?: unknown;
+  };
+  readonly context?: {
+    readonly chat_id?: string;
+    readonly open_chat_id?: string;
+    readonly open_message_id?: string;
+  };
+  readonly event?: FeishuCardActionTriggerPayload;
+  readonly event_type?: string;
+  readonly operator?: {
+    readonly open_id?: string;
+    readonly tenant_key?: string;
+    readonly union_id?: string;
+    readonly user_id?: string;
+  };
+  readonly token?: string;
+}
+//#endregion
+//#region src/core/application/run-presentation/projection/presented-value.d.ts
+type PresentedValue = {
+  readonly kind: "boolean";
+  readonly value: boolean;
+} | {
+  readonly entries: ReadonlyArray<{
+    readonly key: string;
+    readonly value: PresentedValue;
+  }>;
+  readonly kind: "record";
+  readonly omittedEntries: number;
+} | {
+  readonly items: ReadonlyArray<PresentedValue>;
+  readonly kind: "list";
+  readonly omittedItems: number;
+} | {
+  readonly kind: "null";
+} | {
+  readonly kind: "number";
+  readonly value: number;
+} | {
+  readonly kind: "redacted";
+  readonly reason: "sensitive-key" | "sensitive-value";
+} | {
+  readonly kind: "text";
+  readonly omittedCharacters: number;
+  readonly value: string;
+} | {
+  readonly kind: "unsupported";
+  readonly valueType: string;
+};
+//#endregion
+//#region src/core/application/run-presentation/projection/run-presentation.d.ts
+declare const RUN_PRESENTATION_SCHEMA_VERSION: 2;
+type AgentRunId$1 = string;
+type RunPresentationPhase = "cancelled" | "completed" | "failed" | "running";
+type PresentationStepStatus = "completed" | "failed" | "running";
+interface PresentationStepBase {
+  readonly durationMs?: number;
+  readonly endedAt?: string;
+  readonly id: string;
+  readonly label: string;
+  readonly startedAt: string;
+  readonly status: PresentationStepStatus;
+}
+interface AssistantPresentationStep extends PresentationStepBase {
+  readonly kind: "assistant";
+  readonly text: string;
+}
+interface ModelPresentationStep extends PresentationStepBase {
+  readonly kind: "model";
+  readonly model: string;
+  readonly provider: string;
+}
+interface SkillPresentationStep extends PresentationStepBase {
+  readonly kind: "skill";
+  readonly skillId: string;
+}
+interface ToolPresentationStep extends PresentationStepBase {
+  readonly error?: PresentedValue;
+  readonly input: PresentedValue;
+  readonly kind: "tool";
+  readonly output?: PresentedValue;
+  readonly skillId?: string;
+  readonly toolName: string;
+}
+interface ResponsePresentationStep extends PresentationStepBase {
+  readonly kind: "response";
+}
+type PresentationStep = AssistantPresentationStep | ModelPresentationStep | ResponsePresentationStep | SkillPresentationStep | ToolPresentationStep;
+interface RunPresentation {
+  readonly answer: {
+    readonly format: "markdown";
+    readonly text: string;
+  };
+  readonly omittedStepCount: number;
+  readonly phase: RunPresentationPhase;
+  readonly revision: number;
+  readonly runId: AgentRunId$1;
+  readonly schemaVersion: typeof RUN_PRESENTATION_SCHEMA_VERSION;
+  readonly steps: ReadonlyArray<PresentationStep>;
+  readonly totalStepCount: number;
+  readonly totalToolCallCount: number;
+}
+//#endregion
+//#region src/adapters/feishu/card-presentation/streaming/feishu-stream-projector.d.ts
+type FeishuStreamAction = {
+  readonly type: "update_text";
+  readonly runId: AgentRunId;
+  readonly text: string;
+} | {
+  readonly presentation: RunPresentation;
+  readonly runId: AgentRunId;
+  readonly type: "update_progress";
+} | {
+  readonly presentation?: RunPresentation;
+  readonly runId: AgentRunId;
+  readonly sessionKey: string;
+  readonly text?: string;
+  readonly type: "update_presentation";
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "finish";
+  readonly runId: AgentRunId;
+  readonly text: string;
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "fail";
+  readonly runId: AgentRunId;
+  readonly errorMessage: string;
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "cancel";
+  readonly runId: AgentRunId;
+  readonly reason?: string;
+  readonly text?: string;
+};
+//#endregion
+//#region src/adapters/feishu/protocol/feishu-agent-run-preparation.d.ts
+interface FeishuAgentRunPreparation {
+  readonly messageId: string;
+  readonly prompt: string;
+  readonly receiveId: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+//#endregion
+//#region src/adapters/feishu/intake/feishu-agent-daemon.d.ts
+interface FeishuAgentDaemonRunResult {
+  readonly messageId: string;
+  readonly runId: string;
+  readonly finalText: string;
+}
+interface FeishuAgentDaemonSkippedResult {
+  readonly messageId: string;
+  readonly skipped: true;
+  readonly reason: "duplicate";
+}
+interface FeishuAgentDaemonCancelResult {
+  readonly cancelled: boolean;
+  readonly messageId: string;
+  readonly runId?: AgentRunId;
+  readonly reason?: "not_active";
+}
+interface FeishuAgentDaemonSteeredResult {
+  readonly messageId: string;
+  readonly runId: AgentRunId;
+  readonly steered: true;
+}
+interface FeishuAgentDaemonInteractionResult {
+  readonly interaction: HumanInteractionSnapshot;
+  readonly interactionId: string;
+  readonly messageId: string;
+  readonly resolved: true;
+}
+interface FeishuAgentDaemonSessionResetResult {
+  readonly messageId: string;
+  readonly previousSessionKey: SessionKey;
+  readonly sessionKey: SessionKey;
+  readonly reset: true;
+}
+type FeishuAgentDaemonHandleResult = FeishuAgentDaemonRunResult | FeishuAgentDaemonSkippedResult | FeishuAgentDaemonCancelResult | FeishuAgentDaemonSteeredResult | FeishuAgentDaemonInteractionResult | FeishuAgentDaemonSessionResetResult;
+type FeishuAgentMessageSideEffects = "enabled" | "disabled";
+interface FeishuAgentDaemonHandleMessageOptions {
+  readonly sideEffects?: FeishuAgentMessageSideEffects;
+}
+//#endregion
+//#region src/platform/durable-queue/records/inbound-delivery-record.d.ts
+interface InboundDeliveryPendingState {
+  readonly availableAt: string;
+  readonly status: "pending";
+}
+interface InboundDeliveryLeasedState {
+  readonly leaseExpiresAt: string;
+  readonly leaseId: string;
+  readonly leasedAt: string;
+  readonly status: "leased";
+}
+interface InboundDeliveryCompletedState {
+  readonly completedAt: string;
+  readonly status: "completed";
+}
+interface InboundDeliveryDeadState {
+  readonly failedAt: string;
+  readonly reason: string;
+  readonly status: "dead";
+}
+type InboundDeliveryState = InboundDeliveryPendingState | InboundDeliveryLeasedState | InboundDeliveryCompletedState | InboundDeliveryDeadState;
+interface InboundDeliveryRecoveryAudit {
+  readonly actorId: string;
+  readonly at: string;
+  readonly note: string;
+}
+type InboundDelivery<Payload = unknown, Metadata = unknown> = Readonly<{
+  readonly acceptedAt: string;
+  readonly attempts: number;
+  readonly id: string;
+  readonly laneKey: string;
+  readonly metadata?: Metadata;
+  readonly payload: Payload;
+  readonly recovery?: InboundDeliveryRecoveryAudit;
+  readonly revision: number;
+  readonly state: InboundDeliveryState;
+}>;
+//#endregion
+//#region src/platform/durable-queue/processing/durable-queue.d.ts
+interface DurableQueueAcceptInput<Payload, Metadata> {
+  readonly id: string;
+  readonly laneKey: string;
+  readonly metadata?: Metadata;
+  readonly payload: Payload;
+}
+type DurableQueueAcceptResult = {
+  readonly accepted: true;
+  readonly deliveryId: string;
+  readonly pending: number;
+} | {
+  readonly accepted: false;
+  readonly deliveryId: string;
+  readonly pending: number;
+  readonly reason: "capacity" | "duplicate";
+};
+interface DurableQueueReplayResult {
+  readonly deliveryId: string;
+  readonly reason: "duplicate";
+  readonly skipped: true;
+}
+type DurableQueueDrainResult<Result> = {
+  readonly deliveryId: string;
+  readonly handled: true;
+  readonly result: Result | DurableQueueReplayResult;
+} | {
+  readonly handled: false;
+  readonly reason: "empty";
+};
+interface DurableQueue<Payload, Metadata, Result> {
+  accept(input: DurableQueueAcceptInput<Payload, Metadata>): Effect.Effect<DurableQueueAcceptResult, unknown>;
+  deadLetters(): ReadonlyArray<InboundDelivery<Payload, Metadata>>;
+  drainOne(): Effect.Effect<DurableQueueDrainResult<Result>, unknown>;
+  pending(): number;
+}
+//#endregion
+//#region src/platform/durable-queue/processing/worker.d.ts
+interface DurableQueueWorkerDrainResult<Result> {
+  readonly drained: number;
+  readonly results: ReadonlyArray<Extract<DurableQueueDrainResult<Result>, {
+    readonly handled: true;
+  }>>;
+}
+interface DurableQueueWorker<Result> {
+  drainAvailable(): Effect.Effect<DurableQueueWorkerDrainResult<Result>, unknown>;
+}
+//#endregion
+//#region src/adapters/feishu/inbound-delivery/feishu-inbound-delivery.d.ts
+interface FeishuInboundDeliveryMetadata {
+  readonly sideEffects?: "disabled" | "enabled";
+}
+type FeishuMessageAcceptResult = {
+  readonly accepted: true;
+  readonly messageId: string;
+  readonly pending: number;
+} | {
+  readonly accepted: false;
+  readonly messageId: string;
+  readonly pending: number;
+  readonly reason: "capacity" | "duplicate" | "ignored";
+};
+interface FeishuMessageDrainAvailableResult {
+  readonly drained: number;
+  readonly results: ReadonlyArray<{
+    readonly handled: true;
+    readonly messageId: string;
+    readonly result: FeishuAgentDaemonHandleResult;
+  }>;
+}
+//#endregion
+//#region src/adapters/feishu/runtime/feishu-receive-status.d.ts
+type FeishuReceiveMessageReplayOptions = FeishuAgentDaemonHandleMessageOptions;
+interface FeishuReceiveMessageSummary {
+  readonly chatId: string;
+  readonly messageId: string;
+  readonly tenantKey?: string;
+  readonly threadId?: string;
+}
+interface FeishuReceiveAcceptedObservation {
+  readonly accepted: FeishuMessageAcceptResult;
+  readonly message: FeishuReceiveMessageSummary;
+  readonly observedAt: Date;
+}
+interface FeishuReceiveHandledObservation {
+  readonly intake: FeishuMessageIntakeSummary;
+  readonly messageId: string;
+  readonly observedAt: Date;
+  readonly result: FeishuAgentDaemonHandleResult;
+}
+interface FeishuReceiveRuntimeStatus {
+  readonly lastAccepted?: FeishuReceiveAcceptedObservation;
+  readonly lastHandled?: FeishuReceiveHandledObservation;
+}
+interface FeishuReceiveMessageReplayResult {
+  readonly accepted: FeishuMessageAcceptResult;
+  readonly drained: FeishuMessageDrainAvailableResult;
+  readonly intake: FeishuMessageIntakeSummary;
+}
+//#endregion
+//#region src/platform/daemon/process/rivus-daemon-process.d.ts
+interface RivusDaemonTransport {
+  running(): boolean;
+  start(): Promise<void> | void;
+  stop(): Promise<void> | void;
+}
+interface RivusDaemonProcess {
+  running(): boolean;
+  start(): Effect.Effect<void, unknown>;
+  stop(): Effect.Effect<void, unknown>;
+}
+//#endregion
+//#region src/platform/home/config/runtime/rivus-daemon-config.d.ts
+type RivusDaemonEnv = Readonly<Record<string, string | undefined>>;
+type RivusThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+interface RivusDaemonConfig {
+  readonly agentId: string;
+  readonly feishu: {
+    readonly appId: string;
+    readonly appSecret: string;
+    readonly baseUrl: string;
+    readonly cardStreamLeaseMs: number;
+    readonly streamMinIntervalMs: number;
+  };
+  readonly pi: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly model?: string;
+    readonly thinkingLevel?: RivusThinkingLevel;
+  };
+}
+//#endregion
+//#region src/platform/home/rivus-home.d.ts
+type RivusHomeEnvironment = Readonly<Record<string, string | undefined>>;
+interface RivusHome {
+  readonly bootstrap: string;
+  readonly directory: string;
+  readonly envFilePath: string;
+  readonly logsDirectory: string;
+  readonly manifestPath: string;
+  readonly stateDirectory: string;
+  readonly workspaceDirectory: string;
+}
+interface InitializedRivusHome {
+  readonly directory: string;
+  readonly files: ReadonlyArray<string>;
+}
+interface RivusHomeDoctorCheck {
+  readonly message: string;
+  readonly name: "node" | "home" | "workspace" | "modules" | "manifest" | "credentials";
+  readonly status: "pass" | "fail";
+}
+interface RivusHomeDoctorReport {
+  readonly checks: ReadonlyArray<RivusHomeDoctorCheck>;
+  readonly directory: string;
+  readonly ready: boolean;
+}
+interface RivusHomeApi {
+  diagnose(input: {
+    readonly directory: string;
+    readonly env: RivusHomeEnvironment;
+    readonly envFilePath?: string;
+    readonly nodeVersion: string;
+  }): Effect.Effect<RivusHomeDoctorReport, Error>;
+  load(directory: string): Effect.Effect<RivusHome, Error>;
+  setup(directory: string): Effect.Effect<InitializedRivusHome, Error>;
+}
+//#endregion
+//#region src/bootstrap/deployment/rivus-deployment-cli-process.d.ts
+interface RivusDeploymentBootstrapAdapters {
+  readonly initialInstanceRecords?: AgentInstanceRegistryOptions["initialRecords"];
+  readonly dispose?: () => Promise<void> | void;
+  readonly createAutomation?: RivusDeploymentAutomationFactoryPort["create"];
+  readonly createBackgroundSession?: RivusDeploymentBackgroundSessionFactoryPort["create"];
+  readonly createRecoveryControl?: () => Effect.Effect<RecoveryControl, unknown>;
+  readonly createRuntime: RivusDeploymentRuntimeFactoryPort["create"];
+  readonly createEndpoint: RivusDeploymentEndpointFactoryPort["create"];
+  readonly replayReceiveMessage?: (handleDefault: (input: AgentRuntimeInput) => Effect.Effect<unknown, unknown>, payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions) => Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+interface RivusDeploymentBootstrapContext {
+  readonly argv: ReadonlyArray<string>;
+  readonly env: RivusDaemonEnv;
+  /** Explicit original configuration source, required for controlled export on disable. */
+  readonly envFilePath?: string;
+  /** Environment values before the explicit env file is merged. */
+  readonly environmentOverrides?: RivusDaemonEnv;
+  readonly manifestPath: string;
+  readonly pluginPackageManifestPath?: string;
+}
+type RivusDeploymentBootstrapFactory = (context: RivusDeploymentBootstrapContext) => Promise<RivusDeploymentBootstrapAdapters> | RivusDeploymentBootstrapAdapters;
+//#endregion
+//#region src/platform/daemon/process/rivus-daemon-shutdown-controller.d.ts
+type RivusDaemonShutdownSignal = "SIGINT" | "SIGTERM";
+interface RivusDaemonSignalSource {
+  on(signal: RivusDaemonShutdownSignal, listener: () => void): void;
+}
+//#endregion
+//#region src/bootstrap/daemon/rivus-daemon-cli.d.ts
+interface RivusDaemonBootstrapContext {
+  readonly argv: ReadonlyArray<string>;
+  readonly config: RivusDaemonConfig;
+  readonly env: RivusDaemonEnv;
+}
+type RivusDaemonBootstrapFactory = (context: RivusDaemonBootstrapContext) => Promise<RivusDaemonProcess> | RivusDaemonProcess;
+interface RivusDaemonBootstrapModule {
+  readonly createRivusDaemonProcess?: RivusDaemonBootstrapFactory;
+  readonly createRivusDeploymentAdapters?: RivusDeploymentBootstrapFactory;
+  readonly default?: RivusDaemonBootstrapFactory;
+}
+interface RivusDaemonCliWriter {
+  write(text: string): unknown;
+}
+interface RivusDaemonPromptRunner {
+  readonly defaultSessionKey?: string;
+  promptText(command: PromptCommand): Effect.Effect<string, unknown>;
+}
+interface RivusDaemonFeishuReplayRunner {
+  replayReceiveMessage(payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions): Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+interface RivusDaemonCliOptions {
+  readonly argv: ReadonlyArray<string>;
+  readonly env: RivusDaemonEnv;
+  readonly exitAfterSignal?: (exitCode: number) => void;
+  readonly loadBootstrap?: (specifier: string) => Promise<RivusDaemonBootstrapModule>;
+  readonly signalSource: RivusDaemonSignalSource;
+  readonly stderr: RivusDaemonCliWriter;
+  readonly stdout: RivusDaemonCliWriter;
+  readonly pluginPackageManifestPath?: string;
+}
+//#endregion
+export { RivusDeploymentRuntimePort as A, ResolvedRivusAgentDefinition as B, FeishuReceiveMessagePayload as C, CreateRivusDeploymentRuntimePortInput as D, CreateRivusDeploymentEndpointPortInput as E, RivusPluginManifest as F, RivusAgentProfile as H, RivusAutomationInput as I, RivusAutomationOutput as L, RivusPluginCatalog as M, RivusPluginRegistry as N, RivusDeploymentBackgroundSessionPort as O, RIVUS_PLUGIN_API_VERSION as P, RivusAutomationTemplate as R, FeishuCardActionTriggerPayload as S, CreateRivusDeploymentBackgroundSessionPortInput as T, AutomationScheduler as U, RivusAgentDeployment as V, RecoveryControl as W, DurableQueue as _, RivusDeploymentBootstrapContext as a, FeishuAgentRunPreparation as b, RivusDaemonProcess as c, FeishuReceiveMessageReplayResult as d, FeishuReceiveRuntimeStatus as f, DurableQueueWorkerDrainResult as g, DurableQueueWorker as h, RivusDaemonPromptRunner as i, RivusPlugin as j, RivusDeploymentEndpointPort as k, RivusDaemonTransport as l, FeishuMessageAcceptResult as m, RivusDaemonCliOptions as n, RivusHomeApi as o, FeishuInboundDeliveryMetadata as p, RivusDaemonFeishuReplayRunner as r, RivusDaemonEnv as s, RivusDaemonBootstrapContext as t, FeishuReceiveMessageReplayOptions as u, DurableQueueDrainResult as v, CreateRivusDeploymentAutomationPortInput as w, FeishuStreamAction as x, FeishuAgentDaemonHandleResult as y, RivusAutomationTickContext as z };
+export {};