@rivus/gateway 0.16.6 → 0.17.0

package/dist/bootstrap/pi-feishu.d.ts

@@ -1,20 +1,285 @@
-import { Kt as ScheduledAutomation, Rs as ProcessDeploymentEndpoint, af as AgentRuntimeSteering, dt as CreateRivusDeploymentBackgroundSessionInput, gt as RivusDeploymentBackgroundSession, ms as RecoveryControl, mt as CreateRivusDeploymentRuntimeInput, nf as AgentRuntimeInput, pt as CreateRivusDeploymentEndpointInput, ss as RivusDeploymentBootstrapContext, tf as AgentRuntimeCancellation, ut as CreateRivusDeploymentAutomationInput, yo as SessionSchedulerStatus } from "../chunks/index.js";
-
+import { A as RivusDeploymentRuntimePort, C as FeishuReceiveMessagePayload, D as CreateRivusDeploymentRuntimePortInput, E as CreateRivusDeploymentEndpointPortInput, O as RivusDeploymentBackgroundSessionPort, S as FeishuCardActionTriggerPayload, T as CreateRivusDeploymentBackgroundSessionPortInput, U as AutomationScheduler, W as RecoveryControl, _ as DurableQueue, a as RivusDeploymentBootstrapContext, b as FeishuAgentRunPreparation, c as RivusDaemonProcess, d as FeishuReceiveMessageReplayResult, f as FeishuReceiveRuntimeStatus, g as DurableQueueWorkerDrainResult, h as DurableQueueWorker, i as RivusDaemonPromptRunner, k as RivusDeploymentEndpointPort, l as RivusDaemonTransport, m as FeishuMessageAcceptResult, p as FeishuInboundDeliveryMetadata, r as RivusDaemonFeishuReplayRunner, t as RivusDaemonBootstrapContext, u as FeishuReceiveMessageReplayOptions, v as DurableQueueDrainResult, w as CreateRivusDeploymentAutomationPortInput, x as FeishuStreamAction, y as FeishuAgentDaemonHandleResult } from "../chunks/rivus-daemon-cli.js";
+import { AgentEventLog, AgentHarness, AgentHistory, AgentRunId, AgentRunState, PromptCommand } from "@rivus/runtime";
+import { Effect } from "effect";
+import { PeriodicEffectLoop } from "@rivus/platform/concurrency";
+//#region src/adapters/feishu/protocol/feishu-card-protocol.d.ts
+/** Shared raw-card schema used by Feishu protocol adapters. */
+interface FeishuRawCardJson {
+  readonly body: {
+    readonly direction?: "horizontal" | "vertical";
+    readonly elements: ReadonlyArray<unknown>;
+    readonly padding?: string;
+    readonly vertical_spacing?: string;
+  };
+  readonly config: {
+    readonly streaming_mode?: boolean;
+    readonly update_multi: true;
+  };
+  readonly header: {
+    readonly padding?: string;
+    readonly template: "blue" | "green" | "grey" | "orange" | "red";
+    readonly title: {
+      readonly content: string;
+      readonly tag: "plain_text";
+    };
+  };
+  readonly schema: "2.0";
+}
+//#endregion
+//#region src/adapters/feishu/runtime/card-action-response.d.ts
+interface FeishuCardActionCallbackResponse {
+  readonly card?: {
+    readonly data: FeishuRawCardJson;
+    readonly type: "raw";
+  };
+  readonly toast: FeishuCardActionToast;
+}
+interface FeishuCardActionToast {
+  readonly type: "success" | "info" | "warning" | "error";
+  readonly content: string;
+  readonly i18n?: {
+    readonly en_us?: string;
+    readonly zh_cn?: string;
+  };
+}
+//#endregion
+//#region src/adapters/feishu/runtime/event-handlers.d.ts
+interface FeishuSdkReceiveMessagePayload {
+  readonly message: FeishuReceiveMessagePayload["event"]["message"];
+  readonly sender?: FeishuReceiveMessagePayload["event"]["sender"];
+  readonly tenant_key?: string;
+}
+type FeishuReceiveMessageHandlerPayload = FeishuReceiveMessagePayload | FeishuSdkReceiveMessagePayload;
+interface FeishuEventHandlers {
+  readonly "card.action.trigger"?: (payload: FeishuCardActionTriggerPayload) => Promise<FeishuCardActionCallbackResponse>;
+  readonly "im.message.receive_v1": (payload: FeishuReceiveMessageHandlerPayload) => Promise<FeishuMessageAcceptResult>;
+}
+//#endregion
+//#region src/bootstrap/feishu/agent-runtime.d.ts
+interface FeishuAgentRuntime {
+  readonly handlers: FeishuEventHandlers;
+  readonly harness: AgentHarness;
+  readonly queue: DurableQueue<FeishuReceiveMessagePayload, FeishuInboundDeliveryMetadata, FeishuAgentDaemonHandleResult>;
+  readonly worker: DurableQueueWorker<FeishuAgentDaemonHandleResult>;
+  drainAvailable(): Effect.Effect<DurableQueueWorkerDrainResult<FeishuAgentDaemonHandleResult>, unknown>;
+  drainOne(): Effect.Effect<DurableQueueDrainResult<FeishuAgentDaemonHandleResult>, unknown>;
+  pending(): number;
+  receiveStatus(): FeishuReceiveRuntimeStatus;
+  replayReceiveMessage(payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions): Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+//#endregion
+//#region src/platform/daemon/status/daemon-status-reporter.d.ts
+interface DaemonStatusSnapshot<History, RunState, CardStatus, ReceiveStatus> {
+  readonly agentId: string;
+  readonly cards?: CardStatus;
+  readonly harness: {
+    readonly activeRunId?: string;
+    readonly activeRunState?: RunState;
+    readonly activeSessionKey?: string;
+    readonly busy: boolean;
+  };
+  readonly history: History;
+  readonly process: {
+    readonly running: boolean;
+  };
+  readonly queue: {
+    readonly pending: number;
+  };
+  readonly receive?: ReceiveStatus;
+  readonly transport: {
+    readonly running: boolean;
+  };
+  readonly workerLoop: {
+    readonly running: boolean;
+  };
+}
+interface DaemonStatusReporter<History, RunState, CardStatus, ReceiveStatus> {
+  status(): Effect.Effect<DaemonStatusSnapshot<History, RunState, CardStatus, ReceiveStatus>, unknown>;
+}
+//#endregion
+//#region src/adapters/feishu/runtime/websocket-daemon.d.ts
+interface FeishuWebSocketDaemon {
+  running(): boolean;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+//#endregion
+//#region src/core/application/card-presentation/projection/card-presentation.d.ts
+type CardPresentationStatus = "streaming" | "handoff-pending" | "active" | "closed" | "terminal";
+interface CardPresentation {
+  readonly runId: string;
+  readonly presentationId: string;
+  readonly generation: number;
+  readonly cardId: string;
+  readonly elementId?: string;
+  readonly sourceMessageId: string;
+  readonly status: CardPresentationStatus;
+  readonly createdAt: string;
+  readonly leaseDeadlineAt: string;
+  readonly handoffAt?: string;
+  readonly handoffFailedAt?: string;
+  readonly predecessorPresentationId?: string;
+  readonly successorPresentationId?: string;
+  readonly terminalReceiptId?: string;
+}
+interface CardPresentationChain {
+  readonly runId: string;
+  readonly activeGeneration: number;
+  readonly activePresentationId: string;
+  readonly presentations: ReadonlyArray<CardPresentation>;
+  readonly revision: number;
+}
+interface CardPresentationBinding {
+  readonly cardId: string;
+  readonly createdAt: string;
+  readonly elementId?: string;
+  readonly leaseDeadlineAt: string;
+  readonly presentationId: string;
+  readonly runId: string;
+  readonly sourceMessageId: string;
+}
+interface CardPresentationSuccessor {
+  readonly cardId: string;
+  readonly createdAt: string;
+  readonly elementId?: string;
+  readonly leaseDeadlineAt: string;
+  readonly presentationId: string;
+}
+//#endregion
+//#region src/core/application/card-presentation/projection/card-presentation-service.d.ts
+interface CardPresentationHandoffStart {
+  readonly presentation: CardPresentation;
+  readonly started: boolean;
+}
+interface BeginCardPresentationHandoffInput {
+  readonly handoffAt: string;
+  readonly runId: string;
+}
+interface CompleteCardPresentationHandoffInput {
+  readonly runId: string;
+  readonly successor: CardPresentationSuccessor;
+}
+interface FailCardPresentationHandoffInput {
+  readonly failedAt: string;
+  readonly runId: string;
+}
+interface MarkCardPresentationTerminalInput {
+  readonly runId: string;
+  readonly terminalReceiptId: string;
+}
+interface CardPresentationService {
+  chain(runId: string): CardPresentationChain | undefined;
+  chains(): ReadonlyArray<CardPresentationChain>;
+  size(): number;
+  bind(binding: CardPresentationBinding): Effect.Effect<CardPresentation, unknown>;
+  beginHandoff(input: BeginCardPresentationHandoffInput): Effect.Effect<CardPresentationHandoffStart, unknown>;
+  compensateInterruptedHandoffs(compensatedAt: string): Effect.Effect<ReadonlyArray<CardPresentationChain>, unknown>;
+  completeHandoff(input: CompleteCardPresentationHandoffInput): Effect.Effect<CardPresentation, unknown>;
+  failHandoff(input: FailCardPresentationHandoffInput): Effect.Effect<void, unknown>;
+  markTerminal(input: MarkCardPresentationTerminalInput): Effect.Effect<void, unknown>;
+  release(runId: string): Effect.Effect<void, unknown>;
+}
+//#endregion
+//#region src/adapters/feishu/card-presentation/delivery/feishu-cardkit-publisher.d.ts
+interface FeishuCardTarget {
+  readonly cardId: string;
+  readonly elementId: string;
+  readonly progressElementId?: string;
+}
+//#endregion
+//#region src/adapters/feishu/card-presentation/target/feishu-card-target-registry.d.ts
+interface FeishuCardTargetRegistry extends CardPresentationService {
+  resolveTarget(runId: AgentRunId): Effect.Effect<FeishuCardTarget, unknown>;
+}
+//#endregion
+//#region src/adapters/feishu/card-presentation/rollover/feishu-card-rollover.d.ts
+interface FeishuCardRolloverTarget {
+  readonly cardId: string;
+  readonly elementId?: string;
+}
+interface FeishuCardRolloverStreamPublisher {
+  flush(runId?: string): Effect.Effect<void, unknown>;
+  publish(action: FeishuStreamAction): Effect.Effect<void, unknown>;
+}
+type FeishuCardRolloverEventType = "handoff_started" | "handoff_succeeded" | "handoff_failed" | "handoff_notice_failed" | "presentation_write_failed" | "stale_update_dropped" | "stream_closed" | "terminal_delivery_failed";
+type FeishuCardRolloverCounters = Readonly<Record<FeishuCardRolloverEventType, number>>;
+interface FeishuCardRolloverStatus {
+  readonly counters: FeishuCardRolloverCounters;
+  readonly leaseMs: number;
+  readonly live: ReadonlyArray<CardPresentation>;
+}
+type FeishuCardRolloverHandoffResult = {
+  readonly presentation: CardPresentation;
+  readonly status: "rolled-over";
+} | {
+  readonly reason: "already-pending" | "not-due" | "not-live" | "not-streaming";
+  readonly status: "skipped";
+} | {
+  readonly error: unknown;
+  readonly status: "failed";
+};
+interface FeishuCardRollover extends FeishuCardRolloverStreamPublisher {
+  bindRun(run: FeishuAgentRunPreparation, target: FeishuCardRolloverTarget): Effect.Effect<CardPresentation, unknown>;
+  dueRunIds(now: Date): ReadonlyArray<string>;
+  handoff(runId: string): Effect.Effect<FeishuCardRolloverHandoffResult, unknown>;
+  observeStreamClosed(cardId: string): void;
+  recover(): Effect.Effect<{
+    readonly compensated: number;
+  }, unknown>;
+  releaseRun(runId: string): Effect.Effect<void>;
+  status(): FeishuCardRolloverStatus;
+}
+//#endregion
+//#region src/adapters/feishu/card-presentation/rollover/feishu-card-rollover-supervisor.d.ts
+interface FeishuCardRolloverSupervisorTickResult {
+  readonly results: ReadonlyArray<FeishuCardRolloverHandoffResult>;
+}
+interface FeishuCardRolloverSupervisor {
+  recover(): Effect.Effect<void, unknown>;
+  running(): boolean;
+  start(): void;
+  stop(): Promise<void>;
+  tick(): Effect.Effect<FeishuCardRolloverSupervisorTickResult, unknown>;
+}
+//#endregion
+//#region src/bootstrap/feishu/card-rollover-runtime.d.ts
+interface ConfiguredFeishuCardRolloverRuntime {
+  readonly rollover: FeishuCardRollover;
+  readonly supervisor: FeishuCardRolloverSupervisor;
+  readonly transport: RivusDaemonTransport;
+  prepareRun(run: FeishuAgentRunPreparation): Effect.Effect<void, unknown>;
+}
+//#endregion
+//#region src/bootstrap/feishu/rivus-daemon-bootstrap.d.ts
+type ConfiguredRivusDaemonStatus = DaemonStatusSnapshot<AgentHistory, AgentRunState, FeishuCardRolloverStatus, FeishuReceiveRuntimeStatus>;
+type ConfiguredRivusDaemonStatusReporter = DaemonStatusReporter<AgentHistory, AgentRunState, FeishuCardRolloverStatus, FeishuReceiveRuntimeStatus>;
+interface ConfiguredRivusDaemonBootstrap {
+  readonly cardRollover: ConfiguredFeishuCardRolloverRuntime;
+  readonly cardTargets: FeishuCardTargetRegistry;
+  readonly eventLog: AgentEventLog;
+  readonly process: RivusDaemonProcess;
+  readonly publisher: FeishuCardRollover;
+  readonly runtime: FeishuAgentRuntime;
+  readonly statusReporter: ConfiguredRivusDaemonStatusReporter;
+  readonly transport: RivusDaemonTransport;
+  readonly websocketTransport: FeishuWebSocketDaemon;
+  readonly workerLoop: PeriodicEffectLoop;
+  promptText(command: PromptCommand): Effect.Effect<string, unknown>;
+  restoreHistory(): Effect.Effect<AgentHistory, unknown>;
+  status(): Effect.Effect<ConfiguredRivusDaemonStatus, unknown>;
+}
+//#endregion
+//#region src/bootstrap/feishu/pi-feishu-daemon-bootstrap.d.ts
+export declare function createRivusDaemonProcess(context: RivusDaemonBootstrapContext): Promise<RivusDaemonProcess & RivusDaemonPromptRunner & RivusDaemonFeishuReplayRunner & Pick<ConfiguredRivusDaemonBootstrap, "status">>;
+//#endregion
 //#region src/bootstrap/pi-feishu.d.ts
-declare function createRivusDeploymentAdapters(context: RivusDeploymentBootstrapContext): Promise<{
+export declare function createRivusDeploymentAdapters(context: RivusDeploymentBootstrapContext): Promise<{
   dispose: () => Promise<void>;
-  createRecoveryControl: () => Promise<RecoveryControl>;
-  createBackgroundSession: ((input: CreateRivusDeploymentBackgroundSessionInput) => RivusDeploymentBackgroundSession) | undefined;
-  createAutomation: (input: CreateRivusDeploymentAutomationInput) => Promise<ScheduledAutomation>;
-  createEndpoint: (input: CreateRivusDeploymentEndpointInput) => Promise<ProcessDeploymentEndpoint>;
-  createRuntime: (input: CreateRivusDeploymentRuntimeInput) => Promise<{
-    dispose: () => Promise<void>;
-    concurrency: "managed";
-    status(): SessionSchedulerStatus;
-    cancel?(input: AgentRuntimeCancellation): Promise<boolean>;
-    steer?(input: AgentRuntimeSteering): Promise<boolean>;
-    run(input: AgentRuntimeInput): Promise<unknown>;
-  }>;
+  createRecoveryControl: () => Effect.Effect<RecoveryControl, unknown, never>;
+  createBackgroundSession: ((input: CreateRivusDeploymentBackgroundSessionPortInput) => Effect.Effect<RivusDeploymentBackgroundSessionPort, unknown, never>) | undefined;
+  createAutomation: (input: CreateRivusDeploymentAutomationPortInput) => Effect.Effect<AutomationScheduler, unknown, never>;
+  createEndpoint: (input: CreateRivusDeploymentEndpointPortInput) => Effect.Effect<RivusDeploymentEndpointPort, unknown, never>;
+  createRuntime: (input: CreateRivusDeploymentRuntimePortInput) => Effect.Effect<RivusDeploymentRuntimePort, unknown>;
 }>;
 //#endregion
-export { createRivusDeploymentAdapters };
+export {};