@fevex/core 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/sandbox/index.mjs

@@ -0,0 +1,122 @@
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { relative, resolve } from "node:path";
+//#region src/sandbox/sandbox.ts
+var SandboxError = class extends Error {
+	code;
+	safeMessage;
+	name = "SandboxError";
+	constructor(code, safeMessage, options) {
+		super(safeMessage, options);
+		this.code = code;
+		this.safeMessage = safeMessage;
+	}
+};
+function sandboxResultToJson(result) {
+	return {
+		exitCode: result.exitCode,
+		stdout: result.stdout,
+		stderr: result.stderr,
+		durationMs: result.durationMs,
+		timedOut: result.timedOut
+	};
+}
+//#endregion
+//#region src/sandbox/local-sandbox.ts
+/** Creates a subprocess sandbox restricted to a root directory and command allowlist. */
+function createLocalSandbox(options) {
+	if (!options.rootDir.trim()) throw new SandboxError("SANDBOX_INVALID_CONFIG", "Sandbox rootDir must be non-empty");
+	if (!options.commands.length || options.commands.some((command) => !command.trim())) throw new SandboxError("SANDBOX_INVALID_CONFIG", "Sandbox commands allowlist must contain non-empty commands");
+	const rootDir = realpathSync(resolve(options.rootDir));
+	const allowed = new Set(options.commands);
+	const defaultTimeoutMs = options.defaultTimeoutMs ?? 1e4;
+	const maxOutputBytes = options.maxOutputBytes ?? 64e3;
+	return { async run(request) {
+		if (request.capabilities?.network) throw new SandboxError("SANDBOX_NETWORK_UNSUPPORTED", "Local sandbox does not support network access");
+		const command = request.command;
+		if (!allowed.has(command) || !request.capabilities?.process?.commands?.includes(command)) throw new SandboxError("SANDBOX_COMMAND_DENIED", `Command "${command}" is not allowed`);
+		const cwd = resolve(rootDir, request.cwd ?? request.capabilities.filesystem?.cwd ?? ".");
+		if (!isInside(rootDir, cwd)) throw new SandboxError("SANDBOX_CWD_DENIED", "Sandbox cwd must stay inside rootDir");
+		const timeoutMs = request.timeoutMs ?? request.capabilities.resources?.timeoutMs ?? request.capabilities.process.timeoutMs ?? defaultTimeoutMs;
+		const outputLimit = request.maxOutputBytes ?? request.capabilities.resources?.maxOutputBytes ?? maxOutputBytes;
+		if (!Number.isInteger(timeoutMs) || timeoutMs < 1) throw new SandboxError("SANDBOX_INVALID_REQUEST", "Sandbox timeoutMs must be positive");
+		if (!Number.isInteger(outputLimit) || outputLimit < 1) throw new SandboxError("SANDBOX_INVALID_REQUEST", "Sandbox maxOutputBytes must be positive");
+		return runProcess({
+			command,
+			args: request.args ?? [],
+			cwd,
+			env: {
+				...options.env ?? {},
+				...request.env ?? {}
+			},
+			input: request.input,
+			timeoutMs,
+			maxOutputBytes: outputLimit,
+			signal: request.signal
+		});
+	} };
+}
+async function runProcess(options) {
+	const started = Date.now();
+	let timedOut = false;
+	let stdout = "";
+	let stderr = "";
+	return await new Promise((resolvePromise, reject) => {
+		options.signal?.throwIfAborted();
+		const child = spawn(options.command, [...options.args], {
+			cwd: options.cwd,
+			env: options.env,
+			shell: false,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const abort = () => {
+			child.kill("SIGTERM");
+			reject(options.signal?.reason ?? new DOMException("Sandbox aborted", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+		}, options.timeoutMs);
+		options.signal?.addEventListener("abort", abort, { once: true });
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout = appendLimited(stdout, String(chunk), options.maxOutputBytes);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr = appendLimited(stderr, String(chunk), options.maxOutputBytes);
+		});
+		child.on("error", (error) => {
+			clearTimeout(timer);
+			options.signal?.removeEventListener("abort", abort);
+			reject(new SandboxError("SANDBOX_PROCESS_ERROR", "Sandbox process failed", { cause: error }));
+		});
+		child.on("close", (exitCode) => {
+			clearTimeout(timer);
+			options.signal?.removeEventListener("abort", abort);
+			resolvePromise({
+				exitCode,
+				stdout,
+				stderr,
+				durationMs: Date.now() - started,
+				timedOut
+			});
+		});
+		if (options.input !== void 0) child.stdin.end(options.input);
+		else child.stdin.end();
+	});
+}
+function appendLimited(current, chunk, maxBytes) {
+	const next = current + chunk;
+	return Buffer.byteLength(next) <= maxBytes ? next : next.slice(0, maxBytes);
+}
+function isInside(rootDir, value) {
+	const path = relative(rootDir, value);
+	return path === "" || !path.startsWith("..") && !resolve(path).startsWith("..");
+}
+//#endregion
+export { SandboxError, createLocalSandbox, sandboxResultToJson };

package/dist/teams/index.d.mts

@@ -0,0 +1,2 @@
+import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "../index-Bg9rr8Qe.mjs";
+export { type TeamDefinition, type TeamDelegation, type TeamHandoff, type TeamLimits, type TeamMember, type TeamStep, type TeamTaskResult, defineTeam };

package/dist/teams/index.mjs

@@ -0,0 +1,2 @@
+import { t as defineTeam } from "../teams-Ctz676G4.mjs";
+export { defineTeam };

package/dist/teams-Ctz676G4.mjs

@@ -0,0 +1,82 @@
+//#region src/teams/team.ts
+function defineTeam(team) {
+	return team;
+}
+/** @internal Compiles teams onto the existing durable workflow engine. */
+function teamAsWorkflow(team) {
+	const allowed = /* @__PURE__ */ new Set([team.supervisor, ...team.members.map(({ agent }) => agent)]);
+	const limits = team.limits && {
+		...team.limits.maxSteps === void 0 ? {} : { maxSteps: team.limits.maxSteps },
+		...team.limits.maxToolCalls === void 0 ? {} : { maxToolCalls: team.limits.maxToolCalls },
+		...team.limits.maxInputTokens === void 0 ? {} : { maxInputTokens: team.limits.maxInputTokens },
+		...team.limits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: team.limits.maxOutputTokens }
+	};
+	return {
+		name: team.name,
+		version: team.version ?? "1",
+		inputSchema: team.inputSchema,
+		outputSchema: team.outputSchema,
+		limits,
+		async run(step, input) {
+			let delegations = 0;
+			const countDelegation = () => {
+				delegations += 1;
+				if (team.limits?.maxDelegations !== void 0 && delegations > team.limits.maxDelegations) throw new Error(`Team "${team.name}" exceeded maxDelegations limit of ${team.limits.maxDelegations}`);
+			};
+			const runAgent = async (delegationId, delegation, metadata) => {
+				if (!delegationId.trim()) throw new Error("Team delegation id cannot be empty");
+				if (!allowed.has(delegation.agent)) throw new Error(`Agent "${delegation.agent}" is not a member of team "${team.name}"`);
+				if (delegation.expectedOutput !== void 0 && !delegation.expectedOutput.trim()) throw new Error("Team delegation expectedOutput cannot be empty");
+				if (delegation.constraints !== void 0 && (!Array.isArray(delegation.constraints) || delegation.constraints.some((constraint) => typeof constraint !== "string" || !constraint.trim()))) throw new Error("Team delegation constraints must be non-empty strings");
+				countDelegation();
+				const request = {
+					input: delegation.task,
+					...delegation.context === void 0 ? {} : { context: delegation.context },
+					...delegation.limits === void 0 ? {} : { limits: delegation.limits }
+				};
+				return {
+					...await step.agent(delegationId, delegation.agent, request, { metadata }),
+					delegationId,
+					agentName: delegation.agent
+				};
+			};
+			return team.run({
+				delegate(delegationId, delegation) {
+					return runAgent(delegationId, delegation, {
+						teamAction: "delegate",
+						...delegation.expectedOutput === void 0 ? {} : { expectedOutput: delegation.expectedOutput },
+						...delegation.constraints === void 0 ? {} : { constraints: delegation.constraints }
+					});
+				},
+				handoff(delegationId, handoff) {
+					if (!allowed.has(handoff.from)) throw new Error(`Agent "${handoff.from}" is not a member of team "${team.name}"`);
+					if (!handoff.reason.trim()) throw new Error("Team handoff reason cannot be empty");
+					return runAgent(delegationId, {
+						agent: handoff.to,
+						task: handoff.task,
+						context: handoff.context,
+						limits: handoff.limits,
+						expectedOutput: handoff.expectedOutput,
+						constraints: handoff.constraints
+					}, {
+						teamAction: "handoff",
+						from: handoff.from,
+						reason: handoff.reason,
+						...handoff.expectedOutput === void 0 ? {} : { expectedOutput: handoff.expectedOutput },
+						...handoff.constraints === void 0 ? {} : { constraints: handoff.constraints }
+					});
+				},
+				parallel(stepId, tasks) {
+					const width = Object.keys(tasks).length;
+					if (team.limits?.maxParallel !== void 0 && width > team.limits.maxParallel) throw new Error(`Team "${team.name}" exceeded maxParallel limit of ${team.limits.maxParallel}`);
+					return step.parallel(stepId, tasks, { metadata: {
+						teamAction: "merge",
+						width
+					} });
+				}
+			}, input);
+		}
+	};
+}
+//#endregion
+export { teamAsWorkflow as n, defineTeam as t };

package/dist/testing/index.d.mts

@@ -1,16 +1,42 @@
-import { d as ToolCall } from "../index-D_RBJmVt.mjs";
-import { ModelGateway, ModelGenerateInput, ModelGenerateResult } from "../models/index.mjs";
-//#region src/testing/index.d.ts
-interface FakeModel extends ModelGateway {
-  readonly calls: readonly ModelGenerateInput[];
-}
-declare function fakeModel(...responses: ModelGenerateResult[]): FakeModel;
+import { m as ToolCall } from "../types-CuoRx12Q.mjs";
+import { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-CTIwrVf9.mjs";
+import { p as DurableRunStore } from "../index-Dx_LotWZ.mjs";
+import { s as MemoryStore } from "../index-DeXUtyd9.mjs";
+import { d as ToolProvider } from "../index-CqOjvtQ9.mjs";
+import { c as ChannelMessage, l as ChannelOutput, n as ChannelAdapter } from "../index-Bgcxgy66.mjs";
+//#region src/testing/contracts.d.ts
 interface ModelGatewayContract {
   output?: unknown;
   toolCall?: ToolCall;
   usage?: boolean;
   error?: Error;
 }
+interface ChannelAdapterContract<TInput, TOutput> {
+  input: TInput;
+  message: ChannelMessage;
+  output: ChannelOutput;
+  delivered: TOutput;
+  ignoredInput?: TInput;
+}
+interface ToolProviderContract {
+  allowedTool: string;
+  input?: unknown;
+  output?: unknown;
+  disallowedTool?: string;
+  safeError?: boolean;
+  timeout?: boolean;
+}
+declare function testMemoryStore(store: MemoryStore): Promise<void>;
+declare function testToolProvider(provider: ToolProvider, contract: ToolProviderContract): Promise<void>;
+declare function testChannelAdapter<TInput, TOutput>(adapter: ChannelAdapter<TInput, TOutput>, contract: ChannelAdapterContract<TInput, TOutput>): Promise<void>;
 declare function testModelGateway(model: ModelGateway, contract?: ModelGatewayContract): Promise<void>;
+declare function testRunStore(store: DurableRunStore): Promise<void>;
+//#endregion
+//#region src/testing/fake-model.d.ts
+interface FakeModel extends ModelGateway {
+  readonly calls: readonly ModelInput[];
+}
+/** Creates a deterministic model gateway for unit tests. */
+declare function fakeModel(...responses: ModelResult[]): FakeModel;
 //#endregion
-export { FakeModel, ModelGatewayContract, fakeModel, testModelGateway };
+export { ChannelAdapterContract, FakeModel, ModelGatewayContract, ToolProviderContract, fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRunStore, testToolProvider };