@rivus/agent 0.3.1 → 0.4.1

package/dist/agent-loop.d.ts

@@ -0,0 +1,420 @@
+import { n as AgentMemoryIdentity } from "./agent-memory.js";
+import { Effect, Stream } from "effect";
+
+//#region src/domain/agent-events.d.ts
+type AgentRunId = string;
+type SessionKey = string;
+interface AgentRunAccepted {
+  readonly type: "agent_run_accepted";
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly prompt: string;
+  readonly occurredAt: Date;
+}
+interface AgentTurnStarted {
+  readonly type: "agent_turn_started";
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly occurredAt: Date;
+}
+interface AssistantTextDelta {
+  readonly type: "assistant_text_delta";
+  readonly runId: AgentRunId;
+  readonly delta: string;
+  readonly occurredAt: Date;
+}
+interface AssistantThinkingDelta {
+  readonly type: "assistant_thinking_delta";
+  readonly runId: AgentRunId;
+  readonly delta: string;
+  readonly occurredAt: Date;
+}
+interface AgentModelExecutionStarted {
+  readonly type: "agent_model_execution_started";
+  readonly api: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly occurredAt: Date;
+  readonly provider: string;
+  readonly runId: AgentRunId;
+}
+interface AgentModelUsage {
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly cost: number;
+  readonly input: number;
+  readonly output: number;
+  readonly reasoning?: number;
+  readonly total: number;
+}
+interface AgentModelExecutionEnded {
+  readonly type: "agent_model_execution_ended";
+  readonly api: string;
+  readonly errorMessage?: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly occurredAt: Date;
+  readonly provider: string;
+  readonly responseModel?: string;
+  readonly runId: AgentRunId;
+  readonly stopReason: string;
+  readonly usage: AgentModelUsage;
+}
+interface AgentSkillExecutionStarted {
+  readonly type: "agent_skill_execution_started";
+  readonly occurredAt: Date;
+  readonly runId: AgentRunId;
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+interface AgentSkillExecutionSucceeded {
+  readonly type: "agent_skill_execution_ended";
+  readonly contentLength: number;
+  readonly digest: string;
+  readonly isError: false;
+  readonly occurredAt: Date;
+  readonly runId: AgentRunId;
+  readonly skillCallId: string;
+  readonly skillId: string;
+  readonly title: string;
+  readonly version: string;
+}
+interface AgentSkillExecutionFailed {
+  readonly type: "agent_skill_execution_ended";
+  readonly isError: true;
+  readonly occurredAt: Date;
+  readonly runId: AgentRunId;
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+type AgentSkillExecutionEnded = AgentSkillExecutionSucceeded | AgentSkillExecutionFailed;
+interface AgentToolExecutionStarted {
+  readonly type: "agent_tool_execution_started";
+  readonly runId: AgentRunId;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly occurredAt: Date;
+}
+interface AgentToolExecutionUpdated {
+  readonly type: "agent_tool_execution_updated";
+  readonly runId: AgentRunId;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly partialResult: unknown;
+  readonly occurredAt: Date;
+}
+interface AgentToolExecutionEnded {
+  readonly type: "agent_tool_execution_ended";
+  readonly runId: AgentRunId;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: unknown;
+  readonly isError: boolean;
+  readonly occurredAt: Date;
+}
+interface AgentTurnCompleted {
+  readonly type: "agent_turn_completed";
+  readonly runId: AgentRunId;
+  readonly finalText: string;
+  readonly occurredAt: Date;
+}
+interface AgentRunCompleted {
+  readonly type: "agent_run_completed";
+  readonly runId: AgentRunId;
+  readonly finalText: string;
+  readonly occurredAt: Date;
+}
+interface AgentRunFailed {
+  readonly type: "agent_run_failed";
+  readonly runId: AgentRunId;
+  readonly errorMessage: string;
+  readonly occurredAt: Date;
+}
+interface AgentRunCancelled {
+  readonly type: "agent_run_cancelled";
+  readonly runId: AgentRunId;
+  readonly reason?: string;
+  readonly occurredAt: Date;
+}
+type AgentDomainEvent = AgentRunAccepted | AgentTurnStarted | AssistantTextDelta | AssistantThinkingDelta | AgentModelExecutionStarted | AgentModelExecutionEnded | AgentSkillExecutionStarted | AgentSkillExecutionEnded | AgentToolExecutionStarted | AgentToolExecutionUpdated | AgentToolExecutionEnded | AgentTurnCompleted | AgentRunCompleted | AgentRunFailed | AgentRunCancelled;
+type AgentToolExecutionEvent = AgentToolExecutionStarted | AgentToolExecutionUpdated | AgentToolExecutionEnded;
+type AgentModelExecutionEvent = AgentModelExecutionStarted | AgentModelExecutionEnded;
+type TerminalAgentDomainEvent = AgentRunCompleted | AgentRunFailed | AgentRunCancelled;
+declare function isAssistantTextDeltaEvent(event: AgentDomainEvent): event is AssistantTextDelta;
+declare function isAssistantThinkingDeltaEvent(event: AgentDomainEvent): event is AssistantThinkingDelta;
+declare function isAgentToolExecutionEvent(event: AgentDomainEvent): event is AgentToolExecutionEvent;
+declare function isTerminalAgentDomainEvent(event: AgentDomainEvent): event is TerminalAgentDomainEvent;
+//#endregion
+//#region src/domain/agent-run-state.d.ts
+type AgentRunPhase = "idle" | "accepted" | "running" | "completed" | "failed" | "cancelled";
+interface AgentRunState {
+  readonly phase: AgentRunPhase;
+  readonly runId?: AgentRunId;
+  readonly sessionKey?: SessionKey;
+  readonly prompt?: string;
+  readonly finalText: string;
+  readonly errorMessage?: string;
+  readonly cancellationReason?: string;
+  readonly thinkingText?: string;
+  readonly skillExecutions: Readonly<Record<string, AgentSkillExecutionState>>;
+  readonly toolExecutions: Readonly<Record<string, AgentToolExecutionState>>;
+}
+interface AgentSkillExecutionState {
+  readonly contentLength?: number;
+  readonly digest?: string;
+  readonly isError?: boolean;
+  readonly skillCallId: string;
+  readonly skillId: string;
+  readonly status: "running" | "completed";
+  readonly title?: string;
+  readonly version?: string;
+}
+interface AgentToolExecutionState {
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly partialResult?: unknown;
+  readonly result?: unknown;
+  readonly isError?: boolean;
+  readonly status: "running" | "completed";
+}
+declare const initialAgentRunState: AgentRunState;
+declare function isTerminalAgentRunPhase(phase: AgentRunPhase): boolean;
+declare function evolveAgentRun(state: AgentRunState, event: AgentDomainEvent): AgentRunState;
+//#endregion
+//#region src/domain/agent-history.d.ts
+interface AgentRunSummary {
+  readonly acceptedAt?: Date;
+  readonly cancellationReason?: string;
+  readonly cancelledAt?: Date;
+  readonly completedAt?: Date;
+  readonly errorMessage?: string;
+  readonly eventCount: number;
+  readonly failedToolExecutionCount: number;
+  readonly failedSkillExecutionCount: number;
+  readonly failedAt?: Date;
+  readonly finalText: string;
+  readonly phase: AgentRunPhase;
+  readonly prompt?: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey?: SessionKey;
+  readonly startedAt?: Date;
+  readonly state: AgentRunState;
+  readonly thinkingText: string;
+  readonly skillExecutionCount: number;
+  readonly toolExecutionCount: number;
+  readonly updatedAt: Date;
+}
+interface AgentSessionSummary {
+  readonly failedToolExecutionCount: number;
+  readonly failedSkillExecutionCount: number;
+  readonly finalText: string;
+  readonly latestPhase: AgentRunPhase;
+  readonly latestRunId: AgentRunId;
+  readonly runCount: number;
+  readonly runIds: ReadonlyArray<AgentRunId>;
+  readonly sessionKey: SessionKey;
+  readonly thinkingText: string;
+  readonly skillExecutionCount: number;
+  readonly toolExecutionCount: number;
+  readonly updatedAt: Date;
+}
+interface AgentHistory {
+  readonly runs: ReadonlyArray<AgentRunSummary>;
+  readonly sessions: ReadonlyArray<AgentSessionSummary>;
+  readonly totalEvents: number;
+}
+declare function replayAgentHistory(events: ReadonlyArray<AgentDomainEvent>): AgentHistory;
+//#endregion
+//#region src/domain/agent-transcript.d.ts
+interface AgentTranscript {
+  readonly latestTurn?: AgentTranscriptTurn;
+  readonly sessionKey: SessionKey;
+  readonly turnCount: number;
+  readonly turns: ReadonlyArray<AgentTranscriptTurn>;
+}
+interface AgentTranscriptTurn {
+  readonly acceptedAt?: Date;
+  readonly assistantText: string;
+  readonly cancellationReason?: string;
+  readonly cancelledAt?: Date;
+  readonly completedAt?: Date;
+  readonly errorMessage?: string;
+  readonly failedAt?: Date;
+  readonly failedToolExecutionCount: number;
+  readonly phase: AgentRunPhase;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly thinkingText: string;
+  readonly toolExecutionCount: number;
+  readonly updatedAt: Date;
+  readonly userText: string;
+}
+type AgentTranscriptMessageRole = "assistant" | "user";
+interface AgentTranscriptMessage {
+  readonly content: string;
+  readonly role: AgentTranscriptMessageRole;
+}
+interface AgentConversationMessagesOptions {
+  readonly text: string;
+  readonly transcript?: AgentTranscript;
+}
+declare function replayAgentTranscript(events: ReadonlyArray<AgentDomainEvent>, sessionKey: SessionKey): AgentTranscript;
+declare function createAgentTranscriptTurn(summary: AgentRunSummary & {
+  readonly sessionKey: SessionKey;
+}): AgentTranscriptTurn;
+declare function createAgentTranscriptMessages(transcript: AgentTranscript): ReadonlyArray<AgentTranscriptMessage>;
+declare function createAgentConversationMessages(options: AgentConversationMessagesOptions): ReadonlyArray<AgentTranscriptMessage>;
+//#endregion
+//#region src/domain/agent-invocation.d.ts
+type AgentMemoryInvocationIdentity = AgentMemoryIdentity;
+interface FeishuAgentInvocationOrigin {
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly endpointId: string;
+  readonly kind: "feishu";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+}
+interface LocalCliAgentInvocationOrigin {
+  readonly allowedActorOpenIds: readonly [];
+  readonly endpointId: string;
+  readonly kind: "local-cli";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sourceMessageId: string;
+  readonly tenantKey: "local";
+}
+interface AutomationAgentInvocationOrigin {
+  readonly allowedActorOpenIds: readonly [];
+  readonly automationId: string;
+  readonly endpointId: string;
+  readonly kind: "automation";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sourceMessageId: string;
+  readonly tenantKey: "automation";
+  readonly tickId: string;
+}
+type AgentInvocationOrigin = FeishuAgentInvocationOrigin | LocalCliAgentInvocationOrigin | AutomationAgentInvocationOrigin;
+//#endregion
+//#region src/application/agent/agent-loop.d.ts
+interface AgentLoopInput {
+  readonly abortSignal: AbortSignal;
+  readonly invocation?: AgentInvocationOrigin;
+  readonly messages?: ReadonlyArray<AgentTranscriptMessage>;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+  readonly previousSessionState?: AgentRunState;
+  readonly previousSessionTranscript?: AgentTranscript;
+}
+type AgentLoopEvent = AgentLoopTextDelta | AgentLoopThinkingDelta | AgentLoopModelExecutionStart | AgentLoopModelExecutionEnd | AgentLoopSkillExecutionStart | AgentLoopSkillExecutionEnd | AgentLoopToolExecutionStart | AgentLoopToolExecutionUpdate | AgentLoopToolExecutionEnd;
+type AgentLoopEventLike = AgentLoopEvent | string;
+interface AgentLoopTextDelta {
+  readonly type: "assistant_text_delta";
+  readonly delta: string;
+}
+interface AgentLoopThinkingDelta {
+  readonly type: "assistant_thinking_delta";
+  readonly delta: string;
+}
+interface AgentLoopModelExecutionStart {
+  readonly type: "model_execution_start";
+  readonly api: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly provider: string;
+}
+interface AgentLoopModelExecutionEnd {
+  readonly type: "model_execution_end";
+  readonly api: string;
+  readonly errorMessage?: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly provider: string;
+  readonly responseModel?: string;
+  readonly stopReason: string;
+  readonly usage: AgentModelUsage;
+}
+interface AgentLoopSkillExecutionStart {
+  readonly type: "skill_execution_start";
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+interface AgentLoopSkillExecutionSucceeded {
+  readonly type: "skill_execution_end";
+  readonly contentLength: number;
+  readonly digest: string;
+  readonly isError: false;
+  readonly skillCallId: string;
+  readonly skillId: string;
+  readonly title: string;
+  readonly version: string;
+}
+interface AgentLoopSkillExecutionFailed {
+  readonly type: "skill_execution_end";
+  readonly isError: true;
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+type AgentLoopSkillExecutionEnd = AgentLoopSkillExecutionSucceeded | AgentLoopSkillExecutionFailed;
+interface AgentLoopToolExecutionStart {
+  readonly type: "tool_execution_start";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+}
+interface AgentLoopToolExecutionUpdate {
+  readonly type: "tool_execution_update";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly partialResult: unknown;
+}
+interface AgentLoopToolExecutionEnd {
+  readonly type: "tool_execution_end";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: unknown;
+  readonly isError: boolean;
+}
+interface AgentLoop {
+  run(input: AgentLoopInput): Stream.Stream<AgentLoopEvent, unknown>;
+}
+type AgentLoopCallbackOutput = Iterable<AgentLoopEventLike> | AsyncIterable<AgentLoopEventLike> | Stream.Stream<AgentLoopEventLike, unknown>;
+type AgentLoopCallbackResult = AgentLoopCallbackOutput | PromiseLike<AgentLoopCallbackOutput> | Effect.Effect<AgentLoopCallbackOutput, unknown>;
+type AgentLoopCallback = (input: AgentLoopInput) => AgentLoopCallbackResult;
+interface AsyncIterableAgentLoopOptions {
+  readonly run: (input: AgentLoopInput) => AsyncIterable<AgentLoopEventLike>;
+}
+interface EventAgentLoopOptions {
+  readonly events: ReadonlyArray<AgentLoopEventLike> | ((input: AgentLoopInput) => ReadonlyArray<AgentLoopEventLike> | Promise<ReadonlyArray<AgentLoopEventLike>>);
+}
+interface TextAgentLoopOptions {
+  readonly generate: (input: AgentLoopInput) => Effect.Effect<string, unknown>;
+}
+type TextAgentLoopCallback = (input: AgentLoopInput) => string | Promise<string>;
+type AgentLoopToolExecutionStartOptions = Omit<AgentLoopToolExecutionStart, "type">;
+type AgentLoopToolExecutionUpdateOptions = Omit<AgentLoopToolExecutionUpdate, "type">;
+type AgentLoopToolExecutionEndOptions = Omit<AgentLoopToolExecutionEnd, "type">;
+type AgentLoopModelExecutionStartOptions = Omit<AgentLoopModelExecutionStart, "type">;
+type AgentLoopModelExecutionEndOptions = Omit<AgentLoopModelExecutionEnd, "type">;
+type AgentLoopSkillExecutionStartOptions = Omit<AgentLoopSkillExecutionStart, "type">;
+type AgentLoopSkillExecutionEndOptions = Omit<AgentLoopSkillExecutionSucceeded, "type"> | Omit<AgentLoopSkillExecutionFailed, "type">;
+declare function createAgentLoopTextDelta(delta: string): AgentLoopTextDelta;
+declare function createAgentLoopThinkingDelta(delta: string): AgentLoopThinkingDelta;
+declare function createAgentLoopModelExecutionStart(options: AgentLoopModelExecutionStartOptions): AgentLoopModelExecutionStart;
+declare function createAgentLoopModelExecutionEnd(options: AgentLoopModelExecutionEndOptions): AgentLoopModelExecutionEnd;
+declare function createAgentLoopSkillExecutionStart(options: AgentLoopSkillExecutionStartOptions): AgentLoopSkillExecutionStart;
+declare function createAgentLoopSkillExecutionEnd(options: AgentLoopSkillExecutionEndOptions): AgentLoopSkillExecutionEnd;
+declare function createAgentLoopToolExecutionStart(options: AgentLoopToolExecutionStartOptions): AgentLoopToolExecutionStart;
+declare function createAgentLoopToolExecutionUpdate(options: AgentLoopToolExecutionUpdateOptions): AgentLoopToolExecutionUpdate;
+declare function createAgentLoopToolExecutionEnd(options: AgentLoopToolExecutionEndOptions): AgentLoopToolExecutionEnd;
+declare function createEventAgentLoop(options: EventAgentLoopOptions): AgentLoop;
+declare function createAsyncIterableAgentLoop(options: AsyncIterableAgentLoopOptions): AgentLoop;
+declare function createAgentLoopFromCallback(run: AgentLoopCallback): AgentLoop;
+declare function createTextAgentLoop(options: TextAgentLoopOptions): AgentLoop;
+declare function createTextAgentLoopFromCallback(generate: TextAgentLoopCallback): AgentLoop;
+//#endregion
+export { createAgentTranscriptTurn as $, createAgentLoopModelExecutionStart as A, AssistantThinkingDelta as At, createTextAgentLoop as B, AgentLoopToolExecutionUpdateOptions as C, AgentToolExecutionEnded as Ct, TextAgentLoopOptions as D, AgentTurnCompleted as Dt, TextAgentLoopCallback as E, AgentToolExecutionUpdated as Et, createAgentLoopToolExecutionEnd as F, isAssistantThinkingDeltaEvent as Ft, LocalCliAgentInvocationOrigin as G, AgentInvocationOrigin as H, createAgentLoopToolExecutionStart as I, isTerminalAgentDomainEvent as It, AgentTranscriptMessage as J, AgentConversationMessagesOptions as K, createAgentLoopToolExecutionUpdate as L, createAgentLoopSkillExecutionStart as M, TerminalAgentDomainEvent as Mt, createAgentLoopTextDelta as N, isAgentToolExecutionEvent as Nt, createAgentLoopFromCallback as O, AgentTurnStarted as Ot, createAgentLoopThinkingDelta as P, isAssistantTextDeltaEvent as Pt, createAgentTranscriptMessages as Q, createAsyncIterableAgentLoop as R, AgentLoopToolExecutionUpdate as S, AgentSkillExecutionStarted as St, EventAgentLoopOptions as T, AgentToolExecutionStarted as Tt, AutomationAgentInvocationOrigin as U, createTextAgentLoopFromCallback as V, FeishuAgentInvocationOrigin as W, AgentTranscriptTurn as X, AgentTranscriptMessageRole as Y, createAgentConversationMessages as Z, AgentLoopThinkingDelta as _, AgentRunCancelled as _t, AgentLoopEvent as a, AgentRunPhase as at, AgentLoopToolExecutionStart as b, AgentRunId as bt, AgentLoopModelExecutionEnd as c, evolveAgentRun as ct, AgentLoopModelExecutionStartOptions as d, AgentDomainEvent as dt, replayAgentTranscript as et, AgentLoopSkillExecutionEnd as f, AgentModelExecutionEnded as ft, AgentLoopTextDelta as g, AgentRunAccepted as gt, AgentLoopSkillExecutionStartOptions as h, AgentModelUsage as ht, AgentLoopCallbackResult as i, replayAgentHistory as it, createAgentLoopSkillExecutionEnd as j, SessionKey as jt, createAgentLoopModelExecutionEnd as k, AssistantTextDelta as kt, AgentLoopModelExecutionEndOptions as l, initialAgentRunState as lt, AgentLoopSkillExecutionStart as m, AgentModelExecutionStarted as mt, AgentLoopCallback as n, AgentRunSummary as nt, AgentLoopEventLike as o, AgentRunState as ot, AgentLoopSkillExecutionEndOptions as p, AgentModelExecutionEvent as pt, AgentTranscript as q, AgentLoopCallbackOutput as r, AgentSessionSummary as rt, AgentLoopInput as s, AgentSkillExecutionState as st, AgentLoop as t, AgentHistory as tt, AgentLoopModelExecutionStart as u, isTerminalAgentRunPhase as ut, AgentLoopToolExecutionEnd as v, AgentRunCompleted as vt, AsyncIterableAgentLoopOptions as w, AgentToolExecutionEvent as wt, AgentLoopToolExecutionStartOptions as x, AgentSkillExecutionEnded as xt, AgentLoopToolExecutionEndOptions as y, AgentRunFailed as yt, createEventAgentLoop as z };

package/dist/agent-loop.js

@@ -0,0 +1,118 @@
+import { Effect, Stream } from "effect";
+//#region src/application/agent/agent-loop.ts
+function createAgentLoopTextDelta(delta) {
+	return {
+		delta,
+		type: "assistant_text_delta"
+	};
+}
+function normalizeAgentLoopEvent(event) {
+	return typeof event === "string" ? createAgentLoopTextDelta(event) : event;
+}
+function createAgentLoopThinkingDelta(delta) {
+	return {
+		delta,
+		type: "assistant_thinking_delta"
+	};
+}
+function createAgentLoopModelExecutionStart(options) {
+	return {
+		...options,
+		type: "model_execution_start"
+	};
+}
+function createAgentLoopModelExecutionEnd(options) {
+	return {
+		...options,
+		type: "model_execution_end"
+	};
+}
+function createAgentLoopSkillExecutionStart(options) {
+	return {
+		...options,
+		type: "skill_execution_start"
+	};
+}
+function createAgentLoopSkillExecutionEnd(options) {
+	return {
+		...options,
+		type: "skill_execution_end"
+	};
+}
+function createAgentLoopToolExecutionStart(options) {
+	return {
+		input: options.input,
+		toolCallId: options.toolCallId,
+		toolName: options.toolName,
+		type: "tool_execution_start"
+	};
+}
+function createAgentLoopToolExecutionUpdate(options) {
+	return {
+		input: options.input,
+		partialResult: options.partialResult,
+		toolCallId: options.toolCallId,
+		toolName: options.toolName,
+		type: "tool_execution_update"
+	};
+}
+function createAgentLoopToolExecutionEnd(options) {
+	return {
+		isError: options.isError,
+		result: options.result,
+		toolCallId: options.toolCallId,
+		toolName: options.toolName,
+		type: "tool_execution_end"
+	};
+}
+function createEventAgentLoop(options) {
+	return { run: (input) => {
+		const events = typeof options.events === "function" ? options.events(input) : options.events;
+		if (isPromiseLike(events)) return Stream.fromEffect(Effect.tryPromise({
+			try: () => events,
+			catch: (cause) => cause
+		})).pipe(Stream.flatMap((resolvedEvents) => Stream.fromIterable(resolvedEvents)), Stream.map(normalizeAgentLoopEvent));
+		return Stream.fromIterable(events).pipe(Stream.map(normalizeAgentLoopEvent));
+	} };
+}
+function createAsyncIterableAgentLoop(options) {
+	return { run: (input) => Stream.fromAsyncIterable(options.run(input), (error) => error).pipe(Stream.map(normalizeAgentLoopEvent)) };
+}
+function createAgentLoopFromCallback(run) {
+	return { run: (input) => Stream.fromEffect(Effect.try({
+		try: () => run(input),
+		catch: (cause) => cause
+	})).pipe(Stream.flatMap(streamFromAgentLoopCallbackResult)) };
+}
+function createTextAgentLoop(options) {
+	return { run: (input) => Stream.fromEffect(options.generate(input)).pipe(Stream.map((delta) => createAgentLoopTextDelta(delta))) };
+}
+function createTextAgentLoopFromCallback(generate) {
+	return createTextAgentLoop({ generate: (input) => Effect.tryPromise({
+		try: async () => generate(input),
+		catch: (cause) => cause
+	}) });
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function streamFromAgentLoopCallbackResult(result) {
+	if (Effect.isEffect(result)) return Stream.fromEffect(result).pipe(Stream.flatMap(streamFromAgentLoopCallbackOutput));
+	if (isPromiseLike(result)) return Stream.fromEffect(Effect.tryPromise({
+		try: () => Promise.resolve(result),
+		catch: (cause) => cause
+	})).pipe(Stream.flatMap(streamFromAgentLoopCallbackOutput));
+	return streamFromAgentLoopCallbackOutput(result);
+}
+function streamFromAgentLoopCallbackOutput(output) {
+	if (isEffectStream(output)) return output.pipe(Stream.map(normalizeAgentLoopEvent));
+	return (isAsyncIterable(output) ? Stream.fromAsyncIterable(output, (error) => error) : Stream.fromIterable(output)).pipe(Stream.map(normalizeAgentLoopEvent));
+}
+function isAsyncIterable(value) {
+	return Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function isEffectStream(value) {
+	return typeof value === "object" && value !== null && Stream.StreamTypeId in value;
+}
+//#endregion
+export { createAgentLoopSkillExecutionStart as a, createAgentLoopToolExecutionEnd as c, createAsyncIterableAgentLoop as d, createEventAgentLoop as f, createAgentLoopSkillExecutionEnd as i, createAgentLoopToolExecutionStart as l, createTextAgentLoopFromCallback as m, createAgentLoopModelExecutionEnd as n, createAgentLoopTextDelta as o, createTextAgentLoop as p, createAgentLoopModelExecutionStart as r, createAgentLoopThinkingDelta as s, createAgentLoopFromCallback as t, createAgentLoopToolExecutionUpdate as u };

package/dist/agent-memory.d.ts

@@ -0,0 +1,98 @@
+//#region src/domain/agent-memory.d.ts
+declare const MEMORY_SCOPES: readonly ["conversation", "agent-private", "shared-user-profile"];
+declare const RIVUS_MEMORY_TOOL_ID = "memory";
+declare const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
+declare const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
+type MemoryScope = (typeof MEMORY_SCOPES)[number];
+type MemoryState = "proposed" | "confirmed" | "superseded" | "tombstoned";
+type MemoryInvocationAudience = "group" | "private";
+interface AgentMemoryIdentity {
+  readonly audience: MemoryInvocationAudience;
+  readonly conversationId?: string;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface AgentMemoryAuthority extends AgentMemoryIdentity {
+  readonly scopes: ReadonlyArray<MemoryScope>;
+}
+interface MemoryBinding {
+  readonly agentId: string;
+  readonly conversationId?: string;
+  readonly scope: MemoryScope;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface MemoryRecord {
+  readonly content: string;
+  readonly conversationSafe: boolean;
+  readonly id: string;
+  readonly revision: number;
+  readonly scope: MemoryScope;
+  readonly state: MemoryState;
+  readonly tombstoneReason?: string;
+}
+interface AgentMemorySnapshot {
+  readonly binding: MemoryBinding;
+  readonly record: MemoryRecord;
+}
+declare function createMemoryNamespace(binding: MemoryBinding): string;
+declare function restrictMemoryScopesForAudience(scopes: ReadonlyArray<MemoryScope>, audience: MemoryInvocationAudience): ReadonlyArray<MemoryScope>;
+declare function createRivusMemoryToolContract(scopes: ReadonlyArray<MemoryScope>): Readonly<{
+  description: "Search and read Memory inside Host-bound scopes; propose or request forgetting only in writable private scopes.";
+  digest: "sha256:rivus-memory-v3";
+  id: "memory";
+  idempotency: "required";
+  inputSchema: Readonly<{
+    additionalProperties: false;
+    properties: {
+      scope?: {
+        description: string;
+        enum: ("conversation" | "agent-private" | "shared-user-profile")[];
+        type: string;
+      };
+      command: {
+        description: string;
+        enum: string[];
+        type: string;
+      };
+      id: {
+        description: string;
+        minLength: number;
+        type: string;
+      };
+      input: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          content: {
+            minLength: number;
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      query: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          query: {
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      reason: {
+        description: string;
+        type: string;
+      };
+    };
+    required: string[];
+    type: "object";
+  }>;
+  risk: "mutate";
+  version: "1.0.0";
+}>;
+//#endregion
+export { MemoryBinding as a, MemoryScope as c, RIVUS_MEMORY_TOOL_PLUGIN_ID as d, RIVUS_MEMORY_TOOL_VERSION as f, restrictMemoryScopesForAudience as h, MEMORY_SCOPES as i, MemoryState as l, createRivusMemoryToolContract as m, AgentMemoryIdentity as n, MemoryInvocationAudience as o, createMemoryNamespace as p, AgentMemorySnapshot as r, MemoryRecord as s, AgentMemoryAuthority as t, RIVUS_MEMORY_TOOL_ID as u };

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { C as resolveNodeRivusPluginModulePath, D as resolveFeishuEndpointCredentials, O as loadMergedLocalEnvFile, T as loadRivusDeploymentManifest, j as validateRivusDeploymentManifest, t as runRivusDaemonCli } from "./rivus-daemon-cli.js";
+import { Effect } from "effect";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { Effect } from "effect";
 import { lstat, mkdir, readFile, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 //#region src/infrastructure/project/rivus-project-doctor.ts
 const REQUIRED_FILES = Object.freeze([
@@ -153,6 +153,7 @@ function isMissingPath$1(error) {
 //#region src/infrastructure/project/rivus-project-initializer.ts
 const TEMPLATE_FILES = Object.freeze({
 	"current-weather.mjs": "current-weather.mjs",
+	"https-response-reader.mjs": "https-response-reader.mjs",
 	"rivus-agents.plugin.mjs": "rivus-starter.plugin.mjs",
 	"rivus.bootstrap.ts": "pi-feishu-deployment.bootstrap.ts"
 });
@@ -364,7 +365,10 @@ function environmentTemplate() {
 }
 function systemdService(directory, nodeExecutable) {
 	const cli = join(directory, "node_modules", "@rivus", "agent", "dist", "cli.js");
-	return `[Unit]\nDescription=Rivus Agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nWorkingDirectory=${systemdQuote(directory)}\nExecStart=${systemdQuote(nodeExecutable)} ${systemdQuote(cli)} --env-file .env.local --bootstrap ./rivus.bootstrap.ts --manifest ./rivus.config.json\nRestart=on-failure\nRestartSec=5\nEnvironment=NODE_ENV=production\n\n[Install]\nWantedBy=default.target\n`;
+	return `[Unit]\nDescription=Rivus Agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nWorkingDirectory=${systemdPath(directory)}\nExecStart=${systemdQuote(nodeExecutable)} ${systemdQuote(cli)} --env-file .env.local --bootstrap ./rivus.bootstrap.ts --manifest ./rivus.config.json\nRestart=on-failure\nRestartSec=5\nEnvironment=NODE_ENV=production\n\n[Install]\nWantedBy=default.target\n`;
+}
+function systemdPath(value) {
+	return value.replaceAll("%", "%%");
 }
 function systemdQuote(value) {
 	return `"${value.replace(/%/g, "%%").replace(/\$/g, () => "$$").replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;