minimal-agent 0.12.0 → 0.14.0

package/plugins/workflow-runner/src/runtime/exec.js

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process';
+import { isAbsolute, resolve } from 'node:path';
+export async function executeWorkflowFile(path, args, options, runtime) {
+    const target = isAbsolute(path)
+        ? path
+        : resolve(runtime.workflowDir || runtime.cwd, path);
+    const script = /\.(?:mjs|cjs|js)$/i.test(target);
+    const executable = script ? process.execPath : target;
+    const commandArgs = script ? [target, ...args.map(String)] : args.map(String);
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(executable, commandArgs, {
+            cwd: options.cwd ? resolve(runtime.cwd, options.cwd) : runtime.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: 'pipe',
+            signal: runtime.signal,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.setEncoding('utf8').on('data', (value) => (stdout += value));
+        child.stderr?.setEncoding('utf8').on('data', (value) => (stderr += value));
+        child.on('error', reject);
+        let timer;
+        child.on('close', (code) => {
+            if (timer)
+                clearTimeout(timer);
+            resolvePromise({ stdout, stderr, exitCode: code ?? 1 });
+        });
+        child.stdin?.end(options.input);
+        if (options.timeoutMs !== undefined) {
+            timer = setTimeout(() => child.kill(), options.timeoutMs);
+            timer.unref();
+        }
+    });
+}

package/plugins/workflow-runner/src/runtime/exec.ts

@@ -0,0 +1,53 @@
+import { spawn } from 'node:child_process';
+import { isAbsolute, resolve } from 'node:path';
+
+export interface WorkflowFileOptions {
+  cwd?: string;
+  input?: string;
+  timeoutMs?: number;
+  env?: Record<string, string>;
+}
+
+export interface WorkflowProcessResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export async function executeWorkflowFile(
+  path: string,
+  args: string[],
+  options: WorkflowFileOptions,
+  runtime: { cwd: string; workflowDir: string; signal?: AbortSignal },
+): Promise<WorkflowProcessResult> {
+  const target = isAbsolute(path)
+    ? path
+    : resolve(runtime.workflowDir || runtime.cwd, path);
+  const script = /\.(?:mjs|cjs|js)$/i.test(target);
+  const executable = script ? process.execPath : target;
+  const commandArgs = script ? [target, ...args.map(String)] : args.map(String);
+
+  return new Promise<WorkflowProcessResult>((resolvePromise, reject) => {
+    const child = spawn(executable, commandArgs, {
+      cwd: options.cwd ? resolve(runtime.cwd, options.cwd) : runtime.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: 'pipe',
+      signal: runtime.signal,
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.setEncoding('utf8').on('data', (value) => (stdout += value));
+    child.stderr?.setEncoding('utf8').on('data', (value) => (stderr += value));
+    child.on('error', reject);
+    let timer: NodeJS.Timeout | undefined;
+    child.on('close', (code) => {
+      if (timer) clearTimeout(timer);
+      resolvePromise({ stdout, stderr, exitCode: code ?? 1 });
+    });
+    child.stdin?.end(options.input);
+    if (options.timeoutMs !== undefined) {
+      timer = setTimeout(() => child.kill(), options.timeoutMs);
+      timer.unref();
+    }
+  });
+}

package/plugins/workflow-runner/src/runtime/flow.js

@@ -0,0 +1,8 @@
+export function structuredWorkflowError(error) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    return {
+        name: normalized.name,
+        message: normalized.message,
+        ...('code' in normalized ? { code: String(normalized.code) } : {}),
+    };
+}

package/plugins/workflow-runner/src/runtime/flow.ts

@@ -0,0 +1,12 @@
+export function structuredWorkflowError(error: unknown): {
+  name: string;
+  message: string;
+  code?: string;
+} {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  return {
+    name: normalized.name,
+    message: normalized.message,
+    ...('code' in normalized ? { code: String(normalized.code) } : {}),
+  };
+}

package/plugins/workflow-runner/src/runtime/fs.js

@@ -0,0 +1,27 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+export function resolveWorkflowPath(cwd, path) {
+    return isAbsolute(path) ? path : resolve(cwd, path);
+}
+export async function atomicWriteText(cwd, path, content) {
+    const target = resolveWorkflowPath(cwd, path);
+    await mkdir(dirname(target), { recursive: true });
+    const temp = `${target}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+        await writeFile(temp, content, 'utf8');
+        await rename(temp, target);
+    }
+    finally {
+        await rm(temp, { force: true }).catch(() => undefined);
+    }
+    return target;
+}
+export async function atomicWriteJson(cwd, path, value) {
+    return atomicWriteText(cwd, path, `${JSON.stringify(value, null, 2)}\n`);
+}
+export async function ensureWorkflowDir(cwd, path) {
+    const target = resolveWorkflowPath(cwd, path);
+    await mkdir(target, { recursive: true });
+    return target;
+}

package/plugins/workflow-runner/src/runtime/fs.ts

@@ -0,0 +1,41 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+
+export function resolveWorkflowPath(cwd: string, path: string): string {
+  return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
+export async function atomicWriteText(
+  cwd: string,
+  path: string,
+  content: string,
+): Promise<string> {
+  const target = resolveWorkflowPath(cwd, path);
+  await mkdir(dirname(target), { recursive: true });
+  const temp = `${target}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    await writeFile(temp, content, 'utf8');
+    await rename(temp, target);
+  } finally {
+    await rm(temp, { force: true }).catch(() => undefined);
+  }
+  return target;
+}
+
+export async function atomicWriteJson(
+  cwd: string,
+  path: string,
+  value: unknown,
+): Promise<string> {
+  return atomicWriteText(cwd, path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function ensureWorkflowDir(
+  cwd: string,
+  path: string,
+): Promise<string> {
+  const target = resolveWorkflowPath(cwd, path);
+  await mkdir(target, { recursive: true });
+  return target;
+}

package/plugins/workflow-runner/src/runtime/model.js

@@ -0,0 +1,6 @@
+export function assertWorkflowTimeout(timeoutMs) {
+    if (timeoutMs !== undefined &&
+        (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+        throw new Error('timeoutMs 必须为正的有限毫秒数');
+    }
+}

package/plugins/workflow-runner/src/runtime/model.ts

@@ -0,0 +1,8 @@
+export function assertWorkflowTimeout(timeoutMs: number | undefined): void {
+  if (
+    timeoutMs !== undefined &&
+    (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+  ) {
+    throw new Error('timeoutMs 必须为正的有限毫秒数');
+  }
+}

package/plugins/workflow-runner/src/runtime/output.js

@@ -0,0 +1,7 @@
+export function workflowProgressEvent(identity, update) {
+    return {
+        type: 'workflow_progress',
+        ...identity,
+        ...update,
+    };
+}

package/plugins/workflow-runner/src/runtime/output.ts

@@ -0,0 +1,21 @@
+import type { LoopEvent } from '../../../../src/plugin-sdk.js';
+
+export interface WorkflowEventIdentity {
+  workflow: string;
+  runId: string;
+  rootRunId: string;
+  parentRunId?: string;
+  depth: number;
+}
+
+export function workflowProgressEvent(
+  identity: WorkflowEventIdentity,
+  update: Omit<Extract<LoopEvent, { type: 'workflow_progress' }>,
+    'type' | 'workflow' | 'runId' | 'rootRunId' | 'parentRunId' | 'depth'>,
+): Extract<LoopEvent, { type: 'workflow_progress' }> {
+  return {
+    type: 'workflow_progress',
+    ...identity,
+    ...update,
+  };
+}

package/plugins/workflow-runner/src/runtime/scheduler.js

@@ -0,0 +1,141 @@
+import { readWorkflowRuntimeConfig } from './config.js';
+/** FIFO between requests of one run, round-robin between workflow roots. */
+class FairPool {
+    limit;
+    active = 0;
+    queues = new Map();
+    roots = [];
+    cursor = 0;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    acquire(rootRunId, signal) {
+        signal?.throwIfAborted();
+        if (this.active < this.limit && this.queues.size === 0) {
+            this.active++;
+            return Promise.resolve(this.lease(0));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                signal,
+                queuedAt: Date.now(),
+            };
+            let queue = this.queues.get(rootRunId);
+            if (!queue) {
+                queue = [];
+                this.queues.set(rootRunId, queue);
+                this.roots.push(rootRunId);
+            }
+            queue.push(waiter);
+            const abort = () => {
+                const current = this.queues.get(rootRunId);
+                const index = current?.indexOf(waiter) ?? -1;
+                if (index >= 0)
+                    current.splice(index, 1);
+                this.prune(rootRunId);
+                reject(signal?.reason ?? Object.assign(new Error('已取消'), { name: 'AbortError' }));
+            };
+            signal?.addEventListener('abort', abort, { once: true });
+            const originalResolve = waiter.resolve;
+            waiter.resolve = (lease) => {
+                signal?.removeEventListener('abort', abort);
+                originalResolve(lease);
+            };
+        });
+    }
+    async run(rootRunId, fn, signal) {
+        const lease = await this.acquire(rootRunId, signal);
+        try {
+            signal?.throwIfAborted();
+            return await fn(lease.queuedMs);
+        }
+        finally {
+            lease.release();
+        }
+    }
+    lease(queuedMs) {
+        let released = false;
+        return {
+            queuedMs,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.dispatch();
+            },
+        };
+    }
+    dispatch() {
+        const next = this.takeNext();
+        if (!next) {
+            this.active--;
+            return;
+        }
+        next.resolve(this.lease(Date.now() - next.queuedAt));
+    }
+    takeNext() {
+        while (this.roots.length > 0) {
+            if (this.cursor >= this.roots.length)
+                this.cursor = 0;
+            const root = this.roots[this.cursor];
+            const queue = this.queues.get(root);
+            if (!queue?.length) {
+                this.prune(root);
+                continue;
+            }
+            const waiter = queue.shift();
+            if (queue.length === 0)
+                this.prune(root);
+            else
+                this.cursor = (this.cursor + 1) % this.roots.length;
+            if (waiter.signal?.aborted) {
+                waiter.reject(waiter.signal.reason);
+                continue;
+            }
+            return waiter;
+        }
+        return null;
+    }
+    prune(root) {
+        const queue = this.queues.get(root);
+        if (queue?.length)
+            return;
+        this.queues.delete(root);
+        const index = this.roots.indexOf(root);
+        if (index < 0)
+            return;
+        this.roots.splice(index, 1);
+        if (index < this.cursor)
+            this.cursor--;
+        if (this.cursor >= this.roots.length)
+            this.cursor = 0;
+    }
+}
+export class WorkflowScheduler {
+    config;
+    pools;
+    constructor(config = readWorkflowRuntimeConfig()) {
+        this.config = config;
+        this.pools = {
+            root: new FairPool(config.maxActiveRuns),
+            model: new FairPool(config.modelConcurrency),
+            tool: new FairPool(config.toolConcurrency),
+            process: new FairPool(config.processConcurrency),
+        };
+    }
+    acquire(resource, rootRunId, signal) {
+        return this.pools[resource].acquire(rootRunId, signal);
+    }
+    run(resource, rootRunId, fn, signal) {
+        return this.pools[resource].run(rootRunId, fn, signal);
+    }
+}
+let shared;
+export function sharedWorkflowScheduler() {
+    return (shared ??= new WorkflowScheduler());
+}
+export function resetWorkflowSchedulerForTests() {
+    shared = undefined;
+}

package/plugins/workflow-runner/src/runtime/scheduler.ts

@@ -0,0 +1,166 @@
+import { readWorkflowRuntimeConfig, type WorkflowRuntimeConfig } from './config.js';
+
+export type WorkflowResource = 'root' | 'model' | 'tool' | 'process';
+
+interface Waiter {
+  resolve: (lease: SchedulerLease) => void;
+  reject: (error: unknown) => void;
+  signal?: AbortSignal;
+  queuedAt: number;
+}
+
+export interface SchedulerLease {
+  queuedMs: number;
+  release(): void;
+}
+
+/** FIFO between requests of one run, round-robin between workflow roots. */
+class FairPool {
+  private active = 0;
+  private readonly queues = new Map<string, Waiter[]>();
+  private roots: string[] = [];
+  private cursor = 0;
+
+  constructor(readonly limit: number) {}
+
+  acquire(rootRunId: string, signal?: AbortSignal): Promise<SchedulerLease> {
+    signal?.throwIfAborted();
+    if (this.active < this.limit && this.queues.size === 0) {
+      this.active++;
+      return Promise.resolve(this.lease(0));
+    }
+    return new Promise<SchedulerLease>((resolve, reject) => {
+      const waiter: Waiter = {
+        resolve,
+        reject,
+        signal,
+        queuedAt: Date.now(),
+      };
+      let queue = this.queues.get(rootRunId);
+      if (!queue) {
+        queue = [];
+        this.queues.set(rootRunId, queue);
+        this.roots.push(rootRunId);
+      }
+      queue.push(waiter);
+      const abort = () => {
+        const current = this.queues.get(rootRunId);
+        const index = current?.indexOf(waiter) ?? -1;
+        if (index >= 0) current!.splice(index, 1);
+        this.prune(rootRunId);
+        reject(signal?.reason ?? Object.assign(new Error('已取消'), { name: 'AbortError' }));
+      };
+      signal?.addEventListener('abort', abort, { once: true });
+      const originalResolve = waiter.resolve;
+      waiter.resolve = (lease) => {
+        signal?.removeEventListener('abort', abort);
+        originalResolve(lease);
+      };
+    });
+  }
+
+  async run<T>(
+    rootRunId: string,
+    fn: (queuedMs: number) => Promise<T>,
+    signal?: AbortSignal,
+  ): Promise<T> {
+    const lease = await this.acquire(rootRunId, signal);
+    try {
+      signal?.throwIfAborted();
+      return await fn(lease.queuedMs);
+    } finally {
+      lease.release();
+    }
+  }
+
+  private lease(queuedMs: number): SchedulerLease {
+    let released = false;
+    return {
+      queuedMs,
+      release: () => {
+        if (released) return;
+        released = true;
+        this.dispatch();
+      },
+    };
+  }
+
+  private dispatch(): void {
+    const next = this.takeNext();
+    if (!next) {
+      this.active--;
+      return;
+    }
+    next.resolve(this.lease(Date.now() - next.queuedAt));
+  }
+
+  private takeNext(): Waiter | null {
+    while (this.roots.length > 0) {
+      if (this.cursor >= this.roots.length) this.cursor = 0;
+      const root = this.roots[this.cursor]!;
+      const queue = this.queues.get(root);
+      if (!queue?.length) {
+        this.prune(root);
+        continue;
+      }
+      const waiter = queue.shift()!;
+      if (queue.length === 0) this.prune(root);
+      else this.cursor = (this.cursor + 1) % this.roots.length;
+      if (waiter.signal?.aborted) {
+        waiter.reject(waiter.signal.reason);
+        continue;
+      }
+      return waiter;
+    }
+    return null;
+  }
+
+  private prune(root: string): void {
+    const queue = this.queues.get(root);
+    if (queue?.length) return;
+    this.queues.delete(root);
+    const index = this.roots.indexOf(root);
+    if (index < 0) return;
+    this.roots.splice(index, 1);
+    if (index < this.cursor) this.cursor--;
+    if (this.cursor >= this.roots.length) this.cursor = 0;
+  }
+}
+
+export class WorkflowScheduler {
+  readonly config: WorkflowRuntimeConfig;
+  private readonly pools: Record<WorkflowResource, FairPool>;
+
+  constructor(config: WorkflowRuntimeConfig = readWorkflowRuntimeConfig()) {
+    this.config = config;
+    this.pools = {
+      root: new FairPool(config.maxActiveRuns),
+      model: new FairPool(config.modelConcurrency),
+      tool: new FairPool(config.toolConcurrency),
+      process: new FairPool(config.processConcurrency),
+    };
+  }
+
+  acquire(resource: WorkflowResource, rootRunId: string, signal?: AbortSignal) {
+    return this.pools[resource].acquire(rootRunId, signal);
+  }
+
+  run<T>(
+    resource: WorkflowResource,
+    rootRunId: string,
+    fn: (queuedMs: number) => Promise<T>,
+    signal?: AbortSignal,
+  ) {
+    return this.pools[resource].run(rootRunId, fn, signal);
+  }
+}
+
+let shared: WorkflowScheduler | undefined;
+export function sharedWorkflowScheduler(): WorkflowScheduler {
+  return (shared ??= new WorkflowScheduler());
+}
+
+export function resetWorkflowSchedulerForTests(): void {
+  shared = undefined;
+}
+

package/plugins/workflow-runner/src/runtime/state.js

@@ -0,0 +1,16 @@
+export function workflowBudget(ctx) {
+    const ledger = ctx.resourceLedger;
+    const inputTokens = ledger?.inputTokens ?? 0;
+    const outputTokens = ledger?.outputTokens ?? 0;
+    const used = inputTokens + outputTokens;
+    const limit = ledger?.limit ?? null;
+    return {
+        used,
+        inputTokens,
+        outputTokens,
+        limit,
+        remaining: limit === null ? Number.POSITIVE_INFINITY : Math.max(0, limit - used),
+        exhausted: limit !== null && used >= limit,
+        trustworthy: ledger?.trustworthy ?? true,
+    };
+}

package/plugins/workflow-runner/src/runtime/state.ts

@@ -0,0 +1,19 @@
+import type { RunContext } from '../types.js';
+
+export function workflowBudget(ctx: RunContext) {
+  const ledger = ctx.resourceLedger;
+  const inputTokens = ledger?.inputTokens ?? 0;
+  const outputTokens = ledger?.outputTokens ?? 0;
+  const used = inputTokens + outputTokens;
+  const limit = ledger?.limit ?? null;
+  return {
+    used,
+    inputTokens,
+    outputTokens,
+    limit,
+    remaining:
+      limit === null ? Number.POSITIVE_INFINITY : Math.max(0, limit - used),
+    exhausted: limit !== null && used >= limit,
+    trustworthy: ledger?.trustworthy ?? true,
+  };
+}

package/plugins/workflow-runner/src/runtime/tools.js

@@ -0,0 +1,3 @@
+export function unknownToolNames(requested, known) {
+    return requested.filter((name) => !known.has(name));
+}

package/plugins/workflow-runner/src/runtime/tools.ts

@@ -0,0 +1,6 @@
+export function unknownToolNames(
+  requested: readonly string[],
+  known: ReadonlySet<string>,
+): string[] {
+  return requested.filter((name) => !known.has(name));
+}