@xopcai/xopc 0.0.409 → 0.0.411

package/dist/src/agent/tools/workflow-manage-tool.js

@@ -1,225 +0,0 @@
-import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
-import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { validateWorkflowDefinitionInput } from "../../workflows/domain/validation.js";
-import { WorkflowNameConflictError, WorkflowRevisionConflictError, createWorkflowCatalog } from "../workflow/catalog.js";
-import "../../workflows/domain/index.js";
-import { WorkflowDraftConflictError, WorkflowDraftStore } from "../../workflows/authoring/workflow-draft-store.js";
-import { createStarterWorkflowGraph, createStarterWorkflowManifest } from "../../workflows/authoring/workflow-draft-defaults.js";
-import "../../workflows/authoring/index.js";
-import { Type } from "@sinclair/typebox";
-//#region src/agent/tools/workflow-manage-tool.ts
-init_src();
-const WorkflowManageSchema = Type.Object({
-	action: Type.Union([
-		Type.Literal("list"),
-		Type.Literal("open_draft"),
-		Type.Literal("get_draft"),
-		Type.Literal("replace_draft"),
-		Type.Literal("validate_draft"),
-		Type.Literal("publish_draft")
-	]),
-	workflowName: Type.Optional(Type.String({ description: "Saved or new lowercase snake_case workflow name." })),
-	draftId: Type.Optional(Type.String({ description: "Draft id returned by open_draft." })),
-	graph: Type.Optional(Type.Any({ description: "Complete workflow graph for replace_draft." })),
-	manifest: Type.Optional(Type.Any({ description: "Complete workflow manifest for replace_draft." })),
-	expectedUpdatedAtMs: Type.Optional(Type.Number({ description: "Latest draft updatedAtMs; required for replace_draft and publish_draft." })),
-	confirmed: Type.Optional(Type.Boolean({ description: "Must be true for publish_draft after the user explicitly confirms this draft." }))
-});
-function createWorkflowManageTool() {
-	const store = new WorkflowDraftStore();
-	return {
-		name: "workflow_manage",
-		label: "◆ Workflow builder",
-		description: "Create and edit saved workflows through durable validated drafts. Use list/open/get/replace/validate, then publish only after user confirmation.",
-		parameters: WorkflowManageSchema,
-		async execute(_toolCallId, input) {
-			try {
-				if (input.action === "list") return listWorkflows();
-				if (input.action === "open_draft") return openDraft(store, input.workflowName);
-				const draft = requireDraft(store, input.draftId);
-				if (input.action === "get_draft") return success(JSON.stringify(draft, null, 2), { draft });
-				if (input.action === "validate_draft") return validateDraft(draft);
-				if (input.action === "replace_draft") return replaceDraft(store, draft, input);
-				return publishDraft(store, draft, input.expectedUpdatedAtMs, input.confirmed);
-			} catch (error) {
-				return failure(error instanceof Error ? error.message : String(error));
-			}
-		}
-	};
-}
-function listWorkflows() {
-	const workflows = createWorkflowCatalog().list().slice(0, 100).map((entry) => ({
-		name: entry.name,
-		title: entry.title,
-		description: entry.description,
-		revision: entry.revision
-	}));
-	return success(workflows.length ? JSON.stringify(workflows, null, 2) : "No saved workflows.", { workflows });
-}
-function openDraft(store, rawName) {
-	const workflowName = rawName?.trim();
-	if (!workflowName) return failure("workflowName is required for open_draft.");
-	const catalog = createWorkflowCatalog();
-	let graph = createStarterWorkflowGraph();
-	let manifest = createStarterWorkflowManifest(workflowName);
-	let baseRevision = 0;
-	if (catalog.list().some((entry) => entry.name === workflowName)) {
-		const definition = catalog.load(workflowName);
-		graph = definition.graph;
-		manifest = {
-			title: definition.title,
-			description: definition.description,
-			version: definition.version,
-			inputSchema: definition.inputSchema,
-			outputSchema: definition.outputSchema,
-			defaults: definition.defaults,
-			tags: definition.metadata.tags,
-			whenToUse: definition.metadata.whenToUse,
-			estimatedAgents: definition.metadata.estimatedAgents,
-			examplePrompts: definition.metadata.examplePrompts,
-			i18n: definition.metadata.i18n,
-			permissions: definition.permissions,
-			resources: definition.resources,
-			connectors: definition.connectors
-		};
-		baseRevision = definition.revision;
-	}
-	const draft = store.save({
-		workflowName,
-		graph,
-		manifest,
-		baseRevision
-	});
-	return success(`Opened durable draft ${draft.id} for ${workflowName}.`, { draft });
-}
-function requireDraft(store, draftId) {
-	const id = draftId?.trim();
-	if (!id) throw new Error("draftId is required for this action.");
-	const draft = store.get(id);
-	if (!draft) throw new Error("Workflow draft not found.");
-	return draft;
-}
-function validateDraft(draft) {
-	const validation = validateWorkflowDefinitionInput({
-		name: draft.workflowName,
-		graph: draft.graph,
-		manifest: draft.manifest
-	});
-	const text = validation.valid ? `Workflow draft is valid${validation.warnings.length ? ` with ${validation.warnings.length} warning(s)` : ""}.` : `Workflow draft is invalid: ${validation.errors.map((issue) => issue.message).join(" ")}`;
-	return validation.valid ? success(text, {
-		validation,
-		updatedAtMs: draft.updatedAtMs
-	}) : failure(text, {
-		validation,
-		updatedAtMs: draft.updatedAtMs
-	});
-}
-function replaceDraft(store, draft, input) {
-	if (!input.graph) return failure("graph is required for replace_draft.");
-	if (input.expectedUpdatedAtMs === void 0) return failure("expectedUpdatedAtMs is required for replace_draft.");
-	const workflowName = input.workflowName?.trim() || draft.workflowName;
-	const manifest = input.manifest ?? draft.manifest;
-	const validation = validateWorkflowDefinitionInput({
-		name: workflowName,
-		graph: input.graph,
-		manifest
-	});
-	if (!validation.valid) return failure(`Draft was not changed. ${validation.errors.map((issue) => issue.message).join(" ")}`, { validation });
-	try {
-		const saved = store.save({
-			id: draft.id,
-			workflowName,
-			graph: input.graph,
-			manifest,
-			expectedUpdatedAtMs: input.expectedUpdatedAtMs
-		});
-		return success(`Workflow draft saved at version ${saved.updatedAtMs}.`, {
-			draft: saved,
-			validation
-		});
-	} catch (error) {
-		if (error instanceof WorkflowDraftConflictError) return failure("Draft changed since it was read. Read it again before applying changes.", {
-			code: "WORKFLOW_DRAFT_CONFLICT",
-			currentUpdatedAtMs: error.currentUpdatedAtMs
-		});
-		throw error;
-	}
-}
-function publishDraft(store, draft, expectedUpdatedAtMs, confirmed) {
-	if (confirmed !== true) return failure("Publishing requires explicit user confirmation. Ask the user to confirm this validated draft first.");
-	if (expectedUpdatedAtMs === void 0) return failure("expectedUpdatedAtMs is required for publish_draft.");
-	if (draft.updatedAtMs !== expectedUpdatedAtMs) return failure("Draft changed since it was read. Read and validate it again before publishing.", {
-		code: "WORKFLOW_DRAFT_CONFLICT",
-		currentUpdatedAtMs: draft.updatedAtMs
-	});
-	const validation = validateWorkflowDefinitionInput({
-		name: draft.workflowName,
-		graph: draft.graph,
-		manifest: draft.manifest
-	});
-	if (!validation.valid) return failure(`Workflow was not published. ${validation.errors.map((issue) => issue.message).join(" ")}`, { validation });
-	try {
-		const { definition } = createWorkflowCatalog().save({
-			name: draft.workflowName,
-			graph: draft.graph,
-			manifest: draft.manifest,
-			expectedRevision: draft.baseRevision,
-			intent: draft.baseRevision === 0 ? "create" : "update"
-		});
-		store.save({
-			...draft,
-			baseRevision: definition.revision,
-			expectedUpdatedAtMs: draft.updatedAtMs
-		});
-		const delivery = {
-			version: 2,
-			operation: draft.baseRevision === 0 ? "created" : "updated",
-			primary: {
-				kind: "workflow_definition",
-				id: definition.id,
-				title: definition.title,
-				summary: definition.description,
-				status: "ready",
-				capabilities: [
-					"open",
-					"edit",
-					"run"
-				]
-			}
-		};
-		return success(appendProductDeliveryText(`Published workflow \`${definition.name}\` revision ${definition.revision}.`, delivery), {
-			definition,
-			delivery
-		});
-	} catch (error) {
-		if (error instanceof WorkflowNameConflictError) return failure(`Workflow name "${error.workflowName}" is already in use.`, { code: "WORKFLOW_NAME_EXISTS" });
-		if (error instanceof WorkflowRevisionConflictError) return failure("The saved workflow changed. Open a fresh draft before publishing.", {
-			code: "WORKFLOW_REVISION_CONFLICT",
-			currentRevision: error.currentRevision
-		});
-		throw error;
-	}
-}
-function success(text, details) {
-	return {
-		content: [{
-			type: "text",
-			text
-		}],
-		details
-	};
-}
-function failure(message, details = {}) {
-	return {
-		content: [{
-			type: "text",
-			text: message
-		}],
-		details: {
-			error: message,
-			...details
-		}
-	};
-}
-//#endregion
-export { createWorkflowManageTool };

package/dist/src/agent/tools/workflow-tool.d.ts

@@ -1,20 +0,0 @@
-/**
- * `workflow` — starts a persisted workflow run in a dedicated chat session.
- */
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { WorkflowCatalog } from '../workflow/catalog.js';
-import type { StartWorkflowRunServiceParams, WorkflowRunServiceResult } from '../../workflows/service/workflow-run-service.types.js';
-export type WorkflowToolInput = {
-    name?: string;
-    args?: unknown;
-    goal?: string;
-    intent?: string;
-    taskRunId?: string;
-};
-export interface WorkflowToolDeps {
-    catalog: WorkflowCatalog;
-    getCurrentConversationId?: () => string | undefined;
-    getConfig: () => import('../../config/schema.js').Config | undefined;
-    startWorkflowRun?: (params: StartWorkflowRunServiceParams) => Promise<WorkflowRunServiceResult>;
-}
-export declare function createWorkflowTool(deps: WorkflowToolDeps): AgentTool;

package/dist/src/agent/tools/workflow-tool.js

@@ -1,155 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
-import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { extractProfileAgentId, resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
-import { Type } from "@sinclair/typebox";
-//#region src/agent/tools/workflow-tool.ts
-/**
-* `workflow` — starts a persisted workflow run in a dedicated chat session.
-*/
-init_src();
-init_logger();
-const log = createLogger("Agent:WorkflowTool");
-const WorkflowToolSchema = Type.Object({
-	name: Type.Optional(Type.String({ description: "Name of a saved visual workflow to run." })),
-	args: Type.Optional(Type.Any({ description: "Optional JSON value passed as workflow input payload." })),
-	goal: Type.Optional(Type.String({ description: "Optional goal or task description for this workflow run (defaults to user intent in chat)." })),
-	intent: Type.Optional(Type.String({ description: "Optional short intent used to select a suggested workflow." })),
-	taskRunId: Type.Optional(Type.String({ description: "Optional TaskRun id. When set, the workflow executes and finalizes that run." }))
-});
-function createWorkflowTool(deps) {
-	return {
-		name: "workflow",
-		label: "◆ Workflow",
-		description: [
-			"Start a multi-agent workflow run in its own chat session.",
-			"Use `name` for a workflow from the visual workflow catalog.",
-			"Returns immediately with runId + conversationId — track progress in the linked chat session."
-		].join(" "),
-		parameters: WorkflowToolSchema,
-		async execute(_toolCallId, params) {
-			if (!deps.startWorkflowRun) return {
-				content: [{
-					type: "text",
-					text: "workflow: gateway workflow runs are not available in this context"
-				}],
-				details: { error: "workflow_run_unavailable" }
-			};
-			let definitionId;
-			try {
-				definitionId = resolveDefinitionId(params, deps.catalog, deps.getConfig(), deps.getCurrentConversationId?.());
-			} catch (e) {
-				const message = e instanceof Error ? e.message : String(e);
-				return {
-					content: [{
-						type: "text",
-						text: `workflow: ${message}`
-					}],
-					details: { error: message }
-				};
-			}
-			const parentConversationId = deps.getCurrentConversationId?.()?.trim();
-			const agentId = extractProfileAgentId(parentConversationId);
-			const goal = params.goal?.trim() || "";
-			const taskRunId = params.taskRunId?.trim();
-			const source = parentConversationId ? {
-				kind: "chat",
-				conversationId: parentConversationId
-			} : { kind: "api" };
-			const inputEnvelope = taskRunId ? {
-				payload: params.args ?? {},
-				...goal ? { goal } : {}
-			} : void 0;
-			try {
-				const result = await deps.startWorkflowRun({
-					agentId,
-					definitionId,
-					goal,
-					taskRunId,
-					input: inputEnvelope ? void 0 : params.args,
-					inputEnvelope,
-					parentConversationId,
-					source
-				});
-				if (result.ok === false) return {
-					content: [{
-						type: "text",
-						text: `workflow: ${result.message}`
-					}],
-					details: { error: result.message }
-				};
-				const summary = goal ? `Started workflow \`${definitionId}\` (run ${result.runId}). Open chat session to track progress and continue.` : `Started workflow \`${definitionId}\` (run ${result.runId}). Open the workflow chat session to track progress.`;
-				const delivery = {
-					version: 2,
-					operation: "started",
-					primary: {
-						kind: "workflow_run",
-						id: result.runId,
-						title: goal || definitionId,
-						summary: `Workflow ${definitionId}`,
-						status: "running",
-						capabilities: ["open", "continue_in_chat"]
-					},
-					related: [{
-						kind: "workflow_definition",
-						id: definitionId,
-						title: definitionId,
-						capabilities: [
-							"open",
-							"edit",
-							"run"
-						]
-					}, {
-						kind: "session",
-						id: result.conversationId,
-						title: goal || definitionId,
-						capabilities: ["open", "continue_in_chat"]
-					}]
-				};
-				return {
-					content: [{
-						type: "text",
-						text: appendProductDeliveryText(`${summary}\n\nconversationId: ${result.conversationId}`, delivery)
-					}],
-					details: {
-						runId: result.runId,
-						conversationId: result.conversationId,
-						definitionId,
-						parentConversationId: parentConversationId ?? null,
-						delivery
-					}
-				};
-			} catch (e) {
-				const message = e instanceof Error ? e.message : String(e);
-				log.warn({
-					err: e,
-					errorMessage: message,
-					workflow: definitionId
-				}, `workflow start failed: ${message}`);
-				return {
-					content: [{
-						type: "text",
-						text: `workflow: ${message}`
-					}],
-					details: { error: message }
-				};
-			}
-		}
-	};
-}
-function resolveDefinitionId(params, catalog, config, conversationId) {
-	const name = params.name?.trim();
-	if (name) {
-		catalog.load(name);
-		return name;
-	}
-	const configuredDefault = config ? resolveEffectiveAgentProfileForSession(conversationId).config.workflows.default : void 0;
-	if (configuredDefault) {
-		catalog.load(configuredDefault);
-		return configuredDefault;
-	}
-	throw new Error("`name` is required because this agent has no default workflow.");
-}
-//#endregion
-export { createWorkflowTool };

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

@@ -1,5 +0,0 @@
-/**
- * Apply live subagent progress events onto a {@link WorkflowAgentSnapshot}.
- */
-import type { SubagentProgressEvent, WorkflowAgentSnapshot } from './types.js';
-export declare function applySubagentProgress(agent: WorkflowAgentSnapshot, event: SubagentProgressEvent): boolean;

package/dist/src/agent/workflow/agent-progress.js

@@ -1,65 +0,0 @@
-import { workflowStepLabel } from "./step-labels.js";
-//#region src/agent/workflow/agent-progress.ts
-const MAX_STEPS = 50;
-const MAX_STREAM_TEXT = 32e3;
-function applySubagentProgress(agent, event) {
-	switch (event.type) {
-		case "tool_start": {
-			if (!agent.steps) agent.steps = [];
-			const { label, detail } = workflowStepLabel(event.toolName, event.args);
-			const step = {
-				id: event.toolCallId,
-				kind: "tool",
-				toolName: event.toolName,
-				label,
-				detail,
-				status: "running",
-				startedAtMs: Date.now()
-			};
-			agent.steps.push(step);
-			trimSteps(agent);
-			agent.currentStep = formatCurrentStep(step);
-			return true;
-		}
-		case "tool_end": {
-			const step = findStep(agent, event.toolCallId);
-			if (!step) return false;
-			step.status = event.isError ? "error" : "done";
-			step.resultPreview = event.resultPreview;
-			step.error = event.error;
-			if (step.startedAtMs != null) step.durationMs = Date.now() - step.startedAtMs;
-			if (agent.currentStep === formatCurrentStep(step)) agent.currentStep = void 0;
-			return true;
-		}
-		case "iteration":
-			agent.iteration = event.count;
-			agent.maxIterations = event.max;
-			return true;
-		case "text_delta":
-			if (!event.delta) return false;
-			agent.streamText = appendStreamText(agent.streamText, event.delta);
-			return true;
-		case "thinking_delta":
-			if (!event.delta) return false;
-			agent.streamText = appendStreamText(agent.streamText, event.delta);
-			return true;
-		default: return false;
-	}
-}
-function findStep(agent, id) {
-	return agent.steps?.find((s) => s.id === id);
-}
-function formatCurrentStep(step) {
-	return step.detail ? `${step.label}: ${step.detail}` : step.label;
-}
-function trimSteps(agent) {
-	if (!agent.steps || agent.steps.length <= MAX_STEPS) return;
-	agent.steps = agent.steps.slice(-MAX_STEPS);
-}
-function appendStreamText(existing, delta) {
-	const next = (existing ?? "") + delta;
-	if (next.length <= MAX_STREAM_TEXT) return next;
-	return next.slice(-MAX_STREAM_TEXT);
-}
-//#endregion
-export { applySubagentProgress };

package/dist/src/agent/workflow/builtins/index.d.ts

@@ -1,2 +0,0 @@
-import type { WorkflowDefinition } from '../../../workflows/domain/definition.js';
-export declare const BUILTIN_WORKFLOWS: readonly WorkflowDefinition[];