minimal-agent 0.13.0 → 0.14.0

package/plugins/workflow-runner/test/resourceInputs.test.ts

@@ -0,0 +1,294 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import type { InvocationResource } from '../../../src/plugin-sdk.js';
+import {
+  bindResourceInputs,
+  materializeResources,
+} from '../src/resourceInputs.js';
+
+const imageDef = {
+  name: 'source',
+  type: 'resource' as const,
+  required: true,
+  accepts: ['image/*'],
+  allowFile: true,
+  allowDirectory: true,
+  multiple: true,
+  attachmentFallback: true,
+};
+
+describe('workflow resource inputs', () => {
+  test('binds compatible Desktop attachments and materializes multiple files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const a = join(root, 'a.jpg');
+      const b = join(root, 'b.png');
+      await writeFile(a, 'a');
+      await writeFile(b, 'b');
+      const attachments: InvocationResource[] = [
+        {
+          id: 'a',
+          origin: 'attachment',
+          name: 'a.jpg',
+          mime: 'image/jpeg',
+          size: 1,
+          sha256: 'sha-a',
+          localPath: a,
+          kind: 'file',
+        },
+        {
+          id: 'b',
+          origin: 'attachment',
+          name: 'b.png',
+          mime: 'image/png',
+          size: 1,
+          sha256: 'sha-b',
+          localPath: b,
+          kind: 'file',
+        },
+      ];
+      const bound = await bindResourceInputs({
+        workflowName: 'wrong-question-docx',
+        sessionId: 's1',
+        rawInputs: {},
+        defs: [imageDef],
+        attachments,
+      });
+      expect(typeof bound.inputs.source).toBe('string');
+      expect(bound.resourceMap.source).toHaveLength(2);
+      expect(bound.resourceIdentity).toEqual(['source:sha-a', 'source:sha-b']);
+      const staged = String(bound.inputs.source);
+      expect(await readFile(join(staged, '001-a.jpg'), 'utf8')).toBe('a');
+      expect(await readFile(join(staged, '002-b.png'), 'utf8')).toBe('b');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('explicit path wins over attachments', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const path = join(root, 'paper.jpg');
+      await writeFile(path, 'paper');
+      const bound = await bindResourceInputs({
+        workflowName: 'wrong-question-docx',
+        sessionId: 's1',
+        rawInputs: { source: path },
+        defs: [imageDef],
+        attachments: [
+          {
+            id: 'other',
+            origin: 'attachment',
+            name: 'other.jpg',
+            mime: 'image/jpeg',
+            localPath: path,
+            kind: 'file',
+          },
+        ],
+      });
+      expect(bound.inputs.source).toBe(path);
+      expect(bound.resourceMap.source?.[0]?.origin).toBe('path');
+      expect(bound.warnings).toHaveLength(0);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('relative explicit paths resolve from the workflow cwd', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      await writeFile(join(root, 'paper.jpg'), 'paper');
+      const bound = await bindResourceInputs({
+        workflowName: 'wrong-question-docx',
+        sessionId: 's1',
+        cwd: root,
+        rawInputs: { source: 'paper.jpg' },
+        defs: [imageDef],
+      });
+      expect(bound.inputs.source).toBe(join(root, 'paper.jpg'));
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('directory materialization stages even one Desktop file', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const file = join(root, 'one.jpg');
+      await writeFile(file, 'one');
+      const bound = await bindResourceInputs({
+        workflowName: 'e2e-vision-schema',
+        sessionId: 's1',
+        rawInputs: {},
+        defs: [
+          {
+            ...imageDef,
+            name: 'dir',
+            allowFile: false,
+            materialize: 'directory',
+          },
+        ],
+        attachments: [
+          {
+            id: 'one',
+            origin: 'attachment',
+            name: 'one.jpg',
+            mime: 'image/jpeg',
+            sha256: 'sha-one',
+            localPath: file,
+            kind: 'file',
+          },
+        ],
+      });
+      expect(
+        await readFile(join(String(bound.inputs.dir), '001-one.jpg'), 'utf8'),
+      ).toBe('one');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('single Desktop file also uses a stable Runner copy', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const file = join(root, 'one.jpg');
+      await writeFile(file, 'one');
+      const bound = await bindResourceInputs({
+        workflowName: 'wrong-question-docx',
+        sessionId: 's1',
+        rawInputs: {},
+        defs: [{ ...imageDef, multiple: false }],
+        attachments: [
+          {
+            id: 'one',
+            origin: 'attachment',
+            name: 'one.jpg',
+            mime: 'image/jpeg',
+            sha256: 'sha-one',
+            localPath: file,
+            kind: 'file',
+          },
+        ],
+      });
+      expect(bound.inputs.source).not.toBe(file);
+      expect(await readFile(String(bound.inputs.source), 'utf8')).toBe('one');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('reference identity uses resource ids instead of content hashes', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const path = join(root, 'paper.jpg');
+      await writeFile(path, 'paper');
+      const bound = await bindResourceInputs({
+        workflowName: 'demo',
+        sessionId: 's1',
+        rawInputs: { source: path },
+        defs: [{ ...imageDef, identity: 'reference' }],
+      });
+      expect(bound.resourceIdentity).toHaveLength(1);
+      expect(bound.resourceIdentity[0]).toMatch(/^source:path-[a-f0-9]{24}$/);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('content identity notices changes inside an explicit directory', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const source = join(root, 'papers');
+      await mkdir(source);
+      await writeFile(join(source, 'page.jpg'), 'page-a');
+      const options = {
+        workflowName: 'wrong-question-docx',
+        sessionId: 's1',
+        rawInputs: { source },
+        defs: [imageDef],
+      };
+      const first = await bindResourceInputs(options);
+      await writeFile(join(source, 'page.jpg'), 'page-b');
+      const second = await bindResourceInputs(options);
+      expect(first.resourceIdentity).not.toEqual(second.resourceIdentity);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('rejects incompatible attachments instead of guessing', async () => {
+    const bound = await bindResourceInputs({
+      workflowName: 'wrong-question-docx',
+      sessionId: 's1',
+      rawInputs: {},
+      defs: [imageDef],
+      attachments: [
+        {
+          id: 'pdf',
+          origin: 'attachment',
+          name: 'paper.pdf',
+          mime: 'application/pdf',
+          localPath: '/tmp/paper.pdf',
+          kind: 'file',
+        },
+      ],
+    });
+    expect(bound.inputs.source).toBeUndefined();
+    expect(bound.resourceMap.source).toBeUndefined();
+  });
+
+  test('rejects attachment batches above maxItems', async () => {
+    await expect(
+      bindResourceInputs({
+        workflowName: 'wrong-question-docx',
+        sessionId: 's1',
+        rawInputs: {},
+        defs: [{ ...imageDef, maxItems: 1 }],
+        attachments: [
+          {
+            id: 'a',
+            origin: 'attachment',
+            name: 'a.jpg',
+            mime: 'image/jpeg',
+            localPath: '/tmp/a.jpg',
+            kind: 'file',
+          },
+          {
+            id: 'b',
+            origin: 'attachment',
+            name: 'b.jpg',
+            mime: 'image/jpeg',
+            localPath: '/tmp/b.jpg',
+            kind: 'file',
+          },
+        ],
+      }),
+    ).rejects.toThrow('最多允许 1 个附件');
+  });
+
+  test('staging path is stable for the same resources', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'workflow-resource-'));
+    try {
+      const file = join(root, 'x.jpg');
+      await writeFile(file, 'x');
+      const resource: InvocationResource = {
+        id: 'x',
+        origin: 'attachment',
+        name: 'x.jpg',
+        mime: 'image/jpeg',
+        size: 1,
+        sha256: 'sha-x',
+        localPath: file,
+        kind: 'file',
+      };
+      expect(await materializeResources('wf', 's', 'source', [resource])).toBe(
+        await materializeResources('wf', 's', 'source', [resource]),
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/plugins/workflow-runner/test/sandbox.test.ts

@@ -0,0 +1,126 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { WorkflowScriptError, runScript } from '../src/sandbox.js';
+import { validateScript } from '../src/scriptGuard.mjs';
+import type { WorkflowScript } from '../src/types.js';
+
+const dirs: string[] = [];
+afterEach(async () => {
+  for (const dir of dirs.splice(0)) await rm(dir, { recursive: true, force: true });
+});
+
+async function workflow(source: string, name = 'test-flow'): Promise<WorkflowScript> {
+  const root = await mkdtemp(join(tmpdir(), 'wf-esm-'));
+  dirs.push(root);
+  const dir = join(root, name);
+  await mkdir(dir, { recursive: true });
+  const scriptPath = join(dir, 'workflow.mjs');
+  await writeFile(scriptPath, source);
+  const verdict = validateScript(source, { filename: scriptPath });
+  if (!verdict.ok || verdict.bodyOffset === undefined) {
+    throw new Error(verdict.errors.join('; '));
+  }
+  return {
+    name,
+    dir,
+    scriptPath,
+    source,
+    meta: { apiVersion: 2, description: 'test' },
+    bodyOffset: verdict.bodyOffset,
+  };
+}
+
+const head = `export const meta = { apiVersion: 2, description: 'test' };\n`;
+
+describe('trusted ESM workflow loader', () => {
+  test('default run receives an isolated wf object and returns JSON data', async () => {
+    const script = await workflow(
+      `${head}export default async function run(wf) { return { value: wf.input.values.x }; }`,
+    );
+    expect(
+      await runScript(script, { input: { values: { x: 42 } } }, 'bundle-a'),
+    ).toEqual({ value: 42 });
+  });
+
+  test('native relative imports resolve from the workflow directory', async () => {
+    const script = await workflow(
+      `${head}import { twice } from './scripts/math.mjs';\nexport default async function run(wf) { return twice(6); }`,
+    );
+    await mkdir(join(script.dir, 'scripts'), { recursive: true });
+    await writeFile(
+      join(script.dir, 'scripts', 'math.mjs'),
+      'export const twice = (value) => value * 2;\n',
+    );
+    expect(await runScript(script, {}, 'bundle-b')).toBe(12);
+  });
+
+  test('bundle hash selects a fresh physical ESM graph when a helper changes', async () => {
+    const script = await workflow(
+      `${head}import { value } from './scripts/value.mjs';\nexport default async function run(wf) { return value; }`,
+    );
+    const helper = join(script.dir, 'scripts', 'value.mjs');
+    await mkdir(join(script.dir, 'scripts'), { recursive: true });
+    await writeFile(helper, 'export const value = 1;\n');
+    expect(await runScript(script, {}, 'bundle-helper-v1')).toBe(1);
+    await writeFile(helper, 'export const value = 2;\n');
+    expect(await runScript(script, {}, 'bundle-helper-v2')).toBe(2);
+  });
+
+  test('concurrent instances do not share run-local state', async () => {
+    const script = await workflow(
+      `${head}export default async function run(wf) { let value = wf.input.values.value; await Promise.resolve(); value += 1; return value; }`,
+    );
+    expect(
+      await Promise.all([
+        runScript(script, { input: { values: { value: 1 } } }, 'bundle-c'),
+        runScript(script, { input: { values: { value: 9 } } }, 'bundle-c'),
+      ]),
+    ).toEqual([2, 10]);
+  });
+
+  test('wide concurrent fan-out sharing one bundle hash does not race the ESM cache rename (Windows EPERM regression)', async () => {
+    const script = await workflow(
+      `${head}export default async function run(wf) { let value = wf.input.values.value; await Promise.resolve(); value += 1; return value; }`,
+    );
+    const N = 16;
+    const results = await Promise.all(
+      Array.from({ length: N }, (_, i) =>
+        runScript(script, { input: { values: { value: i } } }, 'bundle-wide'),
+      ),
+    );
+    expect(results).toEqual(Array.from({ length: N }, (_, i) => i + 1));
+  });
+
+  test('runtime errors preserve workflow outcome and cause', async () => {
+    const script = await workflow(
+      `${head}export default async function run(wf) { throw Object.assign(new Error('budget'), { workflowOutcome: 'budget_limited' }); }`,
+    );
+    const error = await runScript(script, {}, 'bundle-d').catch((value) => value);
+    expect(error).toBeInstanceOf(WorkflowScriptError);
+    expect(error).toMatchObject({ workflowOutcome: 'budget_limited' });
+    expect((error as WorkflowScriptError).cause).toBeInstanceOf(Error);
+  });
+
+  test('AbortError passes through without workflow-failure wrapping', async () => {
+    const script = await workflow(
+      `${head}export default async function run(wf) { const e = new Error('stop'); e.name = 'AbortError'; throw e; }`,
+    );
+    const error = await runScript(script, {}, 'bundle-e').catch((value) => value);
+    expect((error as Error).name).toBe('AbortError');
+    expect(error).not.toBeInstanceOf(WorkflowScriptError);
+  });
+
+  test('module parse failures are reported as module-load failures', async () => {
+    const script = await workflow(
+      `${head}export default async function run(wf) { return 1; }`,
+    );
+    const invalid = `${head}export default async function run( {`;
+    await writeFile(script.scriptPath, invalid);
+    await expect(
+      runScript({ ...script, source: invalid }, {}, 'bundle-f-invalid'),
+    ).rejects.toThrow(/模块加载失败/);
+  });
+});

package/plugins/workflow-runner/test/scheduler.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'bun:test';
+import { readWorkflowRuntimeConfig } from '../src/runtime/config.js';
+import { WorkflowScheduler } from '../src/runtime/scheduler.js';
+
+const config = (overrides: Partial<ReturnType<typeof readWorkflowRuntimeConfig>> = {}) => ({
+  ...readWorkflowRuntimeConfig({} as NodeJS.ProcessEnv),
+  ...overrides,
+});
+
+describe('WorkflowScheduler', () => {
+  test('进程级资源上限覆盖不同根运行', async () => {
+    const scheduler = new WorkflowScheduler(config({ modelConcurrency: 2 }));
+    let active = 0;
+    let peak = 0;
+    await Promise.all(
+      Array.from({ length: 12 }, (_, index) =>
+        scheduler.run('model', `root-${index % 3}`, async () => {
+          active++;
+          peak = Math.max(peak, active);
+          await new Promise((resolve) => setTimeout(resolve, 4));
+          active--;
+        }),
+      ),
+    );
+    expect(peak).toBe(2);
+  });
+
+  test('根运行之间轮转，不让一个大队列饿死后来的根', async () => {
+    const scheduler = new WorkflowScheduler(config({ toolConcurrency: 1 }));
+    const first = await scheduler.acquire('tool', 'root-a');
+    const order: string[] = [];
+    const queued = [
+      scheduler.run('tool', 'root-a', async () => void order.push('a1')),
+      scheduler.run('tool', 'root-a', async () => void order.push('a2')),
+      scheduler.run('tool', 'root-b', async () => void order.push('b1')),
+      scheduler.run('tool', 'root-a', async () => void order.push('a3')),
+    ];
+    first.release();
+    await Promise.all(queued);
+    expect(order.indexOf('b1')).toBeLessThan(order.indexOf('a3'));
+  });
+
+  test('取消会移除排队项且不占用槽', async () => {
+    const scheduler = new WorkflowScheduler(config({ processConcurrency: 1 }));
+    const first = await scheduler.acquire('process', 'root-a');
+    const controller = new AbortController();
+    const cancelled = scheduler.acquire('process', 'root-b', controller.signal);
+    controller.abort(Object.assign(new Error('stop'), { name: 'AbortError' }));
+    await expect(cancelled).rejects.toMatchObject({ name: 'AbortError' });
+    first.release();
+    const lease = await scheduler.acquire('process', 'root-c');
+    lease.release();
+  });
+});
+
+describe('workflow runtime environment', () => {
+  test('非法值响亮报错，不静默回默认值', () => {
+    expect(() =>
+      readWorkflowRuntimeConfig({
+        MINIMAL_AGENT_WORKFLOW_MODEL_CONCURRENCY: '0',
+      } as NodeJS.ProcessEnv),
+    ).toThrow(/MINIMAL_AGENT_WORKFLOW_MODEL_CONCURRENCY/);
+    expect(() =>
+      readWorkflowRuntimeConfig({
+        MINIMAL_AGENT_WORKFLOW_PIPELINE_CONCURRENCY: '10',
+        MINIMAL_AGENT_WORKFLOW_PIPELINE_MAX_CONCURRENCY: '5',
+      } as NodeJS.ProcessEnv),
+    ).toThrow(/不能大于/);
+  });
+});