@rivus/agent 0.14.3 → 0.15.0

package/dist/chunks/rivus-model-management-wire.js

@@ -0,0 +1,344 @@
+//#region src/adapters/cli/model/rivus-model-cli-protocol.ts
+const RIVUS_MODEL_CLI_USAGE = `Usage:
+  rivus model status --json [--request <id>] [--verbose]
+  rivus model set --model <provider/model> --expected-revision <n> --request <id> --json [--verbose]
+  rivus model rollback --expected-revision <n> --request <id> --json [--verbose]
+
+Commands:
+  status    Read the effective and persistent model selection
+  set       Submit one authorized model change
+  rollback  Submit one authorized change to the previous model
+
+All command results are JSON. A successful set or rollback call means the request
+was accepted; query status by request id for the final outcome.
+`;
+function parseRivusModelCliArguments(argv) {
+	if (argv.includes("--help") || argv.includes("-h")) return { help: true };
+	const operation = argv[0];
+	if (operation !== "status" && operation !== "set" && operation !== "rollback") return { error: "model requires one of status, set, rollback" };
+	let expectedRevision;
+	let json = false;
+	let model;
+	let requestId;
+	let verbose = false;
+	for (let index = 1; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (argument === "--json") {
+			if (json) return { error: "--json may only be provided once" };
+			json = true;
+			continue;
+		}
+		if (argument === "--verbose") {
+			if (verbose) return { error: "--verbose may only be provided once" };
+			verbose = true;
+			continue;
+		}
+		if (argument === "--request") {
+			if (requestId !== void 0) return { error: "--request may only be provided once" };
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) return { error: "--request requires an id" };
+			requestId = value;
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("--request=")) {
+			if (requestId !== void 0) return { error: "--request may only be provided once" };
+			requestId = argument.slice(10);
+			if (!requestId) return { error: "--request requires an id" };
+			continue;
+		}
+		if (argument === "--expected-revision") {
+			if (expectedRevision !== void 0) return { error: "--expected-revision may only be provided once" };
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) return { error: "--expected-revision requires a non-negative integer" };
+			const parsed = parseRevision(value);
+			if (parsed === void 0) return { error: "--expected-revision requires a non-negative integer" };
+			expectedRevision = parsed;
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("--expected-revision=")) {
+			if (expectedRevision !== void 0) return { error: "--expected-revision may only be provided once" };
+			const parsed = parseRevision(argument.slice(20));
+			if (parsed === void 0) return { error: "--expected-revision requires a non-negative integer" };
+			expectedRevision = parsed;
+			continue;
+		}
+		if (argument === "--model") {
+			if (model !== void 0) return { error: "--model may only be provided once" };
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) return { error: "--model requires provider/model" };
+			if (!isModelReference(value)) return { error: "--model must be provider/model" };
+			model = value;
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("--model=")) {
+			if (model !== void 0) return { error: "--model may only be provided once" };
+			const value = argument.slice(8);
+			if (!isModelReference(value)) return { error: "--model must be provider/model" };
+			model = value;
+			continue;
+		}
+		return { error: `Unknown model option: ${argument}` };
+	}
+	if (!json) return { error: "model commands require --json" };
+	if (operation === "status") {
+		if (model !== void 0) return { error: "status does not accept --model" };
+		if (expectedRevision !== void 0) return { error: "status does not accept --expected-revision" };
+		return {
+			json: true,
+			operation,
+			...requestId !== void 0 ? { requestId } : {},
+			...verbose ? { verbose: true } : {}
+		};
+	}
+	if (requestId === void 0) return { error: "--request is required for model changes" };
+	if (expectedRevision === void 0) return { error: "--expected-revision is required for model changes" };
+	if (operation === "set" && model === void 0) return { error: "--model is required for model set" };
+	if (operation === "rollback" && model !== void 0) return { error: "rollback does not accept --model" };
+	return operation === "set" ? {
+		expectedRevision,
+		json: true,
+		model,
+		operation,
+		requestId,
+		...verbose ? { verbose: true } : {}
+	} : {
+		expectedRevision,
+		json: true,
+		operation,
+		requestId,
+		...verbose ? { verbose: true } : {}
+	};
+}
+function renderRivusModelCliHelp() {
+	return RIVUS_MODEL_CLI_USAGE;
+}
+function renderRivusModelCliArgumentError(error) {
+	return `${error}\n\n${RIVUS_MODEL_CLI_USAGE}`;
+}
+function isModelReference(value) {
+	return /^[^/\s]+\/[^/\s]+$/.test(value);
+}
+function parseRevision(value) {
+	if (!/^\d+$/.test(value)) return void 0;
+	const revision = Number(value);
+	return Number.isSafeInteger(revision) ? revision : void 0;
+}
+//#endregion
+//#region src/adapters/cli/model/rivus-model-management-wire.ts
+function createRivusModelManagementWireRequest(command, env) {
+	const context = optionalString(env.RIVUS_MODEL_CONTEXT);
+	return {
+		...command,
+		...context ? { context } : {}
+	};
+}
+function parseRivusModelManagementWireRequest(value) {
+	if (!isRecord(value)) throw new Error("model request must be a JSON object");
+	const operation = value.operation;
+	if (operation !== "status" && operation !== "set" && operation !== "rollback") throw new Error("model request operation is invalid");
+	const context = optionalString(value.context);
+	const requestId = optionalString(value.requestId);
+	const verbose = value.verbose === true ? true : void 0;
+	if (operation === "status") {
+		if (value.json !== true) throw new Error("model request must require JSON output");
+		return {
+			json: true,
+			operation,
+			...context ? { context } : {},
+			...requestId ? { requestId } : {},
+			...verbose ? { verbose: true } : {}
+		};
+	}
+	const expectedRevision = value.expectedRevision;
+	if (value.json !== true || typeof expectedRevision !== "number" || !Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new Error("model request has an invalid expected revision or output mode");
+	if (!requestId) throw new Error("model request requires a request id");
+	if (operation === "set") {
+		const model = optionalString(value.model);
+		if (!model || !/^[^/\s]+\/[^/\s]+$/.test(model)) throw new Error("model request target is invalid");
+		return {
+			expectedRevision,
+			json: true,
+			model,
+			operation,
+			requestId,
+			...context ? { context } : {},
+			...verbose ? { verbose: true } : {}
+		};
+	}
+	return {
+		expectedRevision,
+		json: true,
+		operation,
+		requestId,
+		...context ? { context } : {},
+		...verbose ? { verbose: true } : {}
+	};
+}
+function toRivusModelManagementSubmission(request) {
+	const target = request.operation === "set" ? parseTarget(request.model) : void 0;
+	return {
+		expectedRevision: request.expectedRevision,
+		operation: request.operation,
+		requestId: request.requestId,
+		...target ? { target } : {},
+		...request.verbose ? { verbose: true } : {}
+	};
+}
+function projectRivusModelCliResponse(value, operation) {
+	if (!isRecord(value)) throw new Error("model handler must return a JSON object");
+	const response = { schemaVersion: 1 };
+	copyScalar(response, value, "requestId");
+	copyScalar(response, value, "revision");
+	copyScalar(response, value, "source");
+	copyScalar(response, value, "protocolVersion");
+	copyScalar(response, value, "runtimeVersion");
+	copyScalar(response, value, "operation");
+	copyScalar(response, value, "expectedRevision");
+	copyScalar(response, value, "phase");
+	copyScalar(response, value, "reason");
+	for (const key of [
+		"actual",
+		"current",
+		"persisted",
+		"previous",
+		"target"
+	]) {
+		const model = projectModelReference(value[key]);
+		if (model) response[key] = model;
+	}
+	const budget = projectBudget(value.budget);
+	if (budget) response.budget = budget;
+	const pending = projectPending(value.pending);
+	if (pending) response.pending = pending;
+	const request = projectReceipt(value.request);
+	if (request) response.request = request;
+	const error = projectError(value.error);
+	if (error) response.error = error;
+	const recoveryRequired = projectError(value.recoveryRequired);
+	if (recoveryRequired) response.recoveryRequired = recoveryRequired;
+	const notification = projectNotification(value.notification);
+	if (notification) response.notification = notification;
+	const status = value.status;
+	response.status = isPublicStatus(status) ? status : value.recoveryRequired !== void 0 ? "recovery-required" : operation === "status" && value.pending !== void 0 ? "pending" : operation === "status" ? "applied" : "failed";
+	return response;
+}
+function createRivusModelManagementFailure(code, message) {
+	return {
+		error: {
+			code,
+			message
+		},
+		schemaVersion: 1,
+		status: "failed"
+	};
+}
+function projectModelReference(value) {
+	if (!isRecord(value) || typeof value.provider !== "string" || typeof value.model !== "string") return void 0;
+	const result = {
+		model: value.model,
+		provider: value.provider
+	};
+	if (typeof value.label === "string") return {
+		...result,
+		label: value.label
+	};
+	if (typeof value.bindingRevision === "string") return {
+		...result,
+		bindingRevision: value.bindingRevision
+	};
+	return result;
+}
+function projectPending(value) {
+	if (!isRecord(value)) return void 0;
+	const result = {};
+	copyScalar(result, value, "phase");
+	copyScalar(result, value, "reason");
+	if (result.reason === void 0 && typeof result.phase === "string") result.reason = result.phase;
+	copyScalar(result, value, "requestId");
+	copyScalar(result, value, "updatedAt");
+	const request = projectReceipt(value.request);
+	if (request) result.request = request;
+	const target = projectModelReference(value.target);
+	if (target) result.target = target;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function projectReceipt(value) {
+	if (!isRecord(value)) return void 0;
+	const result = {};
+	for (const key of [
+		"requestId",
+		"revision",
+		"status",
+		"phase",
+		"operation",
+		"expectedRevision",
+		"acceptedAt",
+		"updatedAt"
+	]) copyScalar(result, value, key);
+	const current = projectModelReference(value.current);
+	if (current) result.current = current;
+	const previous = projectModelReference(value.previous);
+	if (previous) result.previous = previous;
+	const target = projectModelReference(value.target);
+	if (target) result.target = target;
+	const budget = projectBudget(value.budget);
+	if (budget) result.budget = budget;
+	const error = projectError(value.error);
+	if (error) result.error = error;
+	const notification = projectNotification(value.notification);
+	if (notification) result.notification = notification;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function projectBudget(value) {
+	if (!isRecord(value)) return void 0;
+	const result = {};
+	for (const key of [
+		"deadlineAt",
+		"maxOutputTokens",
+		"maxPaidRequests",
+		"outputTokens",
+		"paidRequests"
+	]) copyScalar(result, value, key);
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function projectError(value) {
+	if (!isRecord(value) || typeof value.code !== "string" || typeof value.message !== "string") return void 0;
+	return {
+		code: value.code,
+		message: value.message
+	};
+}
+function projectNotification(value) {
+	if (!isRecord(value)) return void 0;
+	const result = {};
+	copyScalar(result, value, "attempts");
+	copyScalar(result, value, "lastAttemptAt");
+	copyScalar(result, value, "status");
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function copyScalar(target, source, key) {
+	const value = source[key];
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") target[key] = value;
+}
+function parseTarget(value) {
+	if (!value) throw new Error("model request target is missing");
+	const separator = value.indexOf("/");
+	return {
+		model: value.slice(separator + 1),
+		provider: value.slice(0, separator)
+	};
+}
+function isPublicStatus(value) {
+	return value === "applied" || value === "failed" || value === "pending" || value === "recovery-required" || value === "restored";
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { toRivusModelManagementSubmission as a, renderRivusModelCliHelp as c, projectRivusModelCliResponse as i, createRivusModelManagementWireRequest as n, parseRivusModelCliArguments as o, parseRivusModelManagementWireRequest as r, renderRivusModelCliArgumentError as s, createRivusModelManagementFailure as t };

package/dist/chunks/rivus-plugin-testkit.d.ts

@@ -1,5 +1,178 @@
-import { J as RivusAgentDeployment, a as RivusPlugin } from "./api2.js";
+import { a as RivusRuntimeToolId, d as RivusResolvedToolDescriptor, f as RivusToolDescriptor, g as RivusToolGrantSet, n as RivusSkillDescriptor, r as RivusSkillGrantSet, s as RegisteredRivusTool, t as RegisteredRivusSkill, u as RivusMemoryScope } from "./rivus-skill.js";
 
+//#region src/core/application/agent-catalog/contracts/rivus-agent-definition.d.ts
+interface RivusAgentProfile {
+  readonly id: string;
+  readonly displayName: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+  };
+  readonly runtimeTools?: {
+    readonly allow: ReadonlyArray<RivusRuntimeToolId>;
+  };
+}
+interface RegisteredRivusAgentProfile extends RivusAgentProfile {
+  readonly pluginId: string;
+}
+interface RivusAgentDeployment {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly memory?: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeTools?: {
+    readonly allow: ReadonlyArray<RivusRuntimeToolId>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+}
+interface ResolvedRivusAgentDefinition {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly projectSpaceRevision?: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly profileRevision: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeToolGrantSet: RivusRuntimeToolGrantSet;
+  readonly skillGrantSet: RivusSkillGrantSet;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+  readonly toolGrantSet: RivusToolGrantSet;
+}
+interface RivusRuntimeToolGrantSet {
+  readonly revision: string;
+  readonly toolIds: ReadonlyArray<RivusRuntimeToolId>;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-plugin.d.ts
+declare const RIVUS_PLUGIN_API_VERSION = "1";
+interface RivusPluginManifest {
+  readonly apiVersion: string;
+  readonly id: string;
+  readonly version: string;
+}
+interface RegisteredRivusPlugin extends RivusPluginManifest {}
+declare class InvalidRivusPlugin extends Error {
+  readonly name = "InvalidRivusPlugin";
+}
+//#endregion
+//#region src/core/application/automation/presentation/automation-presentation.d.ts
+declare const AUTOMATION_PRESENTATION_SCHEMA_VERSION: 1;
+type AutomationPresentationKind = "daily-ai" | "generic" | "industry" | "news" | "subscriptions";
+interface AutomationPresentationSource {
+  readonly label: string;
+  readonly url: string;
+}
+interface AutomationPresentationItem {
+  readonly headline: string;
+  readonly note?: string;
+  readonly sources: ReadonlyArray<AutomationPresentationSource>;
+}
+interface AutomationPresentationSection {
+  readonly id: string;
+  readonly items: ReadonlyArray<AutomationPresentationItem>;
+  readonly title: string;
+}
+interface AutomationPresentation {
+  readonly footnote?: string;
+  readonly kind?: AutomationPresentationKind;
+  readonly meta: ReadonlyArray<string>;
+  readonly schemaVersion: typeof AUTOMATION_PRESENTATION_SCHEMA_VERSION;
+  readonly sections: ReadonlyArray<AutomationPresentationSection>;
+  readonly summary?: string;
+  readonly title: string;
+}
+interface AutomationPresentationInput {
+  readonly footnote?: string;
+  readonly kind?: AutomationPresentationKind;
+  readonly meta?: ReadonlyArray<string>;
+  readonly sections: ReadonlyArray<{
+    readonly id: string;
+    readonly items: ReadonlyArray<{
+      readonly headline: string;
+      readonly note?: string;
+      readonly sources?: ReadonlyArray<AutomationPresentationSource>;
+    }>;
+    readonly title: string;
+  }>;
+  readonly summary?: string;
+  readonly title: string;
+}
+declare class InvalidAutomationPresentation extends Error {
+  readonly name = "InvalidAutomationPresentation";
+}
+declare function createAutomationPresentation(input: AutomationPresentationInput): AutomationPresentation;
+declare function readAutomationPresentation(value: unknown): AutomationPresentation;
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-automation-template.d.ts
+interface RivusAutomationTemplate {
+  readonly id: string;
+  readonly profileId: string;
+  readonly requestedSkillIds: ReadonlyArray<string>;
+  readonly requestedToolIds: ReadonlyArray<string>;
+  readonly createInput: (tick: RivusAutomationTickContext) => RivusAutomationInput;
+  readonly createPresentation?: (output: RivusAutomationOutput) => AutomationPresentation;
+}
+interface RivusAutomationTickContext {
+  readonly occurrence: string;
+}
+interface RivusAutomationInput {
+  readonly text: string;
+}
+interface RivusAutomationOutput {
+  readonly occurrence: string;
+  readonly text: string;
+}
+interface RegisteredRivusAutomation extends RivusAutomationTemplate {
+  readonly pluginId: string;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-plugin-contracts.d.ts
+interface RivusPluginRegistry {
+  registerAgentProfile(profile: RivusAgentProfile): void;
+  registerTool(tool: RivusToolDescriptor): void;
+  registerSkill(skill: RivusSkillDescriptor): void;
+  registerAutomation(template: RivusAutomationTemplate): void;
+}
+interface RivusPlugin {
+  readonly manifest: RivusPluginManifest;
+  register(registry: RivusPluginRegistry): void;
+}
+interface RivusPluginCatalogSnapshot {
+  readonly plugins: ReadonlyArray<RegisteredRivusPlugin>;
+  readonly profiles: ReadonlyArray<RegisteredRivusAgentProfile>;
+  readonly tools: ReadonlyArray<RegisteredRivusTool>;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly automations: ReadonlyArray<RegisteredRivusAutomation>;
+}
+interface RivusPluginCatalog {
+  registerPlugin(plugin: RivusPlugin): void;
+  snapshot(): RivusPluginCatalogSnapshot;
+}
+//#endregion
 //#region src/testing/rivus-plugin-testkit.d.ts
 interface RivusPluginLifecycleProbe {
   activate(): Promise<{
@@ -24,4 +197,4 @@ declare class RivusPluginConformanceError extends Error {
 declare function assertRivusPluginConforms(input: RivusPluginConformanceInput): Promise<RivusPluginConformanceReport>;
 declare function createFakeRivusPlugin(): RivusPlugin;
 //#endregion
-export { assertRivusPluginConforms as a, RivusPluginLifecycleProbe as i, RivusPluginConformanceInput as n, createFakeRivusPlugin as o, RivusPluginConformanceReport as r, RivusPluginConformanceError as t };
+export { RegisteredRivusAgentProfile as A, InvalidAutomationPresentation as C, RIVUS_PLUGIN_API_VERSION as D, InvalidRivusPlugin as E, RivusAgentDeployment as M, RivusAgentProfile as N, RegisteredRivusPlugin as O, RivusRuntimeToolGrantSet as P, AutomationPresentationSource as S, readAutomationPresentation as T, AutomationPresentation as _, assertRivusPluginConforms as a, AutomationPresentationKind as b, RivusPluginCatalog as c, RegisteredRivusAutomation as d, RivusAutomationInput as f, AUTOMATION_PRESENTATION_SCHEMA_VERSION as g, RivusAutomationTickContext as h, RivusPluginLifecycleProbe as i, ResolvedRivusAgentDefinition as j, RivusPluginManifest as k, RivusPluginCatalogSnapshot as l, RivusAutomationTemplate as m, RivusPluginConformanceInput as n, createFakeRivusPlugin as o, RivusAutomationOutput as p, RivusPluginConformanceReport as r, RivusPlugin as s, RivusPluginConformanceError as t, RivusPluginRegistry as u, AutomationPresentationInput as v, createAutomationPresentation as w, AutomationPresentationSection as x, AutomationPresentationItem as y };

package/dist/chunks/rivus-plugin-testkit.js

@@ -1,8 +1,15 @@
-import { i as createRivusPluginCatalog } from "./api.js";
-import { n as createRivusHostToolDescriptorProvider, r as RIVUS_MEMORY_TOOL_ID, t as createRivusAgentCatalog } from "./module.js";
+import { t as createSha256Digest } from "./sha256-digest.js";
+import { o as createRivusHostToolDescriptorProvider, p as deepFreeze, r as createRivusPluginCatalog$1, s as RIVUS_MEMORY_TOOL_ID, t as createRivusAgentCatalog } from "./rivus-agent-definition-resolver.js";
 //#region src/adapters/compatibility/agent-catalog/rivus-agent-catalog.ts
+const runtime = Object.freeze({
+	digest: createSha256Digest,
+	deepFreeze
+});
+function createRivusPluginCatalog() {
+	return createRivusPluginCatalog$1(runtime);
+}
 function createCompatibleRivusAgentCatalog(options = {}) {
-	return createRivusAgentCatalog({ toolDescriptorProviders: [createRivusHostToolDescriptorProvider({ backgroundSessions: options.backgroundSessions === true })] });
+	return createRivusAgentCatalog([createRivusHostToolDescriptorProvider({ backgroundSessions: options.backgroundSessions === true })], runtime);
 }
 function resolveRivusAgentDefinition(catalog, deployment, options = {}) {
 	return createCompatibleRivusAgentCatalog(options).resolve(catalog, deployment);
@@ -68,4 +75,4 @@ function createFakeRivusPlugin() {
 	};
 }
 //#endregion
-export { resolveRivusAgentDefinition as a, createCompatibleRivusAgentCatalog as i, assertRivusPluginConforms as n, createFakeRivusPlugin as r, RivusPluginConformanceError as t };
+export { createRivusPluginCatalog as a, createCompatibleRivusAgentCatalog as i, assertRivusPluginConforms as n, resolveRivusAgentDefinition as o, createFakeRivusPlugin as r, RivusPluginConformanceError as t };

package/dist/chunks/rivus-skill.d.ts

@@ -0,0 +1,95 @@
+//#region src/core/application/agent-catalog/contracts/rivus-tool.d.ts
+type RivusMemoryScope = "conversation" | "agent-private" | "project" | "shared-user-profile";
+type RivusToolRisk = "observe" | "mutate" | "irreversible" | "host-control";
+type RivusToolIdempotency = "none" | "supported" | "required";
+declare class RivusToolInputRejected extends Error {
+  readonly name: string;
+}
+interface RivusToolExecutor {
+  execute(input: unknown, context: RivusToolExecutionContext): unknown;
+}
+interface RivusToolExecutionOrigin {
+  readonly endpointId: string;
+  readonly tenantKey: string;
+  readonly conversationId?: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+}
+interface RivusToolExecutionContext {
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly memory?: RivusMemoryAuthority;
+  readonly runId: string;
+  readonly callId: string;
+  readonly operationId?: string;
+  readonly policyEpoch: number;
+  readonly toolId: string;
+  readonly toolVersion: string;
+  readonly sessionKey: string;
+  readonly origin?: RivusToolExecutionOrigin;
+  readonly sourceMessageId?: string;
+}
+interface RivusMemoryAuthority {
+  readonly audience: "group" | "private";
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly scopes: ReadonlyArray<RivusMemoryScope>;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface RivusToolFactoryContext {
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface RivusToolDescriptor {
+  readonly id: string;
+  readonly version: string;
+  readonly digest: string;
+  readonly description: string;
+  readonly inputSchema: unknown;
+  readonly risk: RivusToolRisk;
+  readonly idempotency: RivusToolIdempotency;
+  readonly createExecutor: (context: RivusToolFactoryContext) => RivusToolExecutor;
+}
+interface RivusHostToolDescriptor extends RivusToolDescriptor {
+  readonly replayCompleted?: (input: unknown, completedResult: unknown, context: RivusToolExecutionContext) => unknown;
+}
+interface RegisteredRivusTool extends RivusToolDescriptor {
+  readonly pluginId: string;
+}
+interface RivusResolvedToolDescriptor {
+  readonly id: string;
+  readonly version: string;
+  readonly digest: string;
+  readonly description: string;
+  readonly inputSchema: unknown;
+  readonly risk: RivusToolRisk;
+  readonly idempotency: RivusToolIdempotency;
+  readonly pluginId: string;
+}
+interface RivusToolGrantSet {
+  readonly toolIds: ReadonlyArray<string>;
+  readonly revision: string;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-runtime-tool.d.ts
+declare const RIVUS_RUNTIME_TOOL_IDS: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
+type RivusRuntimeToolId = (typeof RIVUS_RUNTIME_TOOL_IDS)[number];
+declare function isRivusRuntimeToolId(value: string): value is RivusRuntimeToolId;
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-skill.d.ts
+interface RivusSkillDescriptor {
+  readonly id: string;
+  readonly version: string;
+  readonly digest: string;
+  readonly title: string;
+  readonly content: string;
+}
+interface RegisteredRivusSkill extends RivusSkillDescriptor {
+  readonly pluginId: string;
+}
+interface RivusSkillGrantSet {
+  readonly skillIds: ReadonlyArray<string>;
+  readonly revision: string;
+}
+//#endregion
+export { RivusToolIdempotency as _, RivusRuntimeToolId as a, RivusHostToolDescriptor as c, RivusResolvedToolDescriptor as d, RivusToolDescriptor as f, RivusToolGrantSet as g, RivusToolFactoryContext as h, RIVUS_RUNTIME_TOOL_IDS as i, RivusMemoryAuthority as l, RivusToolExecutor as m, RivusSkillDescriptor as n, isRivusRuntimeToolId as o, RivusToolExecutionContext as p, RivusSkillGrantSet as r, RegisteredRivusTool as s, RegisteredRivusSkill as t, RivusMemoryScope as u, RivusToolInputRejected as v, RivusToolRisk as y };