@rivus/agent 0.16.2 → 0.16.6

package/dist/chunks/agent-loop.js

@@ -1,158 +0,0 @@
-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 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 { 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 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 { createAgentLoopToolExecutionStart as _, createTextAgentLoopFromCallback as a, 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, createAgentLoopTurnStart as y };

package/dist/chunks/background-session-authority.js

@@ -1,230 +0,0 @@
-//#region src/core/application/background-session/authority/background-session-identity.ts
-const BACKGROUND_SESSION_SESSION_KEY_PREFIX = "background";
-function createBackgroundSessionKey(sessionId) {
-	return `${BACKGROUND_SESSION_SESSION_KEY_PREFIX}:${sessionId}`;
-}
-function createBackgroundSessionStepSourceMessageId(sessionId, stepCount) {
-	return `bg:${sessionId}:step:${stepCount}`;
-}
-//#endregion
-//#region src/core/application/background-session/authority/background-session-authority.ts
-const BACKGROUND_SESSION_TOOL_IDS = [
-	"background.start",
-	"background.wait",
-	"background.list",
-	"background.status",
-	"background.send",
-	"background.stop"
-];
-const BACKGROUND_SESSION_START_TOOL_ID = "background.start";
-const BACKGROUND_SESSION_TOOL_PLUGIN_ID = "rivus-core";
-const BACKGROUND_SESSION_TOOL_VERSION = "1.0.0";
-const BACKGROUND_SESSION_TOOL_DIGESTS = {
-	"background.list": "sha256:c935847595e406d55ca889875b38db66bb1d4d7a34d7b0fb2b85aecf9478c149",
-	"background.send": "sha256:b7ed492e45c794dc286f7f66aca8d046082d11dfdc8787eaf5604765b68a7735",
-	"background.start": "sha256:773690e47f6eef1f1b289216e94cf98e548382d6cffb7b2f034c3ed0635dfcbb",
-	"background.status": "sha256:6aaa328d6cd97d8755a63abbe97286f1061fd2f238f68b1e576ed9a1d2b7e6b1",
-	"background.stop": "sha256:aa0bfdf0c9394058bfcbd8662e7bedd59055f9ddad51c2a1bb61666bd67ebfcb",
-	"background.wait": "sha256:4a0dc80e933ad3c99b6d58421ac9ef733157e39e0ac9b6ad87ac6e65ceaedaab"
-};
-function createBackgroundSessionToolContracts() {
-	return [
-		Object.freeze({
-			description: "Start a background agent session. Use when the request must wait for external changes, observe over time, or continue working after the foreground run ends. Returns a stable session id immediately; the foreground response can finish here. The detached session continues with the granted Skills, CLI, Tools, Project Space, and Memory of this agent.",
-			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.start"],
-			id: "background.start",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					displayName: {
-						type: "string",
-						maxLength: 200
-					},
-					prompt: {
-						type: "string",
-						minLength: 1,
-						maxLength: 2e4
-					}
-				}),
-				required: ["prompt"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Pause the current background session durably and end the current step. Call with delayMs to resume after a delay, with until to resume at an absolute ISO time, or with neither to wait for user input. After this call no further tool calls are accepted in this step.",
-			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.wait"],
-			id: "background.wait",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					delayMs: {
-						type: "integer",
-						minimum: 1e3,
-						maximum: 864e5
-					},
-					reason: {
-						type: "string",
-						maxLength: 500
-					},
-					until: {
-						type: "string",
-						maxLength: 64
-					}
-				}),
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "List background sessions owned by this conversation, newest first. Optionally filter by phase and limit the number of results.",
-			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.list"],
-			id: "background.list",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					limit: {
-						type: "integer",
-						minimum: 1,
-						maximum: 50
-					},
-					phase: {
-						enum: [
-							"queued",
-							"running",
-							"waiting",
-							"input-required",
-							"stopping",
-							"stopped",
-							"completed",
-							"failed",
-							"reconciliation-required"
-						],
-						type: "string"
-					}
-				}),
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "observe",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Return the current phase, step counts, wake time, and result of one background session owned by this conversation.",
-			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.status"],
-			id: "background.status",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({ sessionId: {
-					type: "string",
-					minLength: 1,
-					maxLength: 200
-				} }),
-				required: ["sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "observe",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Send new user instruction text to a background session owned by this conversation and wake it. The input is delivered exactly once in the next step.",
-			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.send"],
-			id: "background.send",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					message: {
-						type: "string",
-						minLength: 1,
-						maxLength: 2e4
-					},
-					sessionId: {
-						type: "string",
-						minLength: 1,
-						maxLength: 200
-					}
-				}),
-				required: ["message", "sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Stop a background session owned by this conversation. Persists the cancellation, aborts the active step and its owned process, and delivers a terminal notice.",
-			digest: BACKGROUND_SESSION_TOOL_DIGESTS["background.stop"],
-			id: "background.stop",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					reason: {
-						type: "string",
-						maxLength: 500
-					},
-					sessionId: {
-						type: "string",
-						minLength: 1,
-						maxLength: 200
-					}
-				}),
-				required: ["sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		})
-	];
-}
-function backgroundSessionToolIds() {
-	return [...BACKGROUND_SESSION_TOOL_IDS];
-}
-function isBackgroundSessionToolId(toolId) {
-	return BACKGROUND_SESSION_TOOL_IDS.includes(toolId);
-}
-function extendBackgroundSessionDefinition(definition, digest) {
-	const contracts = createBackgroundSessionToolContracts();
-	const existingIds = new Set(definition.tools.map(({ id }) => id));
-	const additions = contracts.filter((contract) => !existingIds.has(contract.id));
-	const toolGrantSet = Object.freeze({
-		revision: grantRevision(digest, definition.toolGrantSet.revision, additions.map(({ id }) => id)),
-		toolIds: Object.freeze([...definition.toolGrantSet.toolIds, ...additions.map(({ id }) => id)].sort())
-	});
-	return Object.freeze({
-		...definition,
-		tools: Object.freeze([...definition.tools, ...additions]),
-		toolGrantSet
-	});
-}
-function narrowBackgroundSessionDefinition(definition, digest) {
-	const childToolIds = definition.toolGrantSet.toolIds.filter((id) => id !== BACKGROUND_SESSION_START_TOOL_ID);
-	const toolGrantSet = Object.freeze({
-		revision: grantRevision(digest, definition.toolGrantSet.revision, childToolIds),
-		toolIds: Object.freeze(childToolIds)
-	});
-	return Object.freeze({
-		...definition,
-		tools: Object.freeze(definition.tools.filter(({ id }) => id !== BACKGROUND_SESSION_START_TOOL_ID)),
-		toolGrantSet
-	});
-}
-function grantRevision(digest, parentRevision, toolIds) {
-	return digest(JSON.stringify({
-		parentRevision,
-		toolIds: [...toolIds].sort()
-	}));
-}
-//#endregion
-export { backgroundSessionToolIds as a, isBackgroundSessionToolId as c, createBackgroundSessionKey as d, createBackgroundSessionStepSourceMessageId as f, BACKGROUND_SESSION_TOOL_VERSION as i, narrowBackgroundSessionDefinition as l, BACKGROUND_SESSION_TOOL_IDS as n, createBackgroundSessionToolContracts as o, BACKGROUND_SESSION_TOOL_PLUGIN_ID as r, extendBackgroundSessionDefinition as s, BACKGROUND_SESSION_START_TOOL_ID as t, BACKGROUND_SESSION_SESSION_KEY_PREFIX as u };

package/dist/chunks/background-session-control-input.js

@@ -1,51 +0,0 @@
-import { randomUUID } from "node:crypto";
-//#region src/platform/identity/random-id.ts
-function createRandomId() {
-	return randomUUID();
-}
-//#endregion
-//#region src/core/application/background-session/control/background-session-control-input.ts
-function readBackgroundSessionObject(input, allowed, error) {
-	if (input === null || typeof input !== "object" || Array.isArray(input)) throw error("background tool input must be an object");
-	const record = input;
-	const unknown = Object.keys(record).find((key) => !allowed.includes(key));
-	if (unknown) throw error(`field is not allowed: ${unknown}`);
-	return record;
-}
-function readBackgroundSessionString(value, name, error) {
-	if (typeof value !== "string" || value.trim() === "") throw error(`${name} must be a non-empty string`);
-	return value;
-}
-function readBackgroundSessionInteger(value, name, error) {
-	if (!Number.isSafeInteger(value) || value < 1) throw error(`${name} must be a positive integer`);
-	return value;
-}
-function readBackgroundSessionPhase(value, error) {
-	const phases = [
-		"queued",
-		"running",
-		"waiting",
-		"input-required",
-		"stopping",
-		"stopped",
-		"completed",
-		"failed",
-		"reconciliation-required"
-	];
-	if (typeof value !== "string" || !phases.includes(value)) throw error(`phase must be one of ${phases.join(", ")}`);
-	return value;
-}
-function readBackgroundSessionWaitInput(input, error) {
-	const { delayMs, reason, until } = readBackgroundSessionObject(input, [
-		"delayMs",
-		"reason",
-		"until"
-	], error);
-	const args = {};
-	if (delayMs !== void 0) args.delayMs = readBackgroundSessionInteger(delayMs, "delayMs", error);
-	if (reason !== void 0) args.reason = readBackgroundSessionString(reason, "reason", error);
-	if (until !== void 0) args.until = readBackgroundSessionString(until, "until", error);
-	return args;
-}
-//#endregion
-export { readBackgroundSessionWaitInput as a, readBackgroundSessionString as i, readBackgroundSessionObject as n, createRandomId as o, readBackgroundSessionPhase as r, readBackgroundSessionInteger as t };