@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.8

package/test/integration/app-command.test.mjs

@@ -1,85 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import test from 'node:test';
-import { listAppManifests } from '../../src/commands/app.js';
-
-test('lists agentsam.app.json manifests for product apps', () => {
-  const apps = listAppManifests();
-  const ids = apps.map((row) => row.id).sort();
-  assert.ok(ids.includes('cad-creator'));
-  assert.ok(ids.includes('local-studio'));
-  assert.ok(ids.includes('client-cms-editor'));
-  assert.ok(ids.includes('ecommerce-cms-agentsam'));
-});
-
-test('agentsam app validate passes for all product apps', async () => {
-  const { validateApps } = await import('../../src/commands/app.js');
-  const report = validateApps();
-  assert.equal(report.ok, true, report.errors.join('\n'));
-  assert.ok(report.apps.length >= 4);
-});
-
-test('CMS app scaffold source is included in the SDK distribution contract', async () => {
-  const { validateApps } = await import('../../src/commands/app.js');
-  const report = validateApps({ appId: 'client-cms-editor' });
-  assert.equal(report.ok, true, report.errors.join('\n'));
-  assert.deepEqual(report.warnings, []);
-});
-
-test('CAD and CMS workers load APP identity from agentsam.app.json', () => {
-  const cad = fs.readFileSync(path.resolve('apps/cad-creator/backend/worker/index.js'), 'utf8');
-  const cms = fs.readFileSync(path.resolve('apps/client-cms-editor/backend/worker/index.js'), 'utf8');
-  assert.match(cad, /import appManifest from ['"]\.\.\/\.\.\/agentsam\.app\.json['"]/);
-  assert.match(cms, /import appManifest from ['"]\.\.\/\.\.\/agentsam\.app\.json['"]/);
-  assert.doesNotMatch(cad, /const\s+APP\s*=\s*["']/);
-  assert.doesNotMatch(cms, /const\s+APP\s*=\s*["']/);
-});
-
-test('desktop CMS shell app_id resolves to client-cms-editor', () => {
-  const manifest = JSON.parse(
-    fs.readFileSync(path.resolve('packages/agentsam-desktop-shell/manifests/cms-editor.json'), 'utf8'),
-  );
-  assert.equal(manifest.app_id, 'client-cms-editor');
-});
-
-
-test('Ecommerce CMS app bin exposes truthful runnable doctor state', () => {
-  const bin = path.resolve('apps/ecommerce-cms-agentsam/bin/agentsam-ecommerce.mjs');
-  const result = spawnSync(process.execPath, [bin, 'doctor', '--json'], {
-    cwd: path.resolve('.'),
-    encoding: 'utf8',
-  });
-
-  assert.equal(result.status, 0, result.stderr);
-  const report = JSON.parse(result.stdout);
-  assert.equal(report.app_id, 'ecommerce-cms-agentsam');
-  assert.equal(report.source.frontend, true);
-  assert.equal(report.runtime.package_json, true);
-  assert.equal(report.runtime.runnable, true);
-  assert.equal(report.manifest_runtime.local_preview, 'ready');
-  assert.equal(report.manifest_runtime.source_scaffold, 'ready');
-  assert.equal(report.contract_consistent, true);
-});
-
-test('Ecommerce CMS app manifest and package agree on executable preview', () => {
-  const manifest = JSON.parse(
-    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/agentsam.app.json'), 'utf8'),
-  );
-  const pkg = JSON.parse(
-    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/package.json'), 'utf8'),
-  );
-  const frontendPkg = JSON.parse(
-    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/frontend/package.json'), 'utf8'),
-  );
-
-  assert.equal(manifest.package, pkg.name);
-  assert.equal(manifest.bin, 'bin/agentsam-ecommerce.mjs');
-  assert.equal(manifest.runtime.local_preview, 'ready');
-  assert.equal(manifest.runtime.source_scaffold, 'ready');
-  assert.equal(manifest.preview.entry, '/admin');
-  assert.equal(manifest.preview.port, 4174);
-  assert.equal(typeof pkg.scripts.preview, 'string');
-  assert.equal(typeof frontendPkg.scripts.preview, 'string');
-});

package/test/integration/autorag-project-authority.integration.test.mjs

@@ -1,51 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const repoRoot = fileURLToPath(new URL('../..', import.meta.url));
-const bin = path.join(repoRoot, 'bin', 'agentsam');
-const fixture = path.join(repoRoot, 'test', 'fixtures', 'project-authority', 'customer-app');
-
-function runAutorag(root, ...args) {
-  const stdout = execFileSync(process.execPath, [bin, 'autorag', ...args, '--cwd', root], {
-    cwd: root,
-    encoding: 'utf8',
-    env: { ...process.env, CLOUDFLARE_API_TOKEN: '', CLOUDFLARE_ACCOUNT_ID: '' },
-  });
-  return JSON.parse(stdout);
-}
-
-test('generic customer fixture discovers existing project resources and adopts Vectorize', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-project-authority-fixture-'));
-  try {
-    fs.cpSync(fixture, root, { recursive: true });
-    const status = runAutorag(root, 'status');
-    assert.deepEqual(status.discovery.scopes, ['apps']);
-    assert.equal(status.project_context.schema, 'agentsam.project-context.v1');
-    assert.equal(status.project_context.project.host_install.app_id, 'my-product');
-    assert.equal(status.project_context.resources.workers_ai.binding, 'MY_AI');
-    assert.equal(status.project_context.resources.vectorize[0].binding, 'MY_VECTORS');
-    assert.equal(status.project_context.resources.vectorize[0].index, 'customer-code-index');
-    assert.equal(status.project_context.resources.d1[0].binding, 'DB');
-    assert.equal(status.project_context.resources.r2[0].binding, 'CONTENT');
-    assert.equal(status.project_context.resources.vectorize[0].locally_executable, false);
-    assert.equal(status.project_context.resources.vectorize[0].remotely_executable, true);
-
-    const setup = runAutorag(root, 'setup', '--yes');
-    assert.deepEqual(setup.recommendation.scope, ['apps']);
-    assert.equal(setup.config.lane.backend, 'cloudflare_vectorize');
-    assert.equal(setup.config.lane.binding, 'MY_VECTORS');
-    assert.equal(setup.config.lane.index, 'customer-code-index');
-    assert.equal(setup.config.embedding.provider, 'none');
-
-    const policy = JSON.parse(fs.readFileSync(path.join(root, '.agentsam', 'knowledge.json'), 'utf8'));
-    assert.equal(policy.lane.binding, 'MY_VECTORS');
-    assert.equal(policy.lane.index, 'customer-code-index');
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

package/test/integration/autorag-runtime-discovery.test.mjs

@@ -1,107 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { discoverKnowledgeRuntime } from '../../src/knowledge/runtime-discovery.js';
-
-test('AutoRAG runtime discovery sees local index and Cloudflare Vectorize without local knowledge config', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-autorag-runtime-'));
-  try {
-    fs.mkdirSync(path.join(root, '.agentsam', 'knowledge'), { recursive: true });
-    fs.writeFileSync(path.join(root, '.agentsam', 'knowledge', 'index.sqlite'), '');
-    fs.writeFileSync(
-      path.join(root, 'wrangler.toml'),
-      [
-        'name = "demo-worker"',
-        '',
-        '[ai]',
-        'binding = "AGENTSAM_WAI"',
-        '',
-        '[[vectorize]]',
-        'binding = "DEMO_VECTORIZE"',
-        'index_name = "demo-index-1024"',
-        '',
-      ].join('\n'),
-    );
-
-    const runtime = discoverKnowledgeRuntime(root);
-    assert.equal(runtime.local_index.exists, true);
-    assert.equal(runtime.cloudflare.configured, true);
-    assert.equal(runtime.cloudflare.worker_name, 'demo-worker');
-    assert.equal(runtime.cloudflare.ai_binding, 'AGENTSAM_WAI');
-    assert.deepEqual(runtime.cloudflare.vectorize, [{
-      binding: 'DEMO_VECTORIZE',
-      index: 'demo-index-1024',
-      source: 'wrangler_config',
-    }]);
-    assert.deepEqual(runtime.lanes.map((lane) => lane.backend), [
-      'local_exact',
-      'cloudflare_vectorize',
-    ]);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('project context receipt separates observed deployment resources from local executability', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-project-context-'));
-  try {
-    fs.mkdirSync(path.join(root, '.agentsam'), { recursive: true });
-    fs.writeFileSync(path.join(root, '.agentsam', 'app.json'), JSON.stringify({ schema: 'agentsam.app-install.v1', app_id: 'my-product' }));
-    fs.writeFileSync(path.join(root, 'wrangler.toml'), [
-      'name = "customer-worker"',
-      '[ai]',
-      'binding = "MY_AI"',
-      '[[vectorize]]',
-      'binding = "MY_VECTORS"',
-      'index_name = "customer-code-index"',
-      '[[d1_databases]]',
-      'binding = "DB"',
-      'database_name = "customer-db"',
-      'database_id = "00000000-0000-0000-0000-000000000001"',
-      '[[r2_buckets]]',
-      'binding = "CONTENT"',
-      'bucket_name = "customer-assets"',
-      '',
-    ].join('\n'));
-
-    const runtime = discoverKnowledgeRuntime(root, { env: {} });
-    assert.equal(runtime.schema, 'agentsam.project-context.v1');
-    assert.equal(runtime.project.host_install.app_id, 'my-product');
-    assert.equal(runtime.resources.workers_ai.binding, 'MY_AI');
-    assert.equal(runtime.resources.workers_ai.locally_executable, false);
-    assert.equal(runtime.resources.workers_ai.remotely_executable, true);
-    assert.equal(runtime.resources.vectorize[0].binding, 'MY_VECTORS');
-    assert.equal(runtime.resources.vectorize[0].index, 'customer-code-index');
-    assert.equal(runtime.resources.vectorize[0].locally_executable, false);
-    assert.equal(runtime.resources.vectorize[0].remotely_executable, true);
-    assert.equal(runtime.resources.d1[0].binding, 'DB');
-    assert.equal(runtime.resources.r2[0].binding, 'CONTENT');
-    assert.equal(runtime.knowledge.policy_configured, false);
-    assert.equal(runtime.knowledge.suggested_backend, 'cloudflare_vectorize');
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('project context receipt surfaces knowledge policy versus Wrangler drift', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-project-context-drift-'));
-  try {
-    fs.writeFileSync(path.join(root, 'wrangler.toml'), [
-      'name = "customer-worker"',
-      '[[vectorize]]',
-      'binding = "MY_VECTORS"',
-      'index_name = "customer-code-index"',
-      '',
-    ].join('\n'));
-    const runtime = discoverKnowledgeRuntime(root, {
-      env: {},
-      knowledgeConfig: { lane: { backend: 'cloudflare_vectorize', binding: 'OTHER_VECTORS', index: 'other-index' } },
-    });
-    assert.equal(runtime.conflicts.length, 1);
-    assert.equal(runtime.conflicts[0].kind, 'knowledge_deployment_drift');
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

package/test/integration/cad-discovery.test.mjs

@@ -1,158 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  discoverOpenScad,
-  openScadStatus,
-  discoverFreeCad,
-  freeCadStatus,
-  meshyStatus,
-  mujocoStatus,
-  discoverAllCadTools,
-  getInstallGuidance,
-} from '../../src/lib/cad/index.js';
-
-function makeFixture(t, name) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), `agentsam-${name}-test-`));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const binary = path.join(root, process.platform === 'win32' ? `${name}.exe` : name);
-  fs.writeFileSync(binary, `fake ${name}\n`);
-  return { root, binary };
-}
-
-test('discoverOpenScad honors explicit binary before env and path', (t) => {
-  const { binary } = makeFixture(t, 'openscad');
-  const result = discoverOpenScad({
-    openscadBin: binary,
-    env: { AGENTSAM_OPENSCAD_BIN: '/nonexistent/bin' },
-  });
-  assert.equal(result.source, 'explicit');
-  assert.equal(result.binary, fs.realpathSync(binary));
-});
-
-test('discoverOpenScad honors AGENTSAM_OPENSCAD_BIN when explicit is not set', (t) => {
-  const { binary } = makeFixture(t, 'openscad');
-  const result = discoverOpenScad({
-    env: { AGENTSAM_OPENSCAD_BIN: binary },
-  });
-  assert.equal(result.source, 'env');
-  assert.equal(result.binary, fs.realpathSync(binary));
-});
-
-test('openScadStatus probes version boundedly and returns deterministic receipt', async (t) => {
-  const { binary } = makeFixture(t, 'openscad');
-  const calls = [];
-  const status = await openScadStatus({
-    openscadBin: binary,
-    runProcessImpl: async (command, args) => {
-      calls.push({ command, args });
-      return { code: 0, stdout: '', stderr: 'OpenSCAD version 2026.04.26\n' };
-    },
-  });
-
-  assert.equal(status.tool, 'openscad');
-  assert.equal(status.available, true);
-  assert.equal(status.version, '2026.04.26');
-  assert.equal(status.execution_lane, 'native');
-  assert.deepEqual(calls[0], { command: fs.realpathSync(binary), args: ['-v'] });
-});
-
-test('discoverFreeCad honors explicit binary and AGENTSAM_FREECAD_BIN', (t) => {
-  const { binary } = makeFixture(t, 'FreeCADCmd');
-  const result = discoverFreeCad({
-    freecadBin: binary,
-    env: { AGENTSAM_FREECAD_BIN: '/nonexistent/path' },
-  });
-  assert.equal(result.source, 'explicit');
-  assert.equal(result.binary, fs.realpathSync(binary));
-
-  const envResult = discoverFreeCad({
-    env: { AGENTSAM_FREECAD_BIN: binary },
-  });
-  assert.equal(envResult.source, 'env');
-  assert.equal(envResult.binary, fs.realpathSync(binary));
-});
-
-test('freeCadStatus probes version and returns deterministic receipt', async (t) => {
-  const { binary } = makeFixture(t, 'FreeCADCmd');
-  const calls = [];
-  const status = await freeCadStatus({
-    freecadBin: binary,
-    runProcessImpl: async (command, args) => {
-      calls.push({ command, args });
-      return { code: 0, stdout: 'FreeCAD 1.1.1 Revision: 20260414 (Git shallow)\n', stderr: '' };
-    },
-  });
-
-  assert.equal(status.tool, 'freecad');
-  assert.equal(status.available, true);
-  assert.equal(status.version, 'FreeCAD 1.1.1 Revision: 20260414 (Git shallow)');
-  assert.equal(status.execution_lane, 'native');
-  assert.deepEqual(calls[0], { command: fs.realpathSync(binary), args: ['--version'] });
-});
-
-test('meshyStatus discovers API key configuration via environment', () => {
-  const noKey = meshyStatus({ env: {} });
-  assert.equal(noKey.available, false);
-  assert.equal(noKey.source, 'none');
-  assert.equal(noKey.execution_lane, 'cloud_byok');
-
-  const withKey = meshyStatus({ env: { MESHY_API_KEY: 'msy_test_secret_key' } });
-  assert.equal(withKey.available, true);
-  assert.equal(withKey.source, 'env');
-  assert.equal(withKey.version, 'v2-api');
-});
-
-test('mujocoStatus returns browser WASM bundled capability', () => {
-  const status = mujocoStatus();
-  assert.equal(status.tool, 'mujoco');
-  assert.equal(status.available, true);
-  assert.equal(status.execution_lane, 'browser_wasm');
-});
-
-test('discoverAllCadTools aggregates deterministic receipts across engines', async (t) => {
-  const { binary: openscad } = makeFixture(t, 'openscad');
-  const { binary: freecad } = makeFixture(t, 'FreeCADCmd');
-  const { binary: blender } = makeFixture(t, 'blender');
-
-  const report = await discoverAllCadTools({
-    openscadBin: openscad,
-    freecadBin: freecad,
-    blenderBin: blender,
-    env: { MESHY_API_KEY: 'test_key' },
-    runProcessImpl: async (command, args) => {
-      if (args[0] === '-v') return { code: 0, stdout: '', stderr: 'OpenSCAD version 2026.04.26\n' };
-      if (command.includes('FreeCAD')) return { code: 0, stdout: 'FreeCAD 1.1.1 Revision: 20260414\n', stderr: '' };
-      return { code: 0, stdout: 'Blender 5.0.1\n', stderr: '' };
-    },
-  });
-
-  assert.equal(report.schema_version, 1);
-  assert.equal(report.total_tools, 5);
-  assert.equal(report.available_tools, 5);
-  assert.equal(report.all_systems_ready, true);
-  assert.equal(report.tools.length, 5);
-});
-
-test('getInstallGuidance provides exact OS package manager commands', () => {
-  const darwinOpenScad = getInstallGuidance('openscad', 'darwin');
-  assert.equal(darwinOpenScad.command, 'brew install openscad');
-
-  const linuxFreeCad = getInstallGuidance('freecad', 'linux');
-  assert.match(linuxFreeCad.command, /apt-get install.*freecad/);
-
-  const winBlender = getInstallGuidance('blender', 'win32');
-  assert.equal(winBlender.command, 'winget install BlenderFoundation.Blender');
-});
-
-test('discoverOpenScad returns binary: null when not found on host (no hardcoded defaults)', () => {
-  const emptyDiscovery = discoverOpenScad({
-    env: { PATH: '' },
-    platform: 'unknown_os',
-  });
-  assert.equal(emptyDiscovery.binary, null);
-  assert.equal(emptyDiscovery.source, 'none');
-});
-

package/test/integration/cad-docker-executor.test.mjs

@@ -1,249 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import http from 'node:http';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  DEFAULT_CAD_DOCKER_PORT,
-  DEFAULT_CAD_DOCKER_URL,
-  resolveDockerServiceConfig,
-  probeDockerServiceHealth,
-  executeOpenScadDocker,
-  executeFreeCadDocker,
-  executeBlenderDocker,
-} from '../../src/lib/cad/docker-executor.js';
-import { discoverAllCadTools } from '../../src/lib/cad/discovery.js';
-
-test('resolveDockerServiceConfig resolves URL and token from env or options', () => {
-  const conf1 = resolveDockerServiceConfig({
-    serviceUrl: 'http://custom-host:9999/',
-    token: 'secret-token-123',
-  });
-  assert.equal(conf1.url, 'http://custom-host:9999');
-  assert.equal(conf1.token, 'secret-token-123');
-
-  const conf2 = resolveDockerServiceConfig({
-    env: {
-      AGENTSAM_CAD_SERVICE_URL: 'http://env-host:8888',
-      AGENTSAM_CAD_TOKEN: 'env-tok',
-    },
-  });
-  assert.equal(conf2.url, 'http://env-host:8888');
-  assert.equal(conf2.token, 'env-tok');
-
-  const confDefault = resolveDockerServiceConfig({ env: {} });
-  assert.equal(confDefault.url, DEFAULT_CAD_DOCKER_URL);
-  assert.equal(confDefault.token, null);
-});
-
-test('probeDockerServiceHealth returns offline gracefully when unreachable', async () => {
-  const result = await probeDockerServiceHealth({
-    serviceUrl: 'http://127.0.0.1:54321', // Unused port
-    timeoutMs: 150,
-  });
-  assert.equal(result.available, false);
-  assert.equal(result.url, 'http://127.0.0.1:54321');
-});
-
-test('Docker CAD service executor routes compile, build, and inspect requests', async () => {
-  const recordedRequests = [];
-  const mockServer = http.createServer((req, res) => {
-    let body = '';
-    req.on('data', chunk => { body += chunk; });
-    req.on('end', () => {
-      recordedRequests.push({
-        url: req.url,
-        method: req.method,
-        auth: req.headers['authorization'],
-        body: body ? JSON.parse(body) : null,
-      });
-
-      if (req.url === '/healthz') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          service: 'agentsam-cad',
-          version: '1',
-          tools: {
-            openscad: { installed: true, version: 'OpenSCAD 2021.01-docker' },
-            freecad: { installed: true, version: 'FreeCAD 0.21.2-docker' },
-            blender: { installed: true, version: 'Blender 4.2.0-docker' },
-          },
-        }));
-        return;
-      }
-
-      if (req.url === '/v1/openscad/compile') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          tool: 'openscad',
-          format: 'stl',
-          filename: 'bracket.stl',
-          size_bytes: 128,
-          sha256: 'abc123sha',
-          artifact_base64: Buffer.from('solid bracket\nendsolid').toString('base64'),
-          logs: ['[DOCKER] OpenSCAD compiled successfully'],
-        }));
-        return;
-      }
-
-      if (req.url === '/v1/freecad/execute') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          tool: 'freecad',
-          format: 'step',
-          filename: 'part.step',
-          size_bytes: 512,
-          sha256: 'step123sha',
-          artifact_base64: Buffer.from('ISO-10303-21;').toString('base64'),
-          metrics: { volume: 1500, surface_area: 800, faces_count: 6 },
-          logs: ['[DOCKER] FreeCAD built STEP model'],
-        }));
-        return;
-      }
-
-      if (req.url === '/v1/blender/execute') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          tool: 'blender',
-          operation: 'build',
-          format: 'glb',
-          filename: 'scene.glb',
-          size_bytes: 1024,
-          sha256: 'glb123sha',
-          artifact_base64: Buffer.from('glTF binary mock').toString('base64'),
-          result: { ok: true, blender_version: '4.2.0', objects: ['Cube', 'Camera'] },
-          logs: ['[DOCKER] Blender rendered glb scene'],
-        }));
-        return;
-      }
-
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ ok: false, error: 'not_found' }));
-    });
-  });
-
-  await new Promise((resolve) => mockServer.listen(0, '127.0.0.1', resolve));
-  const port = mockServer.address().port;
-  const serviceUrl = `http://127.0.0.1:${port}`;
-  const token = 'test-token-xyz';
-
-  try {
-    // 1. Health probe
-    const health = await probeDockerServiceHealth({ serviceUrl, token });
-    assert.equal(health.available, true);
-    assert.equal(health.tools.openscad.installed, true);
-    assert.equal(health.tools.freecad.installed, true);
-    assert.equal(health.tools.blender.installed, true);
-
-    // 2. OpenSCAD execution
-    const oscadRes = await executeOpenScadDocker({
-      source: 'cube([10, 10, 10]);',
-      outputFormat: 'stl',
-      filename: 'bracket.stl',
-      serviceUrl,
-      token,
-    });
-    assert.equal(oscadRes.success, true);
-    assert.equal(oscadRes.filename, 'bracket.stl');
-    assert.match(oscadRes.artifactContent, /solid bracket/);
-    assert.equal(oscadRes.mimeType, 'model/stl');
-
-    // 3. FreeCAD execution
-    const freecadRes = await executeFreeCadDocker({
-      operations: [{ op: 'box', length: 10, width: 10, height: 10 }],
-      format: 'step',
-      filename: 'part.step',
-      serviceUrl,
-      token,
-    });
-    assert.equal(freecadRes.success, true);
-    assert.equal(freecadRes.format, 'step');
-    assert.equal(freecadRes.metrics.volume, 1500);
-    assert.match(freecadRes.artifactText, /ISO-10303-21;/);
-
-    // 4. Blender execution
-    const blenderRes = await executeBlenderDocker({
-      operation: 'build',
-      operations: [{ op: 'add', primitive: 'cube' }],
-      format: 'glb',
-      serviceUrl,
-      token,
-    });
-    assert.equal(blenderRes.success, true);
-    assert.equal(blenderRes.format, 'glb');
-    assert.equal(blenderRes.result.blender_version, '4.2.0');
-
-    // 5. Verify recorded request signatures
-    assert.equal(recordedRequests[0].url, '/healthz');
-    assert.equal(recordedRequests[0].auth, 'Bearer test-token-xyz');
-    assert.equal(recordedRequests[1].url, '/v1/openscad/compile');
-    assert.equal(recordedRequests[2].url, '/v1/freecad/execute');
-    assert.equal(recordedRequests[3].url, '/v1/blender/execute');
-  } finally {
-    await new Promise((resolve) => mockServer.close(resolve));
-  }
-});
-
-test('discoverAllCadTools adopts Docker service execution lane when host tools are absent', async () => {
-  const mockServer = http.createServer((req, res) => {
-    if (req.url === '/healthz') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        ok: true,
-        service: 'agentsam-cad',
-        version: '1',
-        tools: {
-          openscad: { installed: true, version: 'OpenSCAD 2021.01-docker' },
-          freecad: { installed: true, version: 'FreeCAD 0.21.2-docker' },
-          blender: { installed: true, version: 'Blender 4.2.0-docker' },
-        },
-      }));
-      return;
-    }
-    res.writeHead(404);
-    res.end();
-  });
-
-  await new Promise((resolve) => mockServer.listen(0, '127.0.0.1', resolve));
-  const port = mockServer.address().port;
-  const serviceUrl = `http://127.0.0.1:${port}`;
-
-  try {
-    const report = await discoverAllCadTools({
-      openscadBin: '/nonexistent/openscad',
-      freecadBin: '/nonexistent/freecad',
-      blenderBin: '/nonexistent/blender',
-      env: {
-        AGENTSAM_CAD_SERVICE_URL: serviceUrl,
-        PATH: '/empty',
-      },
-      cache: false,
-    });
-
-    const openscad = report.tools.find(t => t.tool === 'openscad');
-    const freecad = report.tools.find(t => t.tool === 'freecad');
-    const blender = report.tools.find(t => t.tool === 'blender');
-
-    assert.equal(openscad.available, true);
-    assert.equal(openscad.execution_lane, 'docker_service');
-    assert.equal(openscad.source, 'docker_service');
-    assert.match(openscad.binary, /^docker:\/\//);
-
-    assert.equal(freecad.available, true);
-    assert.equal(freecad.execution_lane, 'docker_service');
-    assert.equal(freecad.source, 'docker_service');
-    assert.match(freecad.binary, /^docker:\/\//);
-
-    assert.equal(blender.available, true);
-    assert.equal(blender.execution_lane, 'docker_service');
-    assert.equal(blender.source, 'docker_service');
-    assert.match(blender.binary, /^docker:\/\//);
-  } finally {
-    await new Promise((resolve) => mockServer.close(resolve));
-  }
-});