@rivus/runtime 0.16.2

package/dist/chunks/agent-loop.d.ts

@@ -0,0 +1,481 @@
+import { Effect, Stream } from "effect";
+
+//#region src/core/application/agent-execution/contracts/agent-domain-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/core/application/agent-execution/contracts/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";
+}
+//#endregion
+//#region src/core/application/agent-execution/history/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/core/application/agent-execution/transcript/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/core/application/agent-execution/invocation/agent-invocation.d.ts
+interface AgentMemoryInvocationIdentity {
+  readonly audience: "group" | "private";
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+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;
+}
+interface BackgroundSessionAgentInvocationOrigin {
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly conversationId?: string;
+  readonly endpointId: string;
+  readonly kind: "background-session";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sessionId: string;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+}
+type AgentInvocationOrigin = FeishuAgentInvocationOrigin | LocalCliAgentInvocationOrigin | AutomationAgentInvocationOrigin | BackgroundSessionAgentInvocationOrigin;
+//#endregion
+//#region src/core/application/agent-execution/loop/agent-loop.d.ts
+interface AgentLoopInput$1 {
+  readonly abortSignal: AbortSignal;
+  readonly invocation?: AgentInvocationOrigin;
+  readonly messages?: ReadonlyArray<AgentTranscriptMessage>;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  /** Optional mailbox for user steering while the run is active. */
+  readonly steering?: AgentSteeringChannel$1;
+  readonly text: string;
+  readonly previousSessionState?: AgentRunState;
+  readonly previousSessionTranscript?: AgentTranscript;
+}
+interface AgentSteeringChannel$1 {
+  next(): Effect.Effect<string>;
+  /** Seal admission at provider completion and return accepted messages still waiting. */
+  close?(): Effect.Effect<readonly string[]>;
+}
+type AgentLoopEvent = AgentLoopTurnStart | AgentLoopTextDelta | AgentLoopThinkingDelta | AgentLoopModelExecutionStart | AgentLoopModelExecutionEnd | AgentLoopSkillExecutionStart | AgentLoopSkillExecutionEnd | AgentLoopToolExecutionStart | AgentLoopToolExecutionUpdate | AgentLoopToolExecutionEnd;
+type AgentLoopEventLike = AgentLoopEvent | string;
+interface AgentLoopTextDelta {
+  readonly type: "assistant_text_delta";
+  readonly delta: string;
+}
+interface AgentLoopTurnStart {
+  readonly type: "turn_start";
+}
+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$1 {
+  run(input: AgentLoopInput$1): Stream.Stream<AgentLoopEvent, unknown>;
+  /** Provider adapters opt in only when they can consume steering safely. */
+  readonly supportsSteering?: boolean;
+}
+interface TextAgentLoopOptions$1 {
+  readonly generate: (input: AgentLoopInput$1) => Effect.Effect<string, unknown>;
+}
+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 createAgentLoopTurnStart(): AgentLoopTurnStart;
+declare function normalizeAgentLoopEvent(event: AgentLoopEventLike): AgentLoopEvent;
+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;
+interface EventAgentLoopOptions$1 {
+  readonly events: ReadonlyArray<AgentLoopEventLike> | ((input: AgentLoopInput$1) => ReadonlyArray<AgentLoopEventLike> | Promise<ReadonlyArray<AgentLoopEventLike>>);
+}
+declare function createEventAgentLoop$1(options: EventAgentLoopOptions$1): AgentLoop$1;
+declare function createTextAgentLoop$1(options: TextAgentLoopOptions$1): AgentLoop$1;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/loop/agent-loop.d.ts
+interface AgentLoopInput {
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+  readonly abortSignal: AbortSignal;
+  readonly previousSessionState?: AgentRunState;
+  readonly previousSessionTranscript?: AgentTranscript;
+  readonly messages?: ReadonlyArray<AgentTranscriptMessage>;
+  readonly invocation?: AgentInvocationOrigin;
+  /** Optional mailbox for user steering while the run is active. */
+  readonly steering?: AgentSteeringChannel;
+}
+interface AgentSteeringChannel {
+  next(signal?: AbortSignal): Promise<string>;
+  close?(): Promise<readonly string[]>;
+}
+interface AgentLoop {
+  run(input: AgentLoopInput): Stream.Stream<AgentLoopEvent, unknown>;
+  /** Provider adapters opt in only when they can consume steering safely. */
+  readonly supportsSteering?: boolean;
+}
+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>>);
+}
+type TextAgentLoopCallback = (input: AgentLoopInput) => string | Promise<string>;
+interface TextAgentLoopOptions {
+  readonly generate: (input: AgentLoopInput) => Effect.Effect<string, unknown>;
+}
+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;
+declare function toEffectAgentLoop(loop: AgentLoop): AgentLoop$1;
+declare function fromEffectAgentLoop(loop: AgentLoop$1): AgentLoop;
+declare function toEffectAgentLoopInput(input: AgentLoopInput): AgentLoopInput$1;
+declare function toCompatibilityAgentLoopInput(input: AgentLoopInput$1): AgentLoopInput;
+//#endregion
+export { createAgentLoopTurnStart as $, AgentLoopSkillExecutionStart as A, AgentModelUsage as At, AgentLoopTurnStart as B, AgentToolExecutionUpdated as Bt, AgentLoopInput$1 as C, AgentRunState as Ct, AgentLoopModelExecutionStartOptions as D, AgentModelExecutionEnded as Dt, AgentLoopModelExecutionStart as E, AgentDomainEvent as Et, AgentLoopToolExecutionEndOptions as F, AgentSkillExecutionEnded as Ft, createAgentLoopModelExecutionStart as G, SessionKey as Gt, EventAgentLoopOptions$1 as H, AgentTurnStarted as Ht, AgentLoopToolExecutionStart as I, AgentSkillExecutionStarted as It, createAgentLoopTextDelta as J, isAssistantTextDeltaEvent as Jt, createAgentLoopSkillExecutionEnd as K, TerminalAgentDomainEvent as Kt, AgentLoopToolExecutionStartOptions as L, AgentToolExecutionEnded as Lt, AgentLoopTextDelta as M, AgentRunCompleted as Mt, AgentLoopThinkingDelta as N, AgentRunFailed as Nt, AgentLoopSkillExecutionEnd as O, AgentModelExecutionEvent as Ot, AgentLoopToolExecutionEnd as P, AgentRunId as Pt, createAgentLoopToolExecutionUpdate as Q, AgentLoopToolExecutionUpdate as R, AgentToolExecutionEvent as Rt, AgentLoopEventLike as S, AgentRunPhase as St, AgentLoopModelExecutionEndOptions as T, AgentToolExecutionState as Tt, TextAgentLoopOptions$1 as U, AssistantTextDelta as Ut, AgentSteeringChannel$1 as V, AgentTurnCompleted as Vt, createAgentLoopModelExecutionEnd as W, AssistantThinkingDelta as Wt, createAgentLoopToolExecutionEnd as X, isTerminalAgentDomainEvent as Xt, createAgentLoopThinkingDelta as Y, isAssistantThinkingDeltaEvent as Yt, createAgentLoopToolExecutionStart as Z, toCompatibilityAgentLoopInput as _, replayAgentTranscript as _t, AgentLoopInput as a, AutomationAgentInvocationOrigin as at, AgentLoop$1 as b, AgentSessionSummary as bt, EventAgentLoopOptions as c, LocalCliAgentInvocationOrigin as ct, createAgentLoopFromCallback as d, AgentTranscriptMessage as dt, createEventAgentLoop$1 as et, createAsyncIterableAgentLoop as f, AgentTranscriptMessageRole as ft, fromEffectAgentLoop as g, createAgentTranscriptTurn as gt, createTextAgentLoopFromCallback as h, createAgentTranscriptMessages as ht, AgentLoopCallbackResult as i, AgentMemoryInvocationIdentity as it, AgentLoopSkillExecutionStartOptions as j, AgentRunAccepted as jt, AgentLoopSkillExecutionEndOptions as k, AgentModelExecutionStarted as kt, TextAgentLoopCallback as l, AgentConversationMessagesOptions as lt, createTextAgentLoop as m, createAgentConversationMessages as mt, AgentLoopCallback as n, normalizeAgentLoopEvent as nt, AgentSteeringChannel as o, BackgroundSessionAgentInvocationOrigin as ot, createEventAgentLoop as p, AgentTranscriptTurn as pt, createAgentLoopSkillExecutionStart as q, isAgentToolExecutionEvent as qt, AgentLoopCallbackOutput as r, AgentInvocationOrigin as rt, AsyncIterableAgentLoopOptions as s, FeishuAgentInvocationOrigin as st, AgentLoop as t, createTextAgentLoop$1 as tt, TextAgentLoopOptions as u, AgentTranscript as ut, toEffectAgentLoop as v, AgentHistory as vt, AgentLoopModelExecutionEnd as w, AgentSkillExecutionState as wt, AgentLoopEvent as x, replayAgentHistory as xt, toEffectAgentLoopInput as y, AgentRunSummary as yt, AgentLoopToolExecutionUpdateOptions as z, AgentToolExecutionStarted as zt };

package/dist/chunks/agent-loop.js

@@ -0,0 +1,164 @@
+import { Effect, Stream } from "effect";
+//#region src/core/application/agent-execution/loop/agent-loop.ts
+function createAgentLoopTextDelta(delta) {
+	return {
+		delta,
+		type: "assistant_text_delta"
+	};
+}
+function createAgentLoopTurnStart() {
+	return { type: "turn_start" };
+}
+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 isPromiseLike$1(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function createEventAgentLoop$1(options) {
+	return { run: (input) => {
+		const events = typeof options.events === "function" ? options.events(input) : options.events;
+		if (isPromiseLike$1(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 createTextAgentLoop$1(options) {
+	return { run: (input) => Stream.fromEffect(options.generate(input)).pipe(Stream.map((delta) => createAgentLoopTextDelta(delta))) };
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/loop/agent-loop.ts
+function createEventAgentLoop(options) {
+	return fromEffectAgentLoop(createEventAgentLoop$1({ events: (input) => typeof options.events === "function" ? options.events(toCompatibilityAgentLoopInput(input)) : options.events }));
+}
+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 fromEffectAgentLoop(createTextAgentLoop$1({ generate: (input) => options.generate(toCompatibilityAgentLoopInput(input)) }));
+}
+function createTextAgentLoopFromCallback(generate) {
+	return createTextAgentLoop({ generate: (input) => Effect.tryPromise({
+		try: async () => generate(input),
+		catch: (cause) => cause
+	}) });
+}
+function toEffectAgentLoop(loop) {
+	return {
+		run: (input) => loop.run(toCompatibilityAgentLoopInput(input)),
+		...loop.supportsSteering ? { supportsSteering: true } : {}
+	};
+}
+function fromEffectAgentLoop(loop) {
+	return {
+		run: (input) => loop.run(toEffectAgentLoopInput(input)),
+		...loop.supportsSteering ? { supportsSteering: true } : {}
+	};
+}
+function toEffectAgentLoopInput(input) {
+	const { steering, ...rest } = input;
+	return {
+		...rest,
+		...steering ? { steering: {
+			...steering.close ? { close: () => Effect.promise(() => steering.close()) } : {},
+			next: () => Effect.promise((signal) => steering.next(signal))
+		} } : {}
+	};
+}
+function toCompatibilityAgentLoopInput(input) {
+	const { steering, ...rest } = input;
+	return {
+		...rest,
+		...steering ? { steering: {
+			...steering.close ? { close: () => Effect.runPromise(steering.close()) } : {},
+			next: (signal) => Effect.runPromise(steering.next(), { signal })
+		} } : {}
+	};
+}
+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 { normalizeAgentLoopEvent as S, createAgentLoopToolExecutionStart as _, createTextAgentLoopFromCallback as a, createEventAgentLoop$1 as b, toEffectAgentLoop as c, createAgentLoopModelExecutionStart as d, createAgentLoopSkillExecutionEnd as f, createAgentLoopToolExecutionEnd as g, createAgentLoopThinkingDelta as h, createTextAgentLoop as i, toEffectAgentLoopInput as l, createAgentLoopTextDelta as m, createAsyncIterableAgentLoop as n, fromEffectAgentLoop as o, createAgentLoopSkillExecutionStart as p, createEventAgentLoop as r, toCompatibilityAgentLoopInput as s, createAgentLoopFromCallback as t, createAgentLoopModelExecutionEnd as u, createAgentLoopToolExecutionUpdate as v, createTextAgentLoop$1 as x, createAgentLoopTurnStart as y };