@rivus/agent 0.13.2 → 0.14.0

package/dist/bootstrap/pi-feishu.js

@@ -0,0 +1,594 @@
+import { $ as createFeishuPresentationPreparation, $n as createUuidRunIds, B as openJsonlBackgroundSessionDeliveryStore, D as openJsonAutomationTickRepository, F as createRivusMemoryToolDescriptor, Gt as createConfiguredFeishuTextReplySender, Ht as createFeishuTopicContextResolver, Kt as createConfiguredFeishuCardRolloverRuntime, L as createConfiguredFeishuBackgroundSessionDelivery, Mt as createLangfuseAgentTelemetry, N as createProjectMemoryPromptPreparer, Nt as resolveLangfuseTelemetryConfig, O as createScheduledAutomation, Ot as createPiSessionRegistry, Qn as createSystemClock, R as resolveFeishuDeliveryChatId, Rt as createJsonlAgentEventLog, Tt as AUTOMATION_SUPPRESSION_PREFIX, U as openJsonlBackgroundSessionRepository, Vn as mergePiProviderBaseUrlOverride, W as createBackgroundSessionHostTools, _r as openJsonlFeishuCardDeliveryLedger, ar as createJsonFetchRequest, at as openJsonlToolOperationLedger, c as createHumanInteractionToolApprovalGateway, cr as createSessionScheduler, dr as openJsonlFeishuInboxRepository, et as createFeishuDeploymentEndpoint, fn as createLazyFeishuWebSocketEventDispatcher, ir as createAgentHarness, it as openJsonlRecoveryControl, j as openJsonlAgentMemoryService, kt as createPiAgentLoop, l as createRoutedHumanInteractionToolApprovalService, lr as openJsonFeishuSessionStore, m as loadRivusDeploymentManifest, o as createConfiguredFeishuAutomationCardSender, ot as createToolBroker, pt as createFeishuCotPublisher, r as createJsonlHumanInteractionRepository, rn as createConfiguredFeishuOpenApiClient, s as createHumanInteractionEndpointRegistry, st as createAgentsMdInstructionsProvider, t as createConfiguredFeishuHumanInteractionPresenter, tt as createAgentHarnessPooledRuntime, u as createHumanInteractionService, wt as readAutomationPresentation, yr as createFeishuCardDeliveryReconciler, yt as createJsonFileFeishuCardTargetRegistry } from "../chunks/src.js";
+import { V as resolveFeishuEndpointCredentials, a as createWorkspaceRootHandle } from "../chunks/rivus-daemon-cli.js";
+import { n as createPiSkillRuntime } from "../chunks/pi-skill-tool.js";
+import { $ as createBackgroundSessionStepSourceMessageId, f as createBackgroundSessionService, t as createBackgroundSessionSupervisor, u as resolveBackgroundSessionSupervisorIntervalMs } from "../chunks/api2.js";
+import { i as resolvePiSessionToolNames, l as validatePiSkillCommand, n as createPiToolProxyDefinitions, p as createPiSkillReadTools, r as createPiSessionResources, t as createPiToolNameResolver } from "../chunks/pi.js";
+import { Effect } from "effect";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { homedir } from "node:os";
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { AuthStorage, ModelRegistry, SessionManager, createAgentSession } from "@earendil-works/pi-coding-agent";
+//#region examples/pi-feishu-deployment.bootstrap.ts
+const STATE_DIR = process.env.RIVUS_DEPLOYMENT_STATE_DIR?.trim() || ".rivus/deployment";
+const PI_AGENT_DIR = join(STATE_DIR, "pi-agent");
+const PI_AUTH_FILE = join(STATE_DIR, "pi-auth.json");
+const PI_MODELS_FILE = join(STATE_DIR, "pi-models.json");
+const THINKING_LEVELS = /* @__PURE__ */ new Set([
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+async function createRivusDeploymentAdapters(context) {
+	await mkdir(PI_AGENT_DIR, { recursive: true });
+	const piOptions = await createPiSessionOptions(context);
+	const telemetryConfig = resolveLangfuseTelemetryConfig(context.env);
+	const telemetry = telemetryConfig ? createLangfuseAgentTelemetry(telemetryConfig) : void 0;
+	const memory = await openJsonlAgentMemoryService({ filePath: join(STATE_DIR, "memory", "agent-memory.jsonl") });
+	const memoryTenantId = context.env.RIVUS_MEMORY_TENANT_ID?.trim() || "local";
+	const request = createJsonFetchRequest();
+	const createOpenApiClient = (config) => createConfiguredFeishuOpenApiClient({
+		config,
+		request: (input) => request(input).pipe(Effect.map((response) => response))
+	});
+	const interactionRegistry = createHumanInteractionEndpointRegistry();
+	const manifest = await loadRivusDeploymentManifest(context.manifestPath);
+	const backgroundSessionsConfig = manifest.backgroundSessions;
+	const sessionRepository = backgroundSessionsConfig?.enabled ? await openJsonlBackgroundSessionRepository({ filePath: join(STATE_DIR, "background-sessions", "sessions.jsonl") }) : void 0;
+	const sessionDeliveries = backgroundSessionsConfig?.enabled ? await openJsonlBackgroundSessionDeliveryStore({ filePath: join(STATE_DIR, "background-sessions", "deliveries.jsonl") }) : void 0;
+	const deliveryClients = /* @__PURE__ */ new Map();
+	const backgroundService = backgroundSessionsConfig?.enabled ? createBackgroundSessionService({
+		clock: { now: () => (/* @__PURE__ */ new Date()).toISOString() },
+		deliveries: sessionDeliveries,
+		repository: sessionRepository
+	}) : void 0;
+	const createBackgroundSessionAdapter = (input) => {
+		const resolveDeliverySender = async (endpointId) => {
+			const existing = deliveryClients.get(endpointId);
+			if (existing) return existing;
+			const endpoint = manifest.endpoints.find(({ id }) => id === endpointId);
+			if (!endpoint) throw new Error(`background session delivery endpoint not found: ${endpointId}`);
+			const credentials = resolveFeishuEndpointCredentials(endpoint.credentialRef, context.env);
+			const config = {
+				agentId: endpoint.agentId,
+				feishu: {
+					...credentials,
+					baseUrl: endpoint.baseUrl,
+					cardStreamLeaseMs: endpoint.cardStreamLeaseMs,
+					streamMinIntervalMs: endpoint.streamMinIntervalMs
+				},
+				pi: {}
+			};
+			const sender = createConfiguredFeishuBackgroundSessionDelivery({
+				client: createOpenApiClient(config),
+				config
+			});
+			deliveryClients.set(endpointId, sender);
+			return sender;
+		};
+		const supervisor = createBackgroundSessionSupervisor({
+			clock: { now: () => (/* @__PURE__ */ new Date()).toISOString() },
+			config: {
+				intervalMs: resolveBackgroundSessionSupervisorIntervalMs(input.config.leaseMs),
+				leaseMs: input.config.leaseMs,
+				leaseRenewalIntervalMs: input.config.leaseRenewalIntervalMs,
+				maxConcurrentSessions: input.config.maxConcurrentSessions,
+				maxConsecutiveFailures: input.config.maxConsecutiveFailures,
+				retryBackoffMs: input.config.retryBackoffMs,
+				sessionLifetimeMs: input.config.sessionLifetimeMs
+			},
+			deliveries: sessionDeliveries,
+			deliver: async (delivery) => {
+				const session = await sessionRepository.get(delivery.sessionId);
+				if (!session) throw new Error(`background session not found for delivery: ${delivery.sessionId}`);
+				if (!session.origin.conversationId) throw new Error(`background session has no delivery conversation: ${delivery.sessionId}`);
+				return (await resolveDeliverySender(session.origin.endpointId)).deliver({
+					chatId: resolveFeishuDeliveryChatId(session.origin.conversationId),
+					deliveryId: delivery.deliveryId,
+					displayName: session.displayName,
+					kind: delivery.kind,
+					sessionId: session.sessionId,
+					text: delivery.text
+				});
+			},
+			onError: (error) => {
+				console.error("Background session supervisor failed", error);
+			},
+			repository: sessionRepository,
+			runStep: async ({ session, signal, wakeText }) => {
+				let runId;
+				const invocation = {
+					allowedActorOpenIds: session.origin.allowedActorOpenIds,
+					...session.origin.conversationId ? { conversationId: session.origin.conversationId } : {},
+					endpointId: session.origin.endpointId,
+					kind: "background-session",
+					...session.origin.memory ? { memory: session.origin.memory } : {},
+					sessionId: session.sessionId,
+					sourceMessageId: createBackgroundSessionStepSourceMessageId(session.sessionId, session.stepCount + 1),
+					tenantKey: session.origin.tenantKey
+				};
+				const abortPromise = new Promise((_resolve, reject) => {
+					signal.addEventListener("abort", () => {
+						if (runId) input.cancel({
+							agentId: session.authority.agentId,
+							reason: "background session step aborted",
+							runId,
+							sessionKey: session.authority.sessionKey
+						});
+						reject(/* @__PURE__ */ new Error("background session step aborted"));
+					}, { once: true });
+				});
+				const runPromise = input.run({
+					agentId: session.authority.agentId,
+					invocation,
+					onUpdate: (update) => {
+						if (update.event.type === "agent_run_accepted" && !runId) runId = update.event.runId;
+					},
+					sessionKey: session.authority.sessionKey,
+					text: wakeText
+				}).then((result) => readStepRunResult(result));
+				return Promise.race([runPromise, abortPromise]);
+			},
+			sleep
+		});
+		let running = false;
+		return {
+			running: () => running,
+			status: () => supervisor.status(),
+			start: async () => {
+				await Effect.runPromise(supervisor.recover());
+				await Effect.runPromise(supervisor.start());
+				running = true;
+			},
+			stop: async () => {
+				await Effect.runPromise(supervisor.stop());
+				running = false;
+			}
+		};
+	};
+	return {
+		dispose: () => telemetry?.shutdown(),
+		createRecoveryControl: () => openJsonlRecoveryControl({
+			endpointsDirectory: join(STATE_DIR, "endpoints"),
+			instancesDirectory: join(STATE_DIR, "instances")
+		}),
+		createBackgroundSession: backgroundSessionsConfig?.enabled ? (input) => createBackgroundSessionAdapter(input) : void 0,
+		createAutomation: async (input) => {
+			const credentials = resolveFeishuEndpointCredentials(input.deliveryEndpoint.credentialRef, context.env);
+			const config = {
+				agentId: input.definition.agentId,
+				feishu: {
+					...credentials,
+					baseUrl: input.deliveryEndpoint.baseUrl,
+					cardStreamLeaseMs: input.deliveryEndpoint.cardStreamLeaseMs,
+					streamMinIntervalMs: input.deliveryEndpoint.streamMinIntervalMs
+				},
+				pi: {}
+			};
+			const sender = createConfiguredFeishuAutomationCardSender({
+				client: createOpenApiClient(config),
+				config
+			});
+			const repository = await openJsonAutomationTickRepository({ filePath: join(STATE_DIR, "automations", createHash("sha256").update(input.automationId).digest("hex").slice(0, 16), "ticks.json") });
+			const target = resolveAutomationTarget(input.definition.delivery.targetRef, context.env);
+			return createScheduledAutomation({
+				automationId: input.automationId,
+				binding: {
+					agentId: input.definition.agentId,
+					bindingId: input.automationId,
+					delivery: {
+						endpointId: input.definition.delivery.endpointId,
+						targetKey: createHash("sha256").update(target).digest("hex"),
+						targetType: input.definition.delivery.targetType
+					},
+					schedule: input.definition.schedule,
+					servicePrincipalId: `automation:${input.automationId}`,
+					skillGrantRevision: input.definition.runtimeDefinition.skillGrantSet.revision,
+					skillIds: input.definition.template.requestedSkillIds,
+					templateId: input.definition.templateId,
+					timeZone: input.definition.timeZone,
+					toolIds: input.definition.template.requestedToolIds
+				},
+				createInput: input.definition.template.createInput,
+				deliver: ({ body, idempotencyKey, presentation }) => Effect.runPromise(sender.send({
+					idempotencyKey,
+					receiveId: target,
+					receiveIdType: input.definition.delivery.targetType,
+					markdown: body,
+					...presentation === void 0 ? {} : { presentation }
+				})),
+				onError: () => {
+					console.error(`Scheduled Automation ${input.automationId} failed; it will retry`);
+				},
+				repository,
+				run: async (runInput) => {
+					const result = readAutomationRunResult(await input.run(runInput));
+					const projected = result.body === void 0 ? void 0 : input.definition.template.createPresentation?.({
+						occurrence: runInput.occurrence,
+						text: result.body
+					});
+					const presentation = projected ? readAutomationPresentation(projected) : void 0;
+					return {
+						...result,
+						...presentation === void 0 ? {} : { presentation }
+					};
+				}
+			});
+		},
+		createEndpoint: async (input) => {
+			const credentials = resolveFeishuEndpointCredentials(input.definition.credentialRef, context.env);
+			const botOpenId = await resolveFeishuBotOpenId(credentials, input.definition.baseUrl);
+			const endpointState = join(STATE_DIR, "endpoints", input.endpointId);
+			const cardTargets = createJsonFileFeishuCardTargetRegistry({ filePath: join(endpointState, "feishu-card-targets.json") });
+			const cardLedger = await openJsonlFeishuCardDeliveryLedger({ filePath: join(endpointState, "feishu-card-delivery.jsonl") });
+			const inbox = await openJsonlFeishuInboxRepository({ filePath: join(endpointState, "feishu-inbox.jsonl") });
+			const sessionStore = await openJsonFeishuSessionStore({ filePath: join(endpointState, "feishu-session-store.json") });
+			const config = {
+				agentId: input.agentId,
+				feishu: {
+					...credentials,
+					baseUrl: input.definition.baseUrl,
+					cardStreamLeaseMs: input.definition.cardStreamLeaseMs,
+					streamMinIntervalMs: input.definition.streamMinIntervalMs
+				},
+				pi: {}
+			};
+			const openApiClient = createOpenApiClient(config);
+			const promptContext = createFeishuTopicContextResolver({
+				baseUrl: input.definition.baseUrl,
+				client: openApiClient
+			});
+			const cotPublisher = input.definition.experimental?.cotMessages ? createFeishuCotPublisher({
+				baseUrl: resolveExperimentalCotBaseUrl(context.env),
+				client: openApiClient,
+				minIntervalMs: input.definition.streamMinIntervalMs
+			}) : void 0;
+			const interactions = createHumanInteractionService({
+				clock: { now: () => (/* @__PURE__ */ new Date()).toISOString() },
+				presenter: createConfiguredFeishuHumanInteractionPresenter({
+					client: openApiClient,
+					config
+				}),
+				repository: createJsonlHumanInteractionRepository({ filePath: join(endpointState, "human-interactions.jsonl") })
+			});
+			const cardRollover = createConfiguredFeishuCardRolloverRuntime({
+				agentName: input.agentId,
+				cardTargets,
+				client: openApiClient,
+				clock: createSystemClock(),
+				config,
+				ledger: cardLedger,
+				onError: (error) => {
+					console.error(`Feishu card rollover failed for endpoint ${input.endpointId}`, error);
+				},
+				...input.definition.progressDisplay === void 0 ? {} : { progressDisplay: input.definition.progressDisplay },
+				sleep,
+				title: input.agentId
+			});
+			const publisher = cardRollover.rollover;
+			const endpointEvents = createJsonlAgentEventLog({ filePath: join(STATE_DIR, "instances", input.instanceId, "agent-events.jsonl") });
+			const endpointInitialEvents = await Effect.runPromise(endpointEvents.readAll());
+			await Effect.runPromise(createFeishuCardDeliveryReconciler({
+				events: endpointInitialEvents,
+				ledger: cardLedger,
+				publish: (action) => publisher.publish(action)
+			}).reconcile());
+			const replies = createConfiguredFeishuTextReplySender({
+				client: openApiClient,
+				config
+			});
+			const prepareCardTarget = (run) => cardRollover.prepareRun(run);
+			const endpoint = createFeishuDeploymentEndpoint({
+				agentId: input.agentId,
+				botOpenId,
+				cardRollover: cardRollover.transport,
+				finalizeRun: (runId) => cardRollover.rollover.releaseRun(runId),
+				cancel: input.cancel,
+				endpointId: input.endpointId,
+				eventDispatcher: createLazyFeishuWebSocketEventDispatcher(() => new Lark.EventDispatcher({})),
+				groupPolicy: input.definition.groupPolicy,
+				handle: input.handle,
+				inboxRepository: inbox,
+				initialEvents: endpointInitialEvents,
+				interactions,
+				maxPendingMessages: 100,
+				memoryTenantId,
+				...input.projectSpaceId ? { projectSpaceId: input.projectSpaceId } : {},
+				onCapacityExceeded: (payload) => replies.reply(payload.event.message.message_id, "Rivus is busy. Please retry in a moment."),
+				prepareRun: createFeishuPresentationPreparation({
+					...cotPublisher ? { cotPublisher } : {},
+					prepareCardTarget,
+					reportCotError: (operation, error) => reportCotError(input.endpointId, operation, error)
+				}),
+				promptContext,
+				publish: (action) => publisher.publish(action),
+				reply: (messageId, text) => replies.reply(messageId, text),
+				sessionStore,
+				...input.steer ? { steer: input.steer } : {},
+				...cotPublisher ? { publishRunUpdate: (update) => cotPublisher.publish(update).pipe(Effect.catchAll((error) => reportCotError(input.endpointId, "update", error))) } : {},
+				sessionNamespace: input.definition.sessionNamespace,
+				sleep,
+				websocketClient: createLazyFeishuWebSocketClient(credentials, input.definition.baseUrl),
+				workerConcurrency: 4
+			});
+			interactionRegistry.register(input.endpointId, interactions);
+			return endpoint;
+		},
+		createRuntime: async (input) => {
+			const instanceState = join(STATE_DIR, "instances", input.instanceId);
+			await mkdir(instanceState, { recursive: true });
+			const eventLog = createJsonlAgentEventLog({ filePath: join(instanceState, "agent-events.jsonl") });
+			const initialEvents = await Effect.runPromise(eventLog.readAll());
+			const broker = createToolBroker({
+				approvals: createRoutedHumanInteractionToolApprovalService(interactionRegistry),
+				catalog: input.catalog,
+				hostTools: [...input.definition.memory.tool ? [createRivusMemoryToolDescriptor({ memory })] : [], ...backgroundService ? [...createBackgroundSessionHostTools({
+					createSessionId: () => `bg-${randomUUID()}`,
+					definition: input.definition,
+					service: backgroundService
+				})] : []],
+				operations: await openJsonlToolOperationLedger({ filePath: join(instanceState, "tool-operations.jsonl") }),
+				policy: { current: async () => ({
+					epoch: 1,
+					revokedToolIds: []
+				}) }
+			});
+			const resolveToolName = createPiToolNameResolver(input.definition.tools);
+			const skillRuntime = createPiSkillRuntime(input.definition.skills);
+			const workingDirectory = input.projectSpace?.workingDirectory ?? process.cwd();
+			const workspaceRoot = input.projectSpace?.root ?? process.cwd();
+			const workspaceInstructions = await createAgentsMdInstructionsProvider().resolve({
+				maxBytes: 64 * 1024,
+				workingDirectory: relative(workspaceRoot, workingDirectory) || ".",
+				workspaceRoot: await createWorkspaceRootHandle(workspaceRoot)
+			});
+			const prepareProjectMemory = input.projectSpace && input.definition.memory.scopes.includes("project") ? createProjectMemoryPromptPreparer({
+				agentId: input.agentId,
+				memory,
+				projectId: input.projectSpace.id
+			}) : void 0;
+			const sessionRegistry = createPiSessionRegistry({ createSession: async (firstInput) => {
+				let activeInput = firstInput;
+				const resources = await createPiSessionResources({
+					agentDir: PI_AGENT_DIR,
+					appendSystemPromptOverride: () => [workspaceInstructions.content, skillRuntime.prompt].filter((content) => content.length > 0),
+					cwd: workingDirectory,
+					homeDirectory: homedir(),
+					...input.projectSpace ? { projectSkillPaths: input.projectSpace.skillPaths } : {},
+					systemPromptOverride: () => input.definition.systemPrompt
+				});
+				const customTools = [
+					...createPiSkillReadTools({
+						cwd: workingDirectory,
+						runtimeToolIds: input.definition.runtimeToolGrantSet.toolIds,
+						skillPaths: resources.skillNames.size > 0 ? resources.skillPaths : []
+					}),
+					...createPiToolProxyDefinitions({
+						agentId: input.agentId,
+						approvals: createHumanInteractionToolApprovalGateway({ registry: interactionRegistry }),
+						broker,
+						getActiveInput: () => activeInput,
+						instanceId: input.instanceId,
+						memoryScopes: input.definition.memory.scopes,
+						toolGrantSet: input.definition.toolGrantSet,
+						tools: input.definition.tools
+					}),
+					...skillRuntime.tool ? [skillRuntime.tool] : []
+				];
+				const activeToolNames = resolvePiSessionToolNames(input.definition.runtimeToolGrantSet.toolIds, customTools);
+				const result = await createAgentSession(resources.withSessionOptions({
+					...piOptions,
+					customTools,
+					excludeTools: [],
+					sessionManager: SessionManager.create(workingDirectory, join(instanceState, "sessions")),
+					tools: [...activeToolNames]
+				}));
+				return {
+					activate: (loopInput) => {
+						activeInput = loopInput;
+					},
+					dispose: () => result.session.dispose(),
+					preparePrompt: async (loopInput) => {
+						validatePiSkillCommand(loopInput.text, resources.skillNames);
+						return prepareProjectMemory ? prepareProjectMemory(loopInput) : loopInput.text;
+					},
+					resolveToolName,
+					session: result.session
+				};
+			} });
+			const loop = createPiAgentLoop({
+				disposeSessionAfterRun: false,
+				...telemetry ? { modelContentObserver: telemetry.modelContentObserver } : {},
+				resolveSession: (loopInput) => sessionRegistry.resolve(loopInput)
+			});
+			const scheduler = createSessionScheduler({
+				createRuntime: (sessionKey) => createAgentHarnessPooledRuntime(createAgentHarness({
+					clock: createSystemClock(),
+					eventSinks: telemetry ? [eventLog, telemetry.sink] : [eventLog],
+					initialEvents: eventsForSession(initialEvents, sessionKey),
+					loop,
+					runIds: createUuidRunIds(),
+					...input.binding.kind === "background-session" && backgroundSessionsConfig ? { runTimeoutMs: backgroundSessionsConfig.stepTimeoutMs } : {}
+				})),
+				maxConcurrentSessions: input.binding.kind === "background-session" ? backgroundSessionsConfig?.maxConcurrentSessions ?? 4 : 4,
+				maxQueuedRuns: 32
+			});
+			return {
+				...scheduler,
+				dispose: async () => {
+					await scheduler.dispose?.();
+					await sessionRegistry.disposeAll();
+				}
+			};
+		}
+	};
+}
+function eventsForSession(events, sessionKey) {
+	const runIds = new Set(events.filter((event) => event.sessionKey === sessionKey).map((event) => event.runId));
+	return events.filter((event) => runIds.has(event.runId));
+}
+function resolveAutomationTarget(targetRef, env) {
+	if (!targetRef.startsWith("env:")) throw new Error("Automation delivery targetRef must use env:<VARIABLE>");
+	const variable = targetRef.slice(4);
+	if (!/^[A-Z][A-Z0-9_]*$/.test(variable)) throw new Error(`Invalid Automation delivery targetRef: ${targetRef}`);
+	const target = env[variable]?.trim();
+	if (!target) throw new Error(`${variable} is required`);
+	return target;
+}
+function resolveExperimentalCotBaseUrl(env) {
+	const baseUrl = env.RIVUS_FEISHU_COT_BASE_URL?.trim();
+	if (!baseUrl) throw new Error("RIVUS_FEISHU_COT_BASE_URL is required when experimental.cotMessages is enabled");
+	return baseUrl;
+}
+function reportCotError(endpointId, operation, error) {
+	return Effect.sync(() => {
+		const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+		console.error(`Experimental Feishu COT ${operation} failed for endpoint ${endpointId}: ${detail}`);
+	});
+}
+function readAutomationRunResult(result) {
+	const { finalText, runId } = readStepRunResult(result);
+	const trimmedText = finalText.trim();
+	if (trimmedText.startsWith("RIVUS_AUTOMATION_SUPPRESSED:")) {
+		const reason = trimmedText.slice(AUTOMATION_SUPPRESSION_PREFIX.length).trim();
+		if (!reason) throw new Error("Scheduled Automation suppression requires a reason");
+		return {
+			runId,
+			suppressedReason: reason
+		};
+	}
+	if (!trimmedText) throw new Error("Scheduled Automation Agent Run did not produce final text");
+	return {
+		body: finalText,
+		runId
+	};
+}
+function readStepRunResult(result) {
+	if (result !== null && typeof result === "object" && "finalText" in result && typeof result.finalText === "string" && "runId" in result && typeof result.runId === "string" && result.runId.trim() !== "") return {
+		finalText: result.finalText,
+		runId: result.runId
+	};
+	throw new Error("Background session Agent Run did not produce a runId and final text");
+}
+function createLazyFeishuWebSocketClient(credentials, domain) {
+	let client;
+	let connected = false;
+	return {
+		connected: () => connected,
+		close: () => {
+			client?.close();
+			client = void 0;
+			connected = false;
+		},
+		start: (options) => new Promise((resolve, reject) => {
+			let settled = false;
+			const settle = (callback) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				callback();
+			};
+			const timeout = setTimeout(() => settle(() => reject(/* @__PURE__ */ new Error("Feishu WebSocket handshake timed out after 15000ms"))), 15e3);
+			client ??= new Lark.WSClient({
+				...credentials,
+				domain,
+				handshakeTimeoutMs: 1e4,
+				onError: (error) => {
+					connected = false;
+					settle(() => reject(error));
+				},
+				onReady: () => {
+					connected = true;
+					settle(resolve);
+				},
+				onReconnected: () => {
+					connected = true;
+				},
+				onReconnecting: () => {
+					connected = false;
+				}
+			});
+			client.start(options).catch((error) => {
+				connected = false;
+				settle(() => reject(error));
+			});
+		})
+	};
+}
+async function resolveFeishuBotOpenId(credentials, domain) {
+	const response = await new Lark.Client({
+		...credentials,
+		domain
+	}).request({
+		method: "GET",
+		url: "/open-apis/bot/v3/info"
+	});
+	const openId = response.bot?.open_id;
+	if (response.code !== 0 || !openId) throw new Error(`Feishu bot identity lookup failed: ${response.msg ?? "response missing bot.open_id"}`);
+	return openId;
+}
+async function createPiSessionOptions(context) {
+	const authStorage = AuthStorage.create(PI_AUTH_FILE);
+	const modelReference = optional(context.env.PI_MODEL);
+	const configuredModel = modelReference ? parseModelReference(modelReference) : void 0;
+	const provider = configuredModel?.provider;
+	const apiKey = await resolvePiApiKey(context.env);
+	const baseUrl = optional(context.env.PI_BASE_URL);
+	if ((apiKey || baseUrl) && !provider) throw new Error("PI_API_KEY and PI_BASE_URL require PI_MODEL in provider/model form");
+	if (apiKey) authStorage.setRuntimeApiKey(provider, apiKey);
+	if (baseUrl) await writeProviderBaseUrlOverride(provider, baseUrl);
+	const modelRegistry = ModelRegistry.create(authStorage, baseUrl ? PI_MODELS_FILE : void 0);
+	const model = configuredModel ? modelRegistry.find(configuredModel.provider, configuredModel.modelId) : void 0;
+	if (modelReference && !model) throw new Error(`PI_MODEL ${modelReference} was not found in the Pi model registry`);
+	const thinkingLevel = readThinkingLevel(context.env.PI_THINKING_LEVEL);
+	return {
+		authStorage,
+		cwd: process.cwd(),
+		modelRegistry,
+		...model ? { model } : {},
+		...thinkingLevel ? { thinkingLevel } : {}
+	};
+}
+async function resolvePiApiKey(env) {
+	const inline = optional(env.PI_API_KEY);
+	const filePath = optional(env.PI_API_KEY_FILE);
+	if (inline && filePath) throw new Error("PI_API_KEY and PI_API_KEY_FILE cannot both be set");
+	if (inline) return inline;
+	if (!filePath) return void 0;
+	const contents = optional(await readFile(filePath, "utf8"));
+	if (!contents) throw new Error("PI_API_KEY_FILE must not be empty");
+	return contents;
+}
+function optional(value) {
+	return value?.trim() || void 0;
+}
+function parseModelReference(reference) {
+	const separator = reference.indexOf("/");
+	if (separator <= 0 || separator === reference.length - 1) throw new Error("PI_MODEL must use provider/model form, for example zai/glm-5.1");
+	return {
+		modelId: reference.slice(separator + 1),
+		provider: reference.slice(0, separator)
+	};
+}
+function readThinkingLevel(value) {
+	const level = optional(value);
+	if (!level) return void 0;
+	if (!THINKING_LEVELS.has(level)) throw new Error("PI_THINKING_LEVEL must be one of off, minimal, low, medium, high, xhigh");
+	return level;
+}
+function sleep(ms) {
+	return Effect.promise(() => new Promise((resolve) => setTimeout(resolve, ms)));
+}
+async function writeProviderBaseUrlOverride(provider, baseUrl) {
+	await mergePiProviderBaseUrlOverride({
+		baseUrl,
+		filePath: PI_MODELS_FILE,
+		provider
+	});
+}
+//#endregion
+export { createRivusDeploymentAdapters };