@rivus/agent 0.5.0 → 0.5.2

package/dist/acp.js

@@ -312,7 +312,11 @@ function createAcpStdioAgentLoop(options) {
 			resolveSession: async (input) => {
 				const processConnection = await resolveConnection();
 				const current = processConnection.sessions.get(input.sessionKey);
-				if (current) return current;
+				if (current?.isReusable) return current;
+				if (current) {
+					current.dispose();
+					processConnection.sessions.delete(input.sessionKey);
+				}
 				const session = new SdkAcpAgentSession(await processConnection.connection.agent.buildSession(options.workingDirectory).start(), processConnection.connection.agent);
 				sessionKeys.set(session.sessionId, input.sessionKey);
 				processConnection.sessions.set(input.sessionKey, session);
@@ -324,6 +328,7 @@ function createAcpStdioAgentLoop(options) {
 var SdkAcpAgentSession = class {
 	session;
 	agent;
+	reusable = true;
 	constructor(session, agent) {
 		this.session = session;
 		this.agent = agent;
@@ -331,10 +336,15 @@ var SdkAcpAgentSession = class {
 	get sessionId() {
 		return this.session.sessionId;
 	}
+	get isReusable() {
+		return this.reusable;
+	}
 	cancel() {
+		this.reusable = false;
 		return this.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.session.sessionId });
 	}
 	dispose() {
+		this.reusable = false;
 		this.session.dispose();
 	}
 	async prompt(text, onUpdate) {

package/dist/index.d.ts

@@ -18,6 +18,7 @@ interface AgentHarnessOptions {
   readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
   readonly initialRunStates?: ReadonlyArray<AgentRunState>;
   readonly loop: AgentLoop;
+  readonly runTimeoutMs?: number;
   readonly runIds: RunIdGenerator;
 }
 interface PromptCommand {
@@ -1902,14 +1903,17 @@ declare function createFeishuEventHandlers(options: FeishuEventHandlersOptions):
 //#region src/composition/feishu-agent-runtime.d.ts
 interface FeishuAgentRuntimeOptions {
   readonly agentId: string;
+  readonly botOpenId?: string;
   readonly clock: AgentClock;
   readonly eventSinks?: ReadonlyArray<AgentDomainEventSink>;
+  readonly inboxRepository?: FeishuInboxRepository;
   readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
   readonly initialRunStates?: ReadonlyArray<AgentRunState>;
   readonly loop: AgentLoop;
   readonly prepareRun?: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
   readonly periodicFlush?: FeishuPeriodicFlushSupervisor;
   readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly runTimeoutMs?: number;
   readonly runIds: RunIdGenerator;
 }
 interface FeishuPeriodicFlushSupervisor {
@@ -2155,6 +2159,7 @@ declare function createJsonlAgentEventLog(options: JsonlAgentEventLogOptions): A
 type ConfiguredRivusDaemonBootstrapRequest = ConfiguredFeishuOpenApiRequest;
 type ConfiguredRivusDaemonBootstrapResponse = ConfiguredFeishuOpenApiResponse;
 interface ConfiguredRivusDaemonBootstrapOptions {
+  readonly botOpenId?: string;
   readonly cardTargets: FeishuCardTargetRegistry;
   readonly clock: AgentClock;
   readonly config: RivusDaemonConfig;
@@ -2164,10 +2169,12 @@ interface ConfiguredRivusDaemonBootstrapOptions {
   readonly flushIntervalMs?: number;
   readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
   readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly inboxRepository?: FeishuInboxRepository;
   readonly loop: AgentLoop;
   readonly onWorkerError?: (error: unknown) => void | Promise<void>;
   readonly request: (request: ConfiguredRivusDaemonBootstrapRequest) => Effect.Effect<ConfiguredRivusDaemonBootstrapResponse, unknown>;
   readonly runIds: RunIdGenerator;
+  readonly runTimeoutMs?: number;
   readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
   readonly websocketClient: FeishuWebSocketClient;
   readonly workerIntervalMs?: number;

package/dist/index.js

@@ -1083,6 +1083,7 @@ function createAgentRunUpdateHandler(handle) {
 	});
 }
 function createAgentHarness(options) {
+	if (options.runTimeoutMs !== void 0 && (!Number.isSafeInteger(options.runTimeoutMs) || options.runTimeoutMs < 1)) throw new Error("Agent run timeout must be a positive integer");
 	let activeRun;
 	let activeCancellation;
 	let activeRunState;
@@ -1223,7 +1224,7 @@ function createAgentHarness(options) {
 				sessionKey: command.sessionKey,
 				text: command.text
 			};
-			yield* Effect.try({
+			const loop = Effect.try({
 				try: () => options.loop.run(loopInput),
 				catch: (error) => error
 			}).pipe(Effect.flatMap((loopStream) => Stream.runForEach(loopStream.pipe(Stream.interruptWhenDeferred(cancellation.deferred)), (event) => Effect.gen(function* () {
@@ -1244,6 +1245,16 @@ function createAgentHarness(options) {
 					return yield* Effect.fail(new AgentLoopFailed(runId, errorMessage, error, state));
 				});
 			}));
+			yield* options.runTimeoutMs === void 0 ? loop : Effect.raceFirst(loop, Effect.sleep(options.runTimeoutMs).pipe(Effect.flatMap(() => {
+				const request = {
+					reason: `run timed out after ${options.runTimeoutMs}ms`,
+					runId,
+					sessionKey: command.sessionKey
+				};
+				cancellation.requested = request;
+				cancellation.abortController.abort(request);
+				return Deferred.succeed(cancellation.deferred, request);
+			}), Effect.asVoid));
 			if (cancellation.requested) {
 				const cancelledAt = yield* options.clock.now;
 				yield* record({
@@ -2626,10 +2637,12 @@ function createFeishuAgentRuntime(options) {
 		...options.initialEvents ? { initialEvents: options.initialEvents } : {},
 		...options.initialRunStates ? { initialRunStates: options.initialRunStates } : {},
 		loop: options.loop,
+		...options.runTimeoutMs === void 0 ? {} : { runTimeoutMs: options.runTimeoutMs },
 		runIds: options.runIds
 	});
 	const daemon = createFeishuAgentDaemon({
 		agentId: options.agentId,
+		...options.botOpenId ? { botOpenId: options.botOpenId } : {},
 		harness,
 		...options.prepareRun ? { prepareRun: options.prepareRun } : {},
 		publish: options.publish
@@ -2638,7 +2651,10 @@ function createFeishuAgentRuntime(options) {
 	let lastHandled;
 	const queue = createFeishuMessageQueue({
 		handleMessage: (payload, handleOptions) => {
-			const effect = daemon.handleMessage(payload, handleOptions).pipe(Effect.tap((result) => describeFeishuMessageIntake(payload, { agentId: options.agentId }).pipe(Effect.tap((intake) => Effect.gen(function* () {
+			const effect = daemon.handleMessage(payload, handleOptions).pipe(Effect.tap((result) => describeFeishuMessageIntake(payload, {
+				agentId: options.agentId,
+				...options.botOpenId ? { botOpenId: options.botOpenId } : {}
+			}).pipe(Effect.tap((intake) => Effect.gen(function* () {
 				const observedAt = yield* options.clock.now;
 				lastHandled = {
 					intake,
@@ -2649,6 +2665,7 @@ function createFeishuAgentRuntime(options) {
 			})))));
 			return options.periodicFlush ? options.periodicFlush.withPeriodicFlush(effect) : effect;
 		},
+		...options.inboxRepository ? { repository: options.inboxRepository } : {},
 		shouldRetryError: isRetryableFeishuMessageError
 	});
 	const worker = createFeishuMessageWorker({ queue });
@@ -2675,7 +2692,10 @@ function createFeishuAgentRuntime(options) {
 			...lastHandled ? { lastHandled } : {}
 		}),
 		replayReceiveMessage: (payload, replayOptions) => Effect.gen(function* () {
-			const intake = yield* describeFeishuMessageIntake(payload, { agentId: options.agentId });
+			const intake = yield* describeFeishuMessageIntake(payload, {
+				agentId: options.agentId,
+				...options.botOpenId ? { botOpenId: options.botOpenId } : {}
+			});
 			return {
 				accepted: yield* observedQueue.accept(payload, replayOptions),
 				drained: yield* worker.drainAvailable(),
@@ -2818,25 +2838,113 @@ function resolveRunPresentation(input) {
 	}
 }
 //#endregion
+//#region src/infrastructure/feishu/feishu-tenant-token-provider.ts
+var FeishuTenantAccessTokenError = class {
+	status;
+	code;
+	message;
+	_tag = "FeishuTenantAccessTokenError";
+	constructor(status, code, message) {
+		this.status = status;
+		this.code = code;
+		this.message = message;
+	}
+};
+const DEFAULT_REFRESH_WINDOW_MS = 1800 * 1e3;
+function createFeishuTenantAccessTokenProvider(options) {
+	const baseUrl = (options.baseUrl ?? "https://open.feishu.cn").replace(/\/$/, "");
+	const now = options.now ?? Date.now;
+	const refreshWindowMs = options.refreshWindowMs ?? DEFAULT_REFRESH_WINDOW_MS;
+	let cached;
+	return { getTenantAccessToken: () => Effect.gen(function* () {
+		if (cached && now() < cached.refreshAfterMs) return cached.token;
+		const response = yield* options.request({
+			body: {
+				app_id: options.appId,
+				app_secret: options.appSecret
+			},
+			headers: { "Content-Type": "application/json; charset=utf-8" },
+			method: "POST",
+			url: `${baseUrl}/open-apis/auth/v3/tenant_access_token/internal`
+		});
+		if (response.status < 200 || response.status >= 300 || response.body.code !== 0 || !response.body.tenant_access_token || typeof response.body.expire !== "number") return yield* Effect.fail(new FeishuTenantAccessTokenError(response.status, response.body.code, response.body.msg ?? "Failed to get tenant_access_token"));
+		cached = {
+			refreshAfterMs: now() + response.body.expire * 1e3 - refreshWindowMs,
+			token: response.body.tenant_access_token
+		};
+		return cached.token;
+	}) };
+}
+//#endregion
+//#region src/infrastructure/feishu/feishu-openapi-client.ts
+var FeishuOpenApiError = class extends Error {
+	status;
+	code;
+	_tag = "FeishuOpenApiError";
+	name = "FeishuOpenApiError";
+	constructor(status, code, message) {
+		super(message);
+		this.status = status;
+		this.code = code;
+	}
+};
+function createFeishuOpenApiClient(options) {
+	return { request: (request, errorMessage = "Feishu OpenAPI error") => Effect.gen(function* () {
+		const token = yield* options.getTenantAccessToken();
+		const response = yield* options.request({
+			...request,
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json; charset=utf-8"
+			}
+		});
+		if (response.status < 200 || response.status >= 300 || response.body.code !== 0) return yield* Effect.fail(new FeishuOpenApiError(response.status, response.body.code, response.body.msg ?? errorMessage));
+		return response;
+	}) };
+}
+function createConfiguredFeishuOpenApiClient(options) {
+	const tokenProvider = createFeishuTenantAccessTokenProvider({
+		appId: options.config.feishu.appId,
+		appSecret: options.config.feishu.appSecret,
+		baseUrl: options.config.feishu.baseUrl,
+		request: (request) => options.request(request).pipe(Effect.map((response) => response))
+	});
+	return createFeishuOpenApiClient({
+		getTenantAccessToken: () => tokenProvider.getTenantAccessToken(),
+		request: (request) => options.request(request).pipe(Effect.map((response) => response))
+	});
+}
+//#endregion
 //#region src/infrastructure/feishu/feishu-cardkit-openapi-client.ts
 function createFeishuCardKitOpenApiClient(options) {
 	const baseUrl = (options.baseUrl ?? "https://open.feishu.cn").replace(/\/$/, "");
 	const agentName = options.agentName ?? "Rivus Agent";
+	const streamingClosedCards = /* @__PURE__ */ new Set();
 	const call = (request) => options.client.request(request).pipe(Effect.asVoid);
+	const updateTerminal = (request, status) => updateTerminalCard(baseUrl, agentName, request, status, call).pipe(Effect.tap(() => Effect.sync(() => streamingClosedCards.delete(request.cardId))));
 	return {
-		cancel: (request) => updateTerminalCard(baseUrl, agentName, request, "cancelled", call),
-		fail: (request) => updateTerminalCard(baseUrl, agentName, request, "failed", call),
-		finish: (request) => updateTerminalCard(baseUrl, agentName, request, "completed", call),
-		updateText: (request) => call({
-			body: {
-				content: request.content,
-				sequence: request.sequence
-			},
-			method: "PUT",
-			url: `${baseUrl}/open-apis/cardkit/v1/cards/${encodeURIComponent(request.cardId)}/elements/${encodeURIComponent(request.elementId)}/content`
-		})
+		cancel: (request) => updateTerminal(request, "cancelled"),
+		fail: (request) => updateTerminal(request, "failed"),
+		finish: (request) => updateTerminal(request, "completed"),
+		updateText: (request) => {
+			if (streamingClosedCards.has(request.cardId)) return Effect.void;
+			return call({
+				body: {
+					content: request.content,
+					sequence: request.sequence
+				},
+				method: "PUT",
+				url: `${baseUrl}/open-apis/cardkit/v1/cards/${encodeURIComponent(request.cardId)}/elements/${encodeURIComponent(request.elementId)}/content`
+			}).pipe(Effect.catchAll((error) => {
+				if (!isStreamingClosed(error)) return Effect.fail(error);
+				return Effect.sync(() => streamingClosedCards.add(request.cardId));
+			}));
+		}
 	};
 }
+function isStreamingClosed(error) {
+	return error instanceof FeishuOpenApiError && (error.code === 200850 || error.code === 300309);
+}
 function updateTerminalCard(baseUrl, agentName, request, status, call) {
 	const card = status === "completed" && "text" in request ? createFeishuAgentRunCard({
 		agentName,
@@ -2968,83 +3076,6 @@ function createConfiguredFeishuCardKitPublisher(options) {
 	}) });
 }
 //#endregion
-//#region src/infrastructure/feishu/feishu-tenant-token-provider.ts
-var FeishuTenantAccessTokenError = class {
-	status;
-	code;
-	message;
-	_tag = "FeishuTenantAccessTokenError";
-	constructor(status, code, message) {
-		this.status = status;
-		this.code = code;
-		this.message = message;
-	}
-};
-const DEFAULT_REFRESH_WINDOW_MS = 1800 * 1e3;
-function createFeishuTenantAccessTokenProvider(options) {
-	const baseUrl = (options.baseUrl ?? "https://open.feishu.cn").replace(/\/$/, "");
-	const now = options.now ?? Date.now;
-	const refreshWindowMs = options.refreshWindowMs ?? DEFAULT_REFRESH_WINDOW_MS;
-	let cached;
-	return { getTenantAccessToken: () => Effect.gen(function* () {
-		if (cached && now() < cached.refreshAfterMs) return cached.token;
-		const response = yield* options.request({
-			body: {
-				app_id: options.appId,
-				app_secret: options.appSecret
-			},
-			headers: { "Content-Type": "application/json; charset=utf-8" },
-			method: "POST",
-			url: `${baseUrl}/open-apis/auth/v3/tenant_access_token/internal`
-		});
-		if (response.status < 200 || response.status >= 300 || response.body.code !== 0 || !response.body.tenant_access_token || typeof response.body.expire !== "number") return yield* Effect.fail(new FeishuTenantAccessTokenError(response.status, response.body.code, response.body.msg ?? "Failed to get tenant_access_token"));
-		cached = {
-			refreshAfterMs: now() + response.body.expire * 1e3 - refreshWindowMs,
-			token: response.body.tenant_access_token
-		};
-		return cached.token;
-	}) };
-}
-//#endregion
-//#region src/infrastructure/feishu/feishu-openapi-client.ts
-var FeishuOpenApiError = class extends Error {
-	status;
-	code;
-	_tag = "FeishuOpenApiError";
-	name = "FeishuOpenApiError";
-	constructor(status, code, message) {
-		super(message);
-		this.status = status;
-		this.code = code;
-	}
-};
-function createFeishuOpenApiClient(options) {
-	return { request: (request, errorMessage = "Feishu OpenAPI error") => Effect.gen(function* () {
-		const token = yield* options.getTenantAccessToken();
-		const response = yield* options.request({
-			...request,
-			headers: {
-				Authorization: `Bearer ${token}`,
-				"Content-Type": "application/json; charset=utf-8"
-			}
-		});
-		if (response.status < 200 || response.status >= 300 || response.body.code !== 0) return yield* Effect.fail(new FeishuOpenApiError(response.status, response.body.code, response.body.msg ?? errorMessage));
-		return response;
-	}) };
-}
-function createConfiguredFeishuOpenApiClient(options) {
-	const tokenProvider = createFeishuTenantAccessTokenProvider({
-		appId: options.config.feishu.appId,
-		appSecret: options.config.feishu.appSecret,
-		baseUrl: options.config.feishu.baseUrl,
-		request: (request) => options.request(request).pipe(Effect.map((response) => response))
-	});
-	return createFeishuOpenApiClient({
-		getTenantAccessToken: () => tokenProvider.getTenantAccessToken(),
-		request: (request) => options.request(request).pipe(Effect.map((response) => response))
-	});
-}
-//#endregion
 //#region src/infrastructure/feishu/feishu-cardkit-target-preparation.ts
 const DEFAULT_ELEMENT_ID = "rivus_agent_answer";
 function createFeishuCardTargetPreparation(options) {
@@ -3114,6 +3145,7 @@ function isRecord$2(value) {
 //#endregion
 //#region src/composition/rivus-daemon-bootstrap.ts
 const DEFAULT_WORKER_INTERVAL_MS$1 = 250;
+const DEFAULT_RUN_TIMEOUT_MS = 900 * 1e3;
 function restoreConfiguredRivusDaemonBootstrap(options) {
 	return options.eventLog.readAll().pipe(Effect.map((events) => createConfiguredRivusDaemonBootstrap({
 		...options,
@@ -3139,14 +3171,17 @@ function createConfiguredRivusDaemonBootstrap(options) {
 	const periodicFlush = createPeriodicFlush(options, publisher);
 	const runtime = createFeishuAgentRuntime({
 		agentId: options.config.agentId,
+		...options.botOpenId ? { botOpenId: options.botOpenId } : {},
 		clock: options.clock,
 		eventSinks: [options.eventLog],
+		...options.inboxRepository ? { inboxRepository: options.inboxRepository } : {},
 		...options.initialEvents ? { initialEvents: options.initialEvents } : {},
 		...options.initialRunStates ? { initialRunStates: options.initialRunStates } : {},
 		loop: options.loop,
 		periodicFlush,
 		prepareRun,
 		publish: (action) => publisher.publish(action),
+		runTimeoutMs: options.runTimeoutMs ?? DEFAULT_RUN_TIMEOUT_MS,
 		runIds: options.runIds
 	});
 	const websocketTransport = createFeishuWebSocketDaemon({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivus/agent",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "A local agent daemon core built around a usable agent harness and domain events.",
   "type": "module",
   "license": "MIT",