@rivus/gateway 0.16.2

package/dist/bootstrap/pi-feishu.js

@@ -0,0 +1,671 @@
+import { $n as AUTOMATION_SUPPRESSION_PREFIX, B as createBackgroundSessionService, Cn as openPiModelManagementDeployment, G as createFeishuPresentationPreparation, I as openJsonlBackgroundSessionDeliveryStore, J as openJsonlRecoveryControl, K as createFeishuDeploymentEndpoint, M as createBackgroundSessionSupervisor, P as openJsonlBackgroundSessionRepository, Q as createAgentsMdInstructionsProvider, Qn as readAutomationPresentation, Rt as createLazyFeishuWebSocketEventDispatcher, S as resolveFeishuDeliveryChatId, Sn as createPiManagedRunGatewayProvider, Un as createBackgroundSessionHostTools, Y as openJsonlToolOperationLedger$1, Z as createToolBroker$1, _ as openJsonAutomationTickRepository, _n as openJsonlFeishuCardDeliveryLedger, c as createConfiguredFeishuAutomationCardSender, d as createHumanInteractionToolApprovalGateway, dn as openJsonFeishuSessionStore, dt as createConfiguredFeishuMessageReactionSender, et as createFeishuCotPublisher, f as createHumanInteractionEndpointRegistry, ft as createConfiguredFeishuTextReplySender, h as loadRivusDeploymentManifest, it as createJsonFileFeishuCardTargetRegistry, j as resolveBackgroundSessionSupervisorIntervalMs, l as createRoutedHumanInteractionToolApprovalService, lt as createFeishuTopicContextResolver, n as createConfiguredFeishuHumanInteractionPresenter, o as createJsonlHumanInteractionRepository, pn as openJsonlFeishuInboxRepository, pt as createConfiguredFeishuCardRolloverRuntime, q as createAgentHarnessPooledRuntime, sn as createJsonFetchRequest, t as createHumanInteractionService, u as createHumanInteractionModelChangeApproval, un as createSessionScheduler, v as createScheduledAutomation, wt as createConfiguredFeishuOpenApiClient, x as createConfiguredFeishuBackgroundSessionDelivery, y as openJsonlAgentMemoryService, yn as createFeishuCardDeliveryReconciler } from "../chunks/service.js";
+import { f as createBackgroundSessionStepSourceMessageId } from "../chunks/background-session-authority.js";
+import { i as resolveFeishuEndpointCredentials } from "../chunks/node-rivus-deployment-manifest.js";
+import { Effect } from "effect";
+import { createJsonlAgentEventLog, createLangfuseAgentTelemetry, createLegacyAgentHarness, createLegacyProjectMemoryPromptPreparer, createLegacyRivusMemoryToolDescriptor, createSystemClock, createUuidRunIds, createWorkspaceRootHandle, normalizeAgentInvocation, resolveLangfuseTelemetryConfig, toEffectLegacyAgentLoopInput } from "@rivus/runtime";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { homedir } from "node:os";
+import { createLegacyPiAgentLoop, createLegacyPiSessionRegistry, createLegacyPiToolNameResolver, createLegacyPiToolProxyDefinitions, createPiAssembly, createPiBashTool, createPiManagedRunBinding, createPiSessionResources, createPiSkillReadTools, createPiSkillRuntime, ensurePiModel, mergePiProviderBaseUrlOverride, resolvePiSessionToolNames, validatePiSkillCommand } from "@rivus/runtime/pi";
+import * as Lark from "@larksuiteoapi/node-sdk";
+//#region src/bootstrap/pi-feishu.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 hasManagedState = await stat(join(STATE_DIR, "model-management", "model-state.json")).then(() => true, (error) => {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	});
+	const piOptions = await createPiSessionOptions(context, context.env.RIVUS_MODEL_MANAGEMENT_ENABLED?.trim() === "true" || hasManagedState);
+	let activeModel = piOptions.model;
+	const telemetryConfig = resolveLangfuseTelemetryConfig(context.env);
+	let telemetry;
+	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 defaultEndpoint = manifest.endpoints.find((endpoint) => endpoint.id === manifest.defaultEndpointId);
+	const management = await openPiModelManagementDeployment({
+		agentId: manifest.defaultAgentId,
+		approval: createHumanInteractionModelChangeApproval({
+			endpointId: manifest.defaultEndpointId,
+			registry: interactionRegistry
+		}),
+		agentCount: manifest.agents.length,
+		endpointId: manifest.defaultEndpointId,
+		env: context.env,
+		environmentOverrides: context.environmentOverrides ?? process.env,
+		...context.envFilePath ? { envFilePath: context.envFilePath } : {},
+		modelAuthPath: PI_AUTH_FILE,
+		modelCatalogPath: PI_MODELS_FILE,
+		modelRuntime: piOptions.assembly.modelRuntime,
+		reply: (messageId, text) => {
+			const config = createEndpointConfig(defaultEndpoint, manifest.defaultAgentId, context.env);
+			return createConfiguredFeishuTextReplySender({
+				config,
+				client: createOpenApiClient(config)
+			}).reply(messageId, text);
+		},
+		stateDirectory: STATE_DIR,
+		thinkingLevel: piOptions.thinkingLevel ?? "medium"
+	});
+	try {
+		telemetry = telemetryConfig ? createLangfuseAgentTelemetry(telemetryConfig) : void 0;
+		if (management && !management.enabled) activeModel = await ensurePiModel({
+			modelRuntime: piOptions.assembly.modelRuntime,
+			modelsPath: PI_MODELS_FILE,
+			target: management.model
+		});
+		if (management?.enabled && management.recoveryRequired) console.error("Model management requires recovery; business Runs are paused. Query rivus model status --json.");
+		if (management?.enabled && management.skillInstallation.status === "conflict") console.error("The runtime-management Skill has local edits; its installed instructions were preserved.");
+		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 config = createEndpointConfig(endpoint, endpoint.agentId, context.env);
+				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: async () => {
+				if (management?.enabled) await management.close();
+				await telemetry?.shutdown();
+				await piOptions.assembly.dispose();
+			},
+			createRecoveryControl: () => openJsonlRecoveryControl({
+				endpointsDirectory: join(STATE_DIR, "endpoints"),
+				instancesDirectory: join(STATE_DIR, "instances")
+			}),
+			createBackgroundSession: backgroundSessionsConfig?.enabled ? (input) => createBackgroundSessionAdapter(input) : void 0,
+			createAutomation: async (input) => {
+				const config = createEndpointConfig(input.deliveryEndpoint, input.definition.agentId, context.env);
+				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 = createEndpointConfig(input.definition, input.agentId, context.env);
+				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 reactions = createConfiguredFeishuMessageReactionSender({
+					client: openApiClient,
+					config
+				});
+				const prepareCardTarget = (run) => cardRollover.prepareRun(run);
+				const endpoint = createFeishuDeploymentEndpoint({
+					agentId: input.agentId,
+					acknowledgeSteering: (messageId) => reactions.add(messageId),
+					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$1({
+					approvals: createRoutedHumanInteractionToolApprovalService(interactionRegistry),
+					catalog: input.catalog,
+					hostTools: [...input.definition.memory.tool ? [createLegacyRivusMemoryToolDescriptor({ memory })] : [], ...backgroundService ? [...createBackgroundSessionHostTools({
+						createSessionId: () => `bg-${randomUUID()}`,
+						definition: input.definition,
+						service: backgroundService
+					})] : []],
+					operations: await openJsonlToolOperationLedger$1({ filePath: join(instanceState, "tool-operations.jsonl") }),
+					policy: { current: async () => ({
+						epoch: 1,
+						revokedToolIds: []
+					}) }
+				});
+				const resolveToolName = createLegacyPiToolNameResolver(input.definition.tools);
+				const skillRuntime = createPiSkillRuntime(input.definition.skills);
+				const workingDirectory = input.projectSpace?.workingDirectory ?? process.cwd();
+				const runContexts = management?.enabled ? management.createRunContexts({
+					agentId: input.agentId,
+					instanceId: input.instanceId,
+					toolGrantSet: input.definition.toolGrantSet
+				}) : void 0;
+				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") ? createLegacyProjectMemoryPromptPreparer({
+					agentId: input.agentId,
+					memory,
+					projectId: input.projectSpace.id
+				}) : void 0;
+				const sessionRegistry = createLegacyPiSessionRegistry({ 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 managedBinding = management?.enabled && runContexts && input.definition.runtimeToolGrantSet.toolIds.includes("bash") ? createPiManagedRunBinding({
+						...resources.bashToolOptions ? { bashToolOptions: resources.bashToolOptions } : {},
+						cwd: workingDirectory,
+						provider: createPiManagedRunGatewayProvider({
+							binDirectory: management.binDirectory,
+							contexts: runContexts.registry,
+							nodeExecutable: process.execPath,
+							socketPath: management.socketPath,
+							source: () => toEffectLegacyAgentLoopInput(activeInput)
+						})
+					}) : void 0;
+					const bashTool = input.definition.runtimeToolGrantSet.toolIds.includes("bash") ? managedBinding?.tool ?? createPiBashTool(workingDirectory, resources.bashToolOptions) : void 0;
+					const customTools = [
+						...bashTool ? [bashTool] : [],
+						...createPiSkillReadTools({
+							cwd: workingDirectory,
+							runtimeToolIds: input.definition.runtimeToolGrantSet.toolIds,
+							skillPaths: resources.skillNames.size > 0 ? resources.skillPaths : []
+						}),
+						...createLegacyPiToolProxyDefinitions({
+							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(bashTool ? input.definition.runtimeToolGrantSet.toolIds.filter((toolId) => toolId !== "bash") : input.definition.runtimeToolGrantSet.toolIds, customTools);
+					const result = await piOptions.assembly.createSession({
+						...activeModel ? { model: activeModel } : {},
+						...piOptions.thinkingLevel ? { thinkingLevel: piOptions.thinkingLevel } : {},
+						...management?.enabled ? management.runtime.getSessionOptions() : {},
+						customTools,
+						excludeTools: [],
+						resources,
+						sessionCwd: workingDirectory,
+						sessionDirectory: join(instanceState, "sessions"),
+						tools: [...activeToolNames]
+					});
+					return {
+						activate: (loopInput) => {
+							activeInput = loopInput;
+							managedBinding?.activate({
+								runId: loopInput.runId,
+								sessionKey: loopInput.sessionKey,
+								abortSignal: loopInput.abortSignal,
+								...loopInput.invocation ? { invocation: normalizeAgentInvocation(loopInput.invocation) } : {}
+							});
+						},
+						deactivate: () => managedBinding?.deactivate(),
+						dispose: () => result.session.dispose(),
+						preparePrompt: async (loopInput) => {
+							validatePiSkillCommand(loopInput.text, resources.skillNames);
+							return prepareProjectMemory ? prepareProjectMemory(loopInput) : loopInput.text;
+						},
+						resolveToolName,
+						refreshResources: () => resources.refresh(),
+						session: result.session
+					};
+				} });
+				const unregisterModels = management?.enabled ? management.runtime.registerSessionRegistry(sessionRegistry) : void 0;
+				const loop = createLegacyPiAgentLoop({
+					supportsSteering: true,
+					disposeSessionAfterRun: false,
+					...management?.enabled ? { runBoundary: management.boundary } : {},
+					...telemetry ? { modelContentObserver: telemetry.modelContentObserver } : {},
+					resolveSession: (loopInput) => sessionRegistry.resolve(loopInput)
+				});
+				const scheduler = createSessionScheduler({
+					createRuntime: (sessionKey) => createAgentHarnessPooledRuntime(createLegacyAgentHarness({
+						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();
+						unregisterModels?.();
+						runContexts?.unregister();
+					}
+				};
+			}
+		};
+	} catch (error) {
+		await Promise.allSettled([management?.enabled ? management.close() : Promise.resolve(), telemetry?.shutdown()]);
+		throw error;
+	}
+}
+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, deferModel = false) {
+	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 (baseUrl && !deferModel) await writeProviderBaseUrlOverride(provider, baseUrl);
+	const assembly = await createPiAssembly({
+		allowModelNetwork: false,
+		agentDir: PI_AGENT_DIR,
+		authPath: PI_AUTH_FILE,
+		cwd: process.cwd(),
+		homeDirectory: homedir(),
+		modelsPath: baseUrl || deferModel ? PI_MODELS_FILE : null
+	});
+	const modelRuntime = assembly.modelRuntime;
+	if (apiKey) await modelRuntime.setRuntimeApiKey(provider, apiKey);
+	const model = configuredModel && !deferModel ? modelRuntime.getModel(configuredModel.provider, configuredModel.modelId) : void 0;
+	if (modelReference && !model && !deferModel) throw new Error(`PI_MODEL ${modelReference} was not found in the Pi model runtime`);
+	const thinkingLevel = readThinkingLevel(context.env.PI_THINKING_LEVEL) ?? (deferModel && configuredModel ? normalizeThinkingLevel(assembly.resolveThinkingLevel(configuredModel.provider, configuredModel.modelId)) : deferModel ? normalizeThinkingLevel(assembly.resolveThinkingLevel()) : void 0);
+	return {
+		assembly,
+		...model ? { model } : {},
+		...thinkingLevel ? { thinkingLevel } : {}
+	};
+}
+function createEndpointConfig(definition, agentId, env) {
+	return {
+		agentId,
+		feishu: {
+			...resolveFeishuEndpointCredentials(definition.credentialRef, env),
+			baseUrl: definition.baseUrl,
+			cardStreamLeaseMs: definition.cardStreamLeaseMs,
+			streamMinIntervalMs: definition.streamMinIntervalMs
+		},
+		pi: {}
+	};
+}
+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.2");
+	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 normalizeThinkingLevel(value) {
+	return value !== void 0 && THINKING_LEVELS.has(value) ? value : void 0;
+}
+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 };