@xopcai/xopc 0.0.231 → 0.0.233

package/dist/src/agent-manifest/schema.js

@@ -1,226 +0,0 @@
-import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { z } from "zod";
-//#region src/agent-manifest/schema.ts
-var IdSchema, LockPathSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, AgentToolModelSchema, ModelPolicySchema, ModelPolicyPatchSchema, ToolModeSchema, ToolScopeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolPolicySetPatchSchema, SkillPolicySchema, SkillPolicyPatchSchema, WorkflowPolicySchema, WorkflowPolicyPatchSchema, BoundaryPolicySchema, BoundaryPolicyPatchSchema, WorkspacePolicySchema, RuntimePolicySchema, PromptPolicySchema, AgentIdentitySchema, AgentResponsibilitiesSchema, AgentManifestSchema, AgentConfigEntrySchema, CapabilityPresetSchema;
-var init_schema = __esmMin((() => {
-	IdSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
-	LockPathSchema = z.string().regex(/^(models|tools|skills|workflows|boundaries|runtime)(?:\.[^.\s]+)*$/, "lock path must target a capability policy field");
-	DEFAULT_CAPABILITY_PRESET_ID = "default";
-	ManifestModelRoleSchema = z.object({
-		model: z.string().min(1),
-		fallbacks: z.array(z.string().min(1)).optional(),
-		description: z.string().max(500).optional()
-	}).strict().superRefine((entry, ctx) => {
-		const validateRef = (ref) => {
-			const trimmed = ref.trim();
-			const idx = trimmed.indexOf("/");
-			return idx > 0 && idx < trimmed.length - 1;
-		};
-		if (!validateRef(entry.model)) ctx.addIssue({
-			code: "custom",
-			message: `model must be provider/model format (got '${entry.model}')`,
-			path: ["model"]
-		});
-		for (const [index, fallback] of (entry.fallbacks ?? []).entries()) if (!validateRef(fallback)) ctx.addIssue({
-			code: "custom",
-			message: `fallback must be provider/model format (got '${fallback}')`,
-			path: ["fallbacks", index]
-		});
-	});
-	AgentToolModelSchema = z.object({
-		primary: z.string().min(1),
-		fallbacks: z.array(z.string().min(1)).optional(),
-		timeoutMs: z.number().int().positive().optional(),
-		autoProviderFallback: z.boolean().optional()
-	}).strict().superRefine((entry, ctx) => {
-		const validateRef = (ref) => {
-			const trimmed = ref.trim();
-			const idx = trimmed.indexOf("/");
-			return idx > 0 && idx < trimmed.length - 1;
-		};
-		if (!validateRef(entry.primary)) ctx.addIssue({
-			code: "custom",
-			message: `primary must be provider/model format (got '${entry.primary}')`,
-			path: ["primary"]
-		});
-		for (const [index, fallback] of (entry.fallbacks ?? []).entries()) if (!validateRef(fallback)) ctx.addIssue({
-			code: "custom",
-			message: `fallback must be provider/model format (got '${fallback}')`,
-			path: ["fallbacks", index]
-		});
-	});
-	ModelPolicySchema = z.object({
-		defaultRole: IdSchema,
-		roles: z.record(IdSchema, ManifestModelRoleSchema).default({}),
-		imageModel: AgentToolModelSchema.optional(),
-		imageGenerationModel: AgentToolModelSchema.optional(),
-		policy: z.object({
-			allowFallbacks: z.boolean().optional(),
-			maxCostTier: z.enum([
-				"low",
-				"medium",
-				"high"
-			]).optional()
-		}).strict().optional()
-	}).strict();
-	ModelPolicyPatchSchema = z.object({
-		defaultRole: IdSchema.optional(),
-		roles: z.record(IdSchema, ManifestModelRoleSchema).optional(),
-		imageModel: AgentToolModelSchema.optional(),
-		imageGenerationModel: AgentToolModelSchema.optional(),
-		policy: z.object({
-			allowFallbacks: z.boolean().optional(),
-			maxCostTier: z.enum([
-				"low",
-				"medium",
-				"high"
-			]).optional()
-		}).strict().optional()
-	}).strict();
-	ToolModeSchema = z.enum([
-		"allow",
-		"confirm",
-		"deny"
-	]);
-	ToolScopeSchema = z.enum([
-		"readonly",
-		"workspace",
-		"unrestricted"
-	]);
-	ToolPolicySchema = z.object({
-		mode: ToolModeSchema,
-		scope: ToolScopeSchema.optional(),
-		limits: z.object({
-			maxCallsPerTurn: z.number().int().positive().optional(),
-			timeoutMs: z.number().int().positive().optional()
-		}).strict().optional()
-	}).strict();
-	ToolPolicySetSchema = z.object({
-		builtin: z.record(z.string().min(1), ToolPolicySchema).default({}),
-		mcp: z.object({
-			servers: z.record(z.string().min(1), ToolPolicySchema).optional(),
-			tools: z.record(z.string().min(1), ToolPolicySchema).optional()
-		}).strict().optional()
-	}).strict().default({ builtin: {} });
-	ToolPolicySetPatchSchema = z.object({
-		builtin: z.record(z.string().min(1), ToolPolicySchema).optional(),
-		mcp: z.object({
-			servers: z.record(z.string().min(1), ToolPolicySchema).optional(),
-			tools: z.record(z.string().min(1), ToolPolicySchema).optional()
-		}).strict().optional()
-	}).strict();
-	SkillPolicySchema = z.object({
-		mode: z.enum([
-			"all",
-			"allowlist",
-			"denylist",
-			"off"
-		]).default("all"),
-		allow: z.array(z.string().min(1)).optional(),
-		deny: z.array(z.string().min(1)).optional()
-	}).strict().default({ mode: "all" });
-	SkillPolicyPatchSchema = z.object({
-		mode: z.enum([
-			"all",
-			"allowlist",
-			"denylist",
-			"off"
-		]),
-		allow: z.array(z.string().min(1)).optional(),
-		deny: z.array(z.string().min(1)).optional()
-	}).strict();
-	WorkflowPolicySchema = z.object({
-		default: z.string().min(1).optional(),
-		allowed: z.array(z.string().min(1)).optional(),
-		suggested: z.array(z.object({
-			intent: z.string().min(1),
-			workflow: z.string().min(1)
-		}).strict()).optional()
-	}).strict().default({});
-	WorkflowPolicyPatchSchema = WorkflowPolicySchema.removeDefault();
-	BoundaryPolicySchema = z.object({
-		requiresConfirmation: z.array(z.string().min(1)).default([]),
-		forbidden: z.array(z.string().min(1)).default([]),
-		escalation: z.array(z.string().min(1)).default([])
-	}).strict().default({
-		requiresConfirmation: [],
-		forbidden: [],
-		escalation: []
-	});
-	BoundaryPolicyPatchSchema = z.object({
-		requiresConfirmation: z.array(z.string().min(1)).optional(),
-		forbidden: z.array(z.string().min(1)).optional(),
-		escalation: z.array(z.string().min(1)).optional()
-	}).strict();
-	WorkspacePolicySchema = z.object({ root: z.string().min(1) }).strict();
-	RuntimePolicySchema = z.object({
-		maxTurns: z.number().int().positive().optional(),
-		timeoutMs: z.number().int().positive().optional(),
-		maxToolFailuresPerTurn: z.number().int().positive().optional(),
-		promptCache: z.object({
-			mode: z.enum(["off", "auto"]).default("auto"),
-			lifetime: z.enum(["short", "long"]).default("short")
-		}).strict().optional()
-	}).strict().optional();
-	PromptPolicySchema = z.object({ customInstructions: z.string().optional() }).strict().optional();
-	AgentIdentitySchema = z.object({
-		name: z.string().min(1),
-		description: z.string().optional(),
-		role: z.string().min(1),
-		language: z.string().min(1).default("en"),
-		tone: z.string().min(1).default("direct"),
-		avatar: z.string().optional()
-	}).strict();
-	AgentResponsibilitiesSchema = z.object({
-		primary: z.array(z.string().min(1)).min(1),
-		secondary: z.array(z.string().min(1)).optional(),
-		outOfScope: z.array(z.string().min(1)).optional()
-	}).strict();
-	AgentManifestSchema = z.object({
-		id: IdSchema,
-		enabled: z.boolean().default(true),
-		extends: z.array(IdSchema).optional(),
-		identity: AgentIdentitySchema,
-		responsibilities: AgentResponsibilitiesSchema,
-		workspace: WorkspacePolicySchema,
-		models: ModelPolicySchema,
-		tools: ToolPolicySetSchema,
-		skills: SkillPolicySchema,
-		workflows: WorkflowPolicySchema,
-		boundaries: BoundaryPolicySchema,
-		runtime: RuntimePolicySchema,
-		prompt: PromptPolicySchema
-	}).strict();
-	AgentConfigEntrySchema = z.object({
-		id: IdSchema,
-		enabled: z.boolean().default(true),
-		extends: z.array(IdSchema).optional(),
-		identity: AgentIdentitySchema,
-		responsibilities: AgentResponsibilitiesSchema,
-		workspace: WorkspacePolicySchema,
-		models: ModelPolicyPatchSchema.optional(),
-		tools: ToolPolicySetPatchSchema.optional(),
-		skills: SkillPolicyPatchSchema.optional(),
-		workflows: WorkflowPolicyPatchSchema.optional(),
-		boundaries: BoundaryPolicyPatchSchema.optional(),
-		runtime: RuntimePolicySchema,
-		prompt: PromptPolicySchema
-	}).strict();
-	CapabilityPresetSchema = z.object({
-		id: IdSchema,
-		name: z.string().min(1),
-		description: z.string().optional(),
-		version: z.number().int().positive().default(1),
-		extends: z.array(IdSchema).optional(),
-		models: ModelPolicyPatchSchema.optional(),
-		tools: ToolPolicySetPatchSchema.optional(),
-		skills: SkillPolicyPatchSchema.optional(),
-		workflows: WorkflowPolicyPatchSchema.optional(),
-		boundaries: BoundaryPolicyPatchSchema.optional(),
-		runtime: RuntimePolicySchema,
-		locks: z.array(LockPathSchema).optional()
-	}).strict();
-}));
-//#endregion
-init_schema();
-export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicyPatchSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicyPatchSchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetPatchSchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicyPatchSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema };

package/dist/src/agent-manifest/validator.d.ts

@@ -1,25 +0,0 @@
-import type { AgentConfigEntry, CapabilityPreset, EffectiveAgentManifest } from './schema.js';
-export type ManifestIssueSeverity = 'error' | 'warning';
-export interface ManifestIssue {
-    severity: ManifestIssueSeverity;
-    path: string;
-    message: string;
-}
-export interface ManifestCatalogs {
-    tools?: Iterable<string>;
-    skills?: Iterable<string>;
-    workflows?: Iterable<string>;
-    mcpServers?: Iterable<string>;
-}
-export interface ValidateManifestParams {
-    agent: AgentConfigEntry;
-    presets?: Record<string, CapabilityPreset>;
-    defaultPresetId?: string;
-    catalogs?: ManifestCatalogs;
-}
-export interface ValidateManifestResult {
-    ok: boolean;
-    manifest?: EffectiveAgentManifest;
-    issues: ManifestIssue[];
-}
-export declare function validateAgentManifest(params: ValidateManifestParams): ValidateManifestResult;

package/dist/src/agent-manifest/validator.js

@@ -1,74 +0,0 @@
-import { resolveEffectiveAgentManifest } from "./resolver.js";
-//#region src/agent-manifest/validator.ts
-function toSet(values) {
-	if (!values) return void 0;
-	return new Set([...values].map((value) => value.toLowerCase()));
-}
-function hasValue(set, value) {
-	return set === void 0 || set.has(value.toLowerCase());
-}
-function addIssue(issues, severity, path, message) {
-	issues.push({
-		severity,
-		path,
-		message
-	});
-}
-function validateModels(manifest, issues) {
-	if (!manifest.models.roles[manifest.models.defaultRole]) addIssue(issues, "error", "models.defaultRole", `defaultRole "${manifest.models.defaultRole}" does not exist in models.roles`);
-}
-function validateTools(manifest, issues, catalogs) {
-	const tools = toSet(catalogs.tools);
-	for (const [name, policy] of Object.entries(manifest.tools.builtin)) {
-		if (!hasValue(tools, name)) addIssue(issues, "error", `tools.builtin.${name}`, `tool "${name}" is not in the tool catalog`);
-		if (policy.mode === "allow" && policy.scope === "unrestricted") addIssue(issues, "warning", `tools.builtin.${name}.scope`, `tool "${name}" is unrestricted; consider using confirm or a narrower scope`);
-	}
-	const mcpServers = toSet(catalogs.mcpServers);
-	for (const serverName of Object.keys(manifest.tools.mcp?.servers ?? {})) if (!hasValue(mcpServers, serverName)) addIssue(issues, "error", `tools.mcp.servers.${serverName}`, `MCP server "${serverName}" is not configured`);
-}
-function validateSkills(manifest, issues, catalogs) {
-	const skills = toSet(catalogs.skills);
-	for (const name of manifest.skills.allow ?? []) if (!hasValue(skills, name)) addIssue(issues, "error", `skills.allow`, `skill "${name}" is not installed`);
-	for (const name of manifest.skills.deny ?? []) if (!hasValue(skills, name)) addIssue(issues, "warning", `skills.deny`, `skill "${name}" is not installed`);
-	if (manifest.skills.mode === "allowlist" && (manifest.skills.allow?.length ?? 0) === 0) addIssue(issues, "warning", "skills.allow", "allowlist mode has no allowed skills");
-}
-function validateWorkflows(manifest, issues, catalogs) {
-	const workflows = toSet(catalogs.workflows);
-	const check = (path, value) => {
-		if (value && !hasValue(workflows, value)) addIssue(issues, "error", path, `workflow "${value}" is not in the workflow catalog`);
-	};
-	check("workflows.default", manifest.workflows.default);
-	for (const [index, value] of (manifest.workflows.allowed ?? []).entries()) check(`workflows.allowed.${index}`, value);
-	for (const [index, entry] of (manifest.workflows.suggested ?? []).entries()) check(`workflows.suggested.${index}.workflow`, entry.workflow);
-}
-function validateAgentManifest(params) {
-	const issues = [];
-	let manifest;
-	try {
-		manifest = resolveEffectiveAgentManifest({
-			agent: params.agent,
-			presets: params.presets,
-			defaultPresetId: params.defaultPresetId
-		}).manifest;
-	} catch (error) {
-		return {
-			ok: false,
-			issues: [{
-				severity: "error",
-				path: "manifest",
-				message: error instanceof Error ? error.message : String(error)
-			}]
-		};
-	}
-	validateModels(manifest, issues);
-	validateTools(manifest, issues, params.catalogs ?? {});
-	validateSkills(manifest, issues, params.catalogs ?? {});
-	validateWorkflows(manifest, issues, params.catalogs ?? {});
-	return {
-		ok: issues.every((issue) => issue.severity !== "error"),
-		manifest,
-		issues
-	};
-}
-//#endregion
-export { validateAgentManifest };

package/dist/src/agent-runtime/boundary-guard.d.ts

@@ -1,12 +0,0 @@
-import type { EffectiveAgentManifest } from '../agent-manifest/schema.js';
-export type BoundaryDecision = 'allow' | 'confirm' | 'deny' | 'escalate';
-export interface BoundaryCheckParams {
-    manifest: EffectiveAgentManifest;
-    action: string;
-    detail?: string;
-}
-export interface BoundaryCheckResult {
-    decision: BoundaryDecision;
-    matchedRule?: string;
-}
-export declare function checkBoundary(params: BoundaryCheckParams): BoundaryCheckResult;

package/dist/src/agent-runtime/boundary-guard.js

@@ -1,21 +0,0 @@
-//#region src/agent-runtime/boundary-guard.ts
-function matchesRule(action, detail, rule) {
-	return `${action}\n${detail ?? ""}`.toLowerCase().includes(rule.toLowerCase());
-}
-function checkBoundary(params) {
-	for (const rule of params.manifest.boundaries.forbidden) if (matchesRule(params.action, params.detail, rule)) return {
-		decision: "deny",
-		matchedRule: rule
-	};
-	for (const rule of params.manifest.boundaries.escalation) if (matchesRule(params.action, params.detail, rule)) return {
-		decision: "escalate",
-		matchedRule: rule
-	};
-	for (const rule of params.manifest.boundaries.requiresConfirmation) if (matchesRule(params.action, params.detail, rule)) return {
-		decision: "confirm",
-		matchedRule: rule
-	};
-	return { decision: "allow" };
-}
-//#endregion
-export { checkBoundary };

package/dist/src/agent-runtime/index.d.ts

@@ -1,7 +0,0 @@
-export * from './model-router.js';
-export * from './tool-registry.js';
-export * from './boundary-guard.js';
-export * from './memory-runtime.js';
-export * from './runtime-profile.js';
-export * from './run-trace.js';
-export * from './workflow-runtime.js';

package/dist/src/agent-runtime/index.js

@@ -1,8 +0,0 @@
-import { buildMemoryRuntime } from "./memory-runtime.js";
-import { checkBoundary } from "./boundary-guard.js";
-import { resolveModelRole } from "./model-router.js";
-import { buildRuntimeToolRegistry } from "./tool-registry.js";
-import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
-import { buildAgentRuntimeProfile } from "./runtime-profile.js";
-import { appendAgentRunEvent, createAgentRunTrace, finishAgentRunTrace, hashEffectiveManifest } from "./run-trace.js";
-export { appendAgentRunEvent, buildAgentRuntimeProfile, buildMemoryRuntime, buildRuntimeToolRegistry, checkBoundary, createAgentRunTrace, finishAgentRunTrace, hashEffectiveManifest, resolveModelRole, resolveWorkflow, validateWorkflowForRuntime };

package/dist/src/agent-runtime/model-router.d.ts

@@ -1,11 +0,0 @@
-import type { EffectiveAgentManifest } from '../agent-manifest/schema.js';
-export interface ResolveModelRoleParams {
-    manifest: EffectiveAgentManifest;
-    role?: string;
-}
-export interface ResolvedModelRole {
-    role: string;
-    model: string;
-    description?: string;
-}
-export declare function resolveModelRole(params: ResolveModelRoleParams): ResolvedModelRole;

package/dist/src/agent-runtime/model-router.js

@@ -1,14 +0,0 @@
-//#region src/agent-runtime/model-router.ts
-function resolveModelRole(params) {
-	const requested = params.role?.trim() || params.manifest.models.defaultRole;
-	const role = params.manifest.models.roles[requested] ? requested : params.manifest.models.defaultRole;
-	const entry = params.manifest.models.roles[role];
-	if (!entry) throw new Error(`Model role "${role}" is not configured`);
-	return {
-		role,
-		model: entry.model,
-		...entry.description !== void 0 ? { description: entry.description } : {}
-	};
-}
-//#endregion
-export { resolveModelRole };

package/dist/src/agent-runtime/run-trace.d.ts

@@ -1,27 +0,0 @@
-import type { EffectiveAgentManifest } from '../agent-manifest/schema.js';
-export type AgentRunStatus = 'running' | 'completed' | 'failed' | 'cancelled';
-export type AgentRunEventType = 'run.started' | 'model.selected' | 'tool.called' | 'memory.read' | 'memory.write.checked' | 'workflow.selected' | 'boundary.checked' | 'run.completed' | 'run.failed';
-export interface AgentRunEvent {
-    id: string;
-    runId: string;
-    type: AgentRunEventType;
-    payload: Record<string, unknown>;
-    createdAt: string;
-}
-export interface AgentRunTrace {
-    id: string;
-    agentId: string;
-    status: AgentRunStatus;
-    effectiveManifestHash: string;
-    startedAt: string;
-    endedAt?: string;
-    events: AgentRunEvent[];
-}
-export declare function hashEffectiveManifest(manifest: EffectiveAgentManifest): string;
-export declare function createAgentRunTrace(params: {
-    agentId: string;
-    manifest: EffectiveAgentManifest;
-    now?: Date;
-}): AgentRunTrace;
-export declare function appendAgentRunEvent(trace: AgentRunTrace, type: AgentRunEventType, payload: Record<string, unknown>, now?: Date): AgentRunTrace;
-export declare function finishAgentRunTrace(trace: AgentRunTrace, status: Exclude<AgentRunStatus, 'running'>, payload?: Record<string, unknown>, now?: Date): AgentRunTrace;

package/dist/src/agent-runtime/run-trace.js

@@ -1,51 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-//#region src/agent-runtime/run-trace.ts
-function stableJson(value) {
-	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`).join(",")}}`;
-	return JSON.stringify(value);
-}
-function hashEffectiveManifest(manifest) {
-	return createHash("sha256").update(stableJson(manifest)).digest("hex");
-}
-function createAgentRunTrace(params) {
-	const startedAt = (params.now ?? /* @__PURE__ */ new Date()).toISOString();
-	const runId = randomUUID();
-	return {
-		id: runId,
-		agentId: params.agentId,
-		status: "running",
-		effectiveManifestHash: hashEffectiveManifest(params.manifest),
-		startedAt,
-		events: [{
-			id: randomUUID(),
-			runId,
-			type: "run.started",
-			payload: { agentId: params.agentId },
-			createdAt: startedAt
-		}]
-	};
-}
-function appendAgentRunEvent(trace, type, payload, now = /* @__PURE__ */ new Date()) {
-	if (trace.status !== "running") throw new Error(`Cannot append event to ${trace.status} run`);
-	return {
-		...trace,
-		events: [...trace.events, {
-			id: randomUUID(),
-			runId: trace.id,
-			type,
-			payload,
-			createdAt: now.toISOString()
-		}]
-	};
-}
-function finishAgentRunTrace(trace, status, payload = {}, now = /* @__PURE__ */ new Date()) {
-	if (trace.status !== "running") throw new Error(`Cannot finish ${trace.status} run`);
-	return {
-		...appendAgentRunEvent(trace, status === "failed" ? "run.failed" : "run.completed", payload, now),
-		status,
-		endedAt: now.toISOString()
-	};
-}
-//#endregion
-export { appendAgentRunEvent, createAgentRunTrace, finishAgentRunTrace, hashEffectiveManifest };

package/dist/src/agent-runtime/runtime-profile.d.ts

@@ -1,26 +0,0 @@
-import { type EffectiveAgentManifest } from '../agent-manifest/index.js';
-import { checkBoundary } from './boundary-guard.js';
-import { type MemoryRuntime } from './memory-runtime.js';
-import { resolveModelRole } from './model-router.js';
-import { type RuntimeToolRegistry, type ToolCatalogEntry } from './tool-registry.js';
-import { type WorkflowCatalogEntry, type WorkflowResolution, type WorkflowValidationIssue } from './workflow-runtime.js';
-import type { UserContextConfig } from '../user-context/config.js';
-export interface AgentRuntimeProfile<TTool = unknown> {
-    manifest: EffectiveAgentManifest;
-    promptSections: {
-        capability: string;
-    };
-    tools: RuntimeToolRegistry<TTool>;
-    memory: MemoryRuntime;
-    resolveModel: (role?: string) => ReturnType<typeof resolveModelRole>;
-    checkBoundary: (action: string, detail?: string) => ReturnType<typeof checkBoundary>;
-    resolveWorkflow: (intent?: string) => WorkflowResolution;
-    validateWorkflow: (workflow: WorkflowCatalogEntry) => WorkflowValidationIssue[];
-}
-export interface BuildAgentRuntimeProfileParams<TTool = unknown> {
-    manifest: EffectiveAgentManifest;
-    userContext: UserContextConfig;
-    toolCatalog: Iterable<ToolCatalogEntry<TTool>>;
-    workflowCatalog?: Iterable<WorkflowCatalogEntry>;
-}
-export declare function buildAgentRuntimeProfile<TTool = unknown>(params: BuildAgentRuntimeProfileParams<TTool>): AgentRuntimeProfile<TTool>;

package/dist/src/agent-runtime/runtime-profile.js

@@ -1,42 +0,0 @@
-import { buildAgentManifestPromptSection } from "../agent-manifest/prompt.js";
-import "../agent-manifest/index.js";
-import { buildMemoryRuntime } from "./memory-runtime.js";
-import { checkBoundary } from "./boundary-guard.js";
-import { resolveModelRole } from "./model-router.js";
-import { buildRuntimeToolRegistry } from "./tool-registry.js";
-import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
-//#region src/agent-runtime/runtime-profile.ts
-function buildAgentRuntimeProfile(params) {
-	const workflowCatalog = [...params.workflowCatalog ?? []];
-	const tools = buildRuntimeToolRegistry({
-		manifest: params.manifest,
-		catalog: params.toolCatalog
-	});
-	return {
-		manifest: params.manifest,
-		promptSections: { capability: buildAgentManifestPromptSection(params.manifest) },
-		tools,
-		memory: buildMemoryRuntime(params.userContext),
-		resolveModel: (role) => resolveModelRole({
-			manifest: params.manifest,
-			role
-		}),
-		checkBoundary: (action, detail) => checkBoundary({
-			manifest: params.manifest,
-			action,
-			detail
-		}),
-		resolveWorkflow: (intent) => resolveWorkflow({
-			manifest: params.manifest,
-			catalog: workflowCatalog,
-			intent
-		}),
-		validateWorkflow: (workflow) => validateWorkflowForRuntime({
-			manifest: params.manifest,
-			workflow,
-			tools
-		})
-	};
-}
-//#endregion
-export { buildAgentRuntimeProfile };

package/dist/src/agent-runtime/tool-registry.d.ts

@@ -1,28 +0,0 @@
-import type { EffectiveAgentManifest, ToolPolicy } from '../agent-manifest/schema.js';
-export interface ToolCatalogEntry<TTool = unknown> {
-    name: string;
-    category: 'file' | 'web' | 'code' | 'memory' | 'communication' | 'automation' | 'mcp' | 'other';
-    risk: 'low' | 'medium' | 'high';
-    supportsConfirm: boolean;
-    supportsDryRun?: boolean;
-    scopes?: Array<'readonly' | 'workspace' | 'unrestricted'>;
-    tool: TTool;
-}
-export interface RuntimeToolEntry<TTool = unknown> {
-    name: string;
-    policy: ToolPolicy;
-    catalog: ToolCatalogEntry<TTool>;
-    requiresConfirmation: boolean;
-    tool: TTool;
-}
-export interface BuildRuntimeToolRegistryParams<TTool = unknown> {
-    manifest: EffectiveAgentManifest;
-    catalog: Iterable<ToolCatalogEntry<TTool>>;
-}
-export interface RuntimeToolRegistry<TTool = unknown> {
-    tools: RuntimeToolEntry<TTool>[];
-    denied: string[];
-    missing: string[];
-    warnings: string[];
-}
-export declare function buildRuntimeToolRegistry<TTool = unknown>(params: BuildRuntimeToolRegistryParams<TTool>): RuntimeToolRegistry<TTool>;

package/dist/src/agent-runtime/tool-registry.js

@@ -1,50 +0,0 @@
-//#region src/agent-runtime/tool-registry.ts
-function scopeSupported(entry, policy) {
-	if (!policy.scope) return true;
-	return !entry.scopes || entry.scopes.includes(policy.scope);
-}
-function buildRuntimeToolRegistry(params) {
-	const byName = new Map([...params.catalog].map((entry) => [entry.name, entry]));
-	const tools = [];
-	const denied = [];
-	const missing = [];
-	const warnings = [];
-	for (const [name, policy] of Object.entries(params.manifest.tools.builtin)) {
-		if (policy.mode === "deny") {
-			denied.push(name);
-			continue;
-		}
-		const entry = byName.get(name);
-		if (!entry) {
-			missing.push(name);
-			continue;
-		}
-		if (policy.mode === "confirm" && !entry.supportsConfirm) {
-			warnings.push(`tool "${name}" requires confirmation but does not support a confirm wrapper`);
-			continue;
-		}
-		if (!scopeSupported(entry, policy)) {
-			warnings.push(`tool "${name}" does not support scope "${policy.scope}"`);
-			continue;
-		}
-		tools.push({
-			name,
-			policy,
-			catalog: entry,
-			requiresConfirmation: policy.mode === "confirm",
-			tool: entry.tool
-		});
-	}
-	tools.sort((a, b) => a.name.localeCompare(b.name));
-	denied.sort();
-	missing.sort();
-	warnings.sort();
-	return {
-		tools,
-		denied,
-		missing,
-		warnings
-	};
-}
-//#endregion
-export { buildRuntimeToolRegistry };

package/dist/src/agent-runtime/workflow-runtime.d.ts

@@ -1,31 +0,0 @@
-import type { EffectiveAgentManifest } from '../agent-manifest/schema.js';
-import type { RuntimeToolRegistry } from './tool-registry.js';
-export interface WorkflowPhaseDefinition {
-    id: string;
-    modelRole?: string;
-    requiredTools?: string[];
-}
-export interface WorkflowCatalogEntry {
-    id: string;
-    description?: string;
-    phases: WorkflowPhaseDefinition[];
-}
-export interface ResolveWorkflowParams {
-    manifest: EffectiveAgentManifest;
-    catalog: Iterable<WorkflowCatalogEntry>;
-    intent?: string;
-}
-export interface WorkflowResolution {
-    workflow?: WorkflowCatalogEntry;
-    reason: string;
-}
-export interface WorkflowValidationIssue {
-    path: string;
-    message: string;
-}
-export declare function resolveWorkflow(params: ResolveWorkflowParams): WorkflowResolution;
-export declare function validateWorkflowForRuntime(params: {
-    manifest: EffectiveAgentManifest;
-    workflow: WorkflowCatalogEntry;
-    tools: RuntimeToolRegistry;
-}): WorkflowValidationIssue[];