@xopcai/xopc 0.0.329 → 0.0.330

package/dist/src/workflows/draft/workflow-draft-service.js

@@ -1,125 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
-import { getDefaultModelSync, init_providers, resolveModel } from "../../providers/index.js";
-import { completeWithResolvedCredentials } from "../../providers/model-call.js";
-import { resolveModelSelector } from "../../config/agent-model-intents.js";
-import { buildWorkflowDraftPrompt, buildWorkflowDraftRepairPrompt } from "./workflow-draft-prompt.js";
-import { buildWorkflowDraftResponse, parseGeneratedWorkflowDraft } from "./workflow-draft-validator.js";
-//#region src/workflows/draft/workflow-draft-service.ts
-init_schema();
-init_providers();
-init_logger();
-const log = createLogger("WorkflowDraft");
-const DEFAULT_MAX_REPAIR_ATTEMPTS = 2;
-var WorkflowDraftService = class {
-	constructor(options) {
-		this.options = options;
-	}
-	async createDraft(request, signal) {
-		const prompt = request.prompt.trim();
-		if (!prompt) throw new Error("prompt is required");
-		const modelRef = resolveDraftModelRef(this.options.config, request.agentId);
-		const model = resolveModel(modelRef);
-		const maxRepairAttempts = this.options.maxRepairAttempts ?? DEFAULT_MAX_REPAIR_ATTEMPTS;
-		let messageContent = buildWorkflowDraftPrompt({
-			prompt,
-			language: request.language,
-			mode: request.mode ?? (request.existingGraph ? "improve" : "create"),
-			existingGraph: request.existingGraph,
-			constraints: request.constraints
-		});
-		let lastIssues = [];
-		let lastText = "";
-		for (let attempt = 0; attempt <= maxRepairAttempts; attempt += 1) {
-			lastText = extractText(await completeWithResolvedCredentials(model, { messages: [{
-				role: "user",
-				content: messageContent,
-				timestamp: Date.now()
-			}] }, {
-				maxTokens: 4096,
-				temperature: attempt === 0 ? .25 : .1,
-				signal
-			}));
-			try {
-				const response = buildWorkflowDraftResponse(parseGeneratedWorkflowDraft(lastText), request.constraints);
-				const blockingIssues = getBlockingDraftIssues(response);
-				if (blockingIssues.length === 0) return {
-					...response,
-					repairAttempts: attempt
-				};
-				lastIssues = blockingIssues;
-			} catch (err) {
-				lastIssues = [{
-					source: "parse",
-					severity: "error",
-					code: "invalid_model_output",
-					message: err instanceof Error ? err.message : String(err)
-				}];
-			}
-			if (attempt >= maxRepairAttempts) break;
-			log.warn({
-				modelRef,
-				attempt: attempt + 1,
-				issueCount: lastIssues.length,
-				preview: lastText.slice(0, 500)
-			}, "Workflow draft validation failed; asking model to repair");
-			messageContent = buildWorkflowDraftRepairPrompt({
-				prompt,
-				language: request.language,
-				constraints: request.constraints,
-				previousOutput: lastText,
-				issues: lastIssues
-			});
-		}
-		const message = `Unable to generate a valid workflow draft after ${maxRepairAttempts + 1} attempts: ${formatRepairIssues(lastIssues)}`;
-		log.warn({
-			modelRef,
-			issues: lastIssues,
-			preview: lastText.slice(0, 500)
-		}, message);
-		throw new Error(message);
-	}
-};
-function resolveDraftModelRef(config, agentId) {
-	try {
-		return resolveModelSelector(config, agentId, "reasoning");
-	} catch {
-		return getAgentDefaultModelRef() ?? getDefaultModelSync(config);
-	}
-}
-function extractText(result) {
-	const content = result.content;
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) return content.map((item) => {
-		if (item && typeof item === "object" && item.type === "text") return String(item.text ?? "");
-		return "";
-	}).join("");
-	return "";
-}
-function getBlockingDraftIssues(response) {
-	const validationIssues = [...response.validation.errors.map((issue) => ({
-		source: "validation",
-		severity: "error",
-		code: issue.code,
-		message: issue.message
-	})), ...response.validation.warnings.map((issue) => ({
-		source: "validation",
-		severity: "warning",
-		code: issue.code,
-		message: issue.message
-	}))];
-	const lintIssues = response.lint.filter((issue) => issue.severity === "error").map((issue) => ({
-		source: "lint",
-		severity: issue.severity,
-		code: issue.code,
-		message: issue.message
-	}));
-	return [...validationIssues, ...lintIssues];
-}
-function formatRepairIssues(issues) {
-	if (issues.length === 0) return "unknown validation failure";
-	return issues.slice(0, 5).map((issue) => `${issue.source}:${issue.code}: ${issue.message}`).join("; ");
-}
-//#endregion
-export { WorkflowDraftService, resolveDraftModelRef };

package/dist/src/workflows/draft/workflow-draft-validator.d.ts

@@ -1,4 +0,0 @@
-import type { GeneratedWorkflowDraft, WorkflowDraftConstraints, WorkflowDraftLintIssue, WorkflowDraftResponse } from './workflow-draft.types.js';
-export declare function parseGeneratedWorkflowDraft(raw: string): GeneratedWorkflowDraft;
-export declare function buildWorkflowDraftResponse(draft: GeneratedWorkflowDraft, constraints?: WorkflowDraftConstraints): WorkflowDraftResponse;
-export declare function lintWorkflowDraft(draft: GeneratedWorkflowDraft, constraints?: WorkflowDraftConstraints): WorkflowDraftLintIssue[];

package/dist/src/workflows/draft/workflow-draft-validator.js

@@ -1,123 +0,0 @@
-import { validateWorkflowDefinitionInput } from "../domain/validation.js";
-import { randomUUID } from "node:crypto";
-//#region src/workflows/draft/workflow-draft-validator.ts
-function parseGeneratedWorkflowDraft(raw) {
-	const parsed = JSON.parse(extractJsonObject(raw));
-	return {
-		name: normalizeWorkflowName(String(parsed.name ?? "custom_workflow")),
-		graph: normalizeGraph(parsed.graph),
-		manifest: normalizeManifest(parsed.manifest),
-		explanation: String(parsed.explanation ?? ""),
-		assumptions: stringArray(parsed.assumptions),
-		risks: stringArray(parsed.risks)
-	};
-}
-function buildWorkflowDraftResponse(draft, constraints) {
-	const validation = validateWorkflowDefinitionInput({
-		name: draft.name,
-		graph: draft.graph
-	});
-	return {
-		draftId: randomUUID(),
-		repairAttempts: 0,
-		...draft,
-		permissionsSummary: summarizePermissions(draft.manifest),
-		validation,
-		lint: lintWorkflowDraft(draft, constraints),
-		suggestedInputs: suggestedInputsFromManifest(draft.manifest)
-	};
-}
-function lintWorkflowDraft(draft, constraints) {
-	const issues = [];
-	const { manifest, graph } = draft;
-	if (!manifest.inputSchema) issues.push({
-		severity: "warning",
-		code: "missing_input_schema",
-		message: "Draft does not define an input schema."
-	});
-	if (!manifest.outputSchema) issues.push({
-		severity: "warning",
-		code: "missing_output_schema",
-		message: "Draft does not define an output schema."
-	});
-	if (manifest.permissions?.network && constraints?.allowNetwork === false) issues.push({
-		severity: "error",
-		code: "unsafe_permission",
-		message: "Draft requests network access, but network is disabled."
-	});
-	if (manifest.permissions?.fileSystem === "write" && constraints?.fileSystem !== "write") issues.push({
-		severity: "warning",
-		code: "unsafe_permission",
-		message: "Draft requests filesystem write access."
-	});
-	const phases = new Set(graph.nodes.map((node) => node.phaseId).filter(Boolean));
-	if (constraints?.maxPhases && phases.size > constraints.maxPhases) issues.push({
-		severity: "warning",
-		code: "too_many_agents",
-		message: `Draft has ${phases.size} phases, above the requested maximum.`
-	});
-	const agents = graph.nodes.filter((node) => node.kind === "agent");
-	if (constraints?.maxSubagents && agents.length > constraints.maxSubagents) issues.push({
-		severity: "warning",
-		code: "too_many_agents",
-		message: `Draft has ${agents.length} agents, above the requested maximum.`
-	});
-	if (constraints?.allowedTools?.length) {
-		const unknown = agents.flatMap((node) => node.config.toolset ?? []).filter((tool) => !constraints.allowedTools.includes(tool));
-		for (const tool of [...new Set(unknown)]) issues.push({
-			severity: "warning",
-			code: "unknown_tool",
-			message: `Tool '${tool}' is outside the requested allowlist.`
-		});
-	}
-	return issues;
-}
-function extractJsonObject(raw) {
-	const trimmed = raw.trim();
-	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
-	const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1]?.trim();
-	if (fenced?.startsWith("{")) return fenced;
-	const start = trimmed.indexOf("{");
-	const end = trimmed.lastIndexOf("}");
-	if (start >= 0 && end > start) return trimmed.slice(start, end + 1);
-	throw new Error("Model did not return a JSON object.");
-}
-function normalizeGraph(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return {
-		schemaVersion: 1,
-		nodes: [],
-		edges: []
-	};
-	return value;
-}
-function normalizeManifest(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function stringArray(value) {
-	return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
-}
-function normalizeWorkflowName(value) {
-	const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-	return /^[a-z]/.test(normalized) ? normalized : `workflow_${normalized || "draft"}`;
-}
-function summarizePermissions(manifest) {
-	const permissions = manifest.permissions;
-	if (!permissions) return ["No explicit permissions requested."];
-	const values = [];
-	if (permissions.tools?.length) values.push(`Tools: ${permissions.tools.join(", ")}`);
-	if (permissions.network != null) values.push(`Network: ${permissions.network ? "enabled" : "disabled"}`);
-	if (permissions.fileSystem) values.push(`Filesystem: ${permissions.fileSystem}`);
-	if (permissions.approvalRequired) values.push("Approval required");
-	return values.length ? values : ["No explicit permissions requested."];
-}
-function suggestedInputsFromManifest(manifest) {
-	const properties = manifest.inputSchema?.properties;
-	if (!properties) return void 0;
-	return Object.entries(properties).slice(0, 8).map(([key, schema]) => ({
-		key,
-		label: typeof schema.title === "string" ? schema.title : key,
-		example: typeof schema.default === "string" ? schema.default : schema.description ?? ""
-	}));
-}
-//#endregion
-export { buildWorkflowDraftResponse, lintWorkflowDraft, parseGeneratedWorkflowDraft };

package/dist/src/workflows/draft/workflow-draft.types.d.ts

@@ -1,44 +0,0 @@
-import type { WorkflowDefinitionManifest, WorkflowGraph } from '../domain/definition.js';
-import type { WorkflowDefinitionValidationResult } from '../domain/validation.js';
-export type WorkflowDraftMode = 'create' | 'improve';
-export interface WorkflowDraftConstraints {
-    allowedTools?: string[];
-    allowNetwork?: boolean;
-    fileSystem?: 'none' | 'read' | 'write';
-    maxPhases?: number;
-    maxSubagents?: number;
-    outputFormat?: 'report' | 'json' | 'actions';
-}
-export interface CreateWorkflowDraftRequest {
-    prompt: string;
-    agentId: string;
-    language?: 'en' | 'zh';
-    mode?: WorkflowDraftMode;
-    existingGraph?: WorkflowGraph;
-    constraints?: WorkflowDraftConstraints;
-}
-export interface WorkflowDraftLintIssue {
-    severity: 'error' | 'warning';
-    code: 'missing_input_schema' | 'missing_output_schema' | 'unsafe_permission' | 'too_many_agents' | 'unknown_tool' | 'weak_phase_names';
-    message: string;
-}
-export interface GeneratedWorkflowDraft {
-    name: string;
-    graph: WorkflowGraph;
-    manifest: WorkflowDefinitionManifest;
-    explanation: string;
-    assumptions: string[];
-    risks: string[];
-}
-export interface WorkflowDraftResponse extends GeneratedWorkflowDraft {
-    draftId: string;
-    repairAttempts: number;
-    permissionsSummary: string[];
-    validation: WorkflowDefinitionValidationResult;
-    lint: WorkflowDraftLintIssue[];
-    suggestedInputs?: Array<{
-        key: string;
-        label: string;
-        example: string;
-    }>;
-}

package/dist/src/workflows/draft/workflow-draft.types.js

@@ -1 +0,0 @@
-export {};