@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.0

package/test/local-sessions.test.mjs

@@ -0,0 +1,42 @@
+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 { createLocalSession, listLocalSessions, loadLocalSession, saveLocalSession, sessionTitleFromInput } from '../src/lib/local-sessions.js';
+import { renderSessionReceipt } from '../src/commands/shell.js';
+
+function tempHome(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-session-home-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  return home;
+}
+
+test('local sessions persist provider-neutral continuation, usage, cost, and last-input title', t => {
+  const home = tempHome(t);
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-session-project-'));
+  t.after(() => fs.rmSync(cwd, { recursive: true, force: true }));
+  let session = createLocalSession({ cwd, last_input: 'Run wrangler whoami' }, { home });
+  assert.match(session.id, /^asess_[0-9a-f-]{36}$/i);
+  session = saveLocalSession({
+    ...session,
+    title: sessionTitleFromInput('Run wrangler whoami'),
+    model_key: 'openai:gpt-6-astra',
+    actual_service_tier: 'fast',
+    provider_state: { provider: 'openai', previous_response_id: 'resp_123' },
+    usage_snapshot: { current_context: { input_tokens: 21_244, window_tokens: 1_050_000 } },
+    cumulative_usage: { input_tokens: 21_244, cached_input_tokens: 60_544, output_tokens: 219, reasoning_tokens: 31 },
+    total_cost_usd: 0.123456,
+  }, { home });
+
+  const loaded = loadLocalSession(session.id, { home });
+  assert.equal(loaded.provider_state.previous_response_id, 'resp_123');
+  assert.equal(loaded.cumulative_usage.cached_input_tokens, 60_544);
+  assert.equal(listLocalSessions({ home, cwd })[0].id, session.id);
+
+  const receipt = renderSessionReceipt(loaded);
+  assert.match(receipt, /Token usage: total=21,463 input=21,244 \(\+ 60,544 cached\) output=219 reasoning=31/);
+  assert.match(receipt, /Cost: \$0\.1235/);
+  assert.match(receipt, new RegExp(`agentsam resume ${session.id}`));
+  assert.match(receipt, /Run wrangler whoami/);
+});

package/test/local-studio-deploy.test.mjs

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import {
+  DEPLOY_INPUT_GLOBS,
+  loadOptionalCloudflareEnv,
+  resolveLocalStudioDeployable,
+  wranglerDeployCommand,
+  isLocalStudioCheckout,
+  runLocalStudioDeploy,
+} from '../src/lib/deploy/local-studio.js';
+import { productionDeployBlockedReason } from '../src/lib/deploy/git-guard.js';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+describe('local-studio deploy resolver', () => {
+  it('resolves apps/local-studio + backend/wrangler.jsonc from the repo', () => {
+    const target = resolveLocalStudioDeployable(root);
+    assert.equal(target.provider, 'cloudflare');
+    assert.equal(target.app, 'local-studio');
+    assert.equal(path.basename(path.dirname(target.wranglerConfig)), 'backend');
+    assert.deepEqual(target.wranglerArgs, ['deploy', '-c', 'backend/wrangler.jsonc']);
+    assert.equal(isLocalStudioCheckout(root), true);
+    const cmd = wranglerDeployCommand(target, { dryRun: true });
+    assert.equal(cmd.bin, 'npx');
+    assert.equal(cmd.cwd, target.appRoot);
+    assert.deepEqual(cmd.args, ['wrangler', 'deploy', '-c', 'backend/wrangler.jsonc', '--dry-run']);
+  });
+
+  it('fingerprints the cloudflare connector package', () => {
+    assert.equal(DEPLOY_INPUT_GLOBS.includes('packages/connectors/cloudflare'), true);
+    assert.equal(DEPLOY_INPUT_GLOBS.includes('apps/local-studio'), true);
+  });
+
+  it('treats missing .env.cloudflare as optional', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cf-env-'));
+    const loaded = loadOptionalCloudflareEnv(tmp);
+    assert.equal(loaded.loaded, false);
+    assert.deepEqual(loaded.vars, {});
+  });
+
+  it('plan does not invoke wrangler', async () => {
+    const result = await runLocalStudioDeploy({ cwd: root, planOnly: true, execute: false });
+    assert.equal(result.plan.provider, 'cloudflare');
+    assert.equal(result.plan.wranglerConfig, 'apps/local-studio/backend/wrangler.jsonc');
+    assert.equal(result.plan.genericRootDeploy, false);
+    assert.equal(result.receipt.plan, true);
+    assert.equal(result.receipt.promoted, false);
+    assert.equal(result.receipt.wranglerConfig, 'apps/local-studio/backend/wrangler.jsonc');
+    assert.equal(result.receipt.hostname, 'agentsam.inneranimalmedia.com');
+  });
+
+  it('blocks production deploys from feat branches', () => {
+    const reason = productionDeployBlockedReason({
+      ok: true,
+      branch: 'feat/cloudflare-connector-deploy-control',
+      detached: false,
+      head: 'aaa',
+      originMain: 'aaa',
+      dirty: false,
+      tmpCheckout: false,
+      repoRoot: root,
+    });
+    assert.match(reason, /feat\/cloudflare-connector-deploy-control/);
+  });
+
+  it('allows production only when HEAD is a clean origin/main', () => {
+    const reason = productionDeployBlockedReason({
+      ok: true,
+      branch: 'main',
+      detached: false,
+      head: 'abc',
+      originMain: 'abc',
+      dirty: false,
+      tmpCheckout: false,
+      repoRoot: root,
+    });
+    assert.equal(reason, null);
+  });
+});

package/test/model-catalog.test.mjs

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { calculateModelCost, getModelRecord } from '../src/models/index.js';
+
+test('Astra catalog separates technical window, reasoning controls, service tiers, and economics', () => {
+  const model = getModelRecord('gpt-6-astra');
+  assert.ok(model);
+  assert.equal(model.context_window, 1_050_000);
+  assert.equal(model.max_output_tokens, 128_000);
+  assert.deepEqual(model.reasoning_efforts, ['low', 'medium', 'high', 'xhigh', 'max']);
+  assert.deepEqual(model.service_tiers, ['default', 'fast', 'flex']);
+  assert.equal(model.context_policy.target_input_tokens, 120_000);
+  assert.equal(model.context_policy.compact_at_tokens, 180_000);
+  assert.equal(model.context_policy.max_normal_input_tokens, 250_000);
+  assert.equal(model.context_policy.pricing_threshold_tokens, 272_000);
+  assert.equal(model.batch.interactive, false);
+});
+
+test('cost calculation applies the long-context threshold to the full request only after crossing it', () => {
+  const atBoundary = calculateModelCost('gpt-6-astra', { input_tokens: 272_000, output_tokens: 10_000 });
+  assert.equal(atBoundary.threshold_applied, null);
+  assert.equal(atBoundary.rates_per_million.input, 10);
+  assert.equal(atBoundary.rates_per_million.output, 50);
+
+  const crossed = calculateModelCost('gpt-6-astra', { input_tokens: 272_001, output_tokens: 10_000 });
+  assert.equal(crossed.threshold_applied.input_tokens_gt, 272_000);
+  assert.equal(crossed.rates_per_million.input, 20);
+  assert.equal(crossed.rates_per_million.output, 75);
+  assert.ok(crossed.total_usd > atBoundary.total_usd);
+});
+
+test('service tier and cache pricing stay explicit rather than hidden in prompts', () => {
+  const usage = { input_tokens: 100_000, cached_input_tokens: 80_000, cache_write_tokens: 10_000, output_tokens: 20_000 };
+  const standard = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'default' });
+  const fast = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'fast' });
+  const flex = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'flex' });
+  const batch = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'batch' });
+  assert.equal(fast.total_usd, standard.total_usd * 2);
+  assert.equal(flex.total_usd, standard.total_usd * 0.5);
+  assert.equal(batch.total_usd, standard.total_usd * 0.5);
+  assert.equal(standard.rates_per_million.cached_input, 1);
+  assert.equal(standard.rates_per_million.cache_write, 12.5);
+});

package/test/models.test.mjs

@@ -1,37 +1,51 @@
 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 { collectModelsStatus, renderModelsStatus } from '../src/commands/models.js';
 
 function response(body, status = 200) {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    async json() { return body; },
-  };
+  return { ok: status >= 200 && status < 300, status, async json() { return body; } };
+}
+
+function tempHome(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-model-home-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  return home;
 }
 
-test('model inventory reports configured API providers without exposing credentials', async () => {
+test('model inventory reports configured API providers without exposing credentials', async t => {
+  const home = tempHome(t);
   const status = await collectModelsStatus({
+    home,
+    discoverRemote: false,
     env: {
-      OPENAI_API_KEY: 'secret-openai',
-      GEMINI_API_KEY: '',
-      XAI_API_KEY: 'secret-xai',
-      OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
-      OLLAMA_MODEL: 'qwen:test',
-      OLLAMA_EMBED_MODEL: 'embed:test',
+      OPENAI_API_KEY: 'secret-openai', GEMINI_API_KEY: '', XAI_API_KEY: 'secret-xai', ANTHROPIC_API_KEY: 'secret-anthropic',
+      OLLAMA_BASE_URL: 'http://127.0.0.1:11434', OLLAMA_MODEL: 'qwen:test', OLLAMA_EMBED_MODEL: 'embed:test',
     },
     fetchImpl: async () => response({ models: [{ name: 'qwen:test' }, { name: 'embed:test' }] }),
   });
-
   assert.equal(status.providers.find((row) => row.id === 'openai').configured, true);
   assert.equal(status.providers.find((row) => row.id === 'gemini').configured, false);
   assert.equal(status.providers.find((row) => row.id === 'grok').configured, true);
+  assert.equal(status.providers.find((row) => row.id === 'anthropic').configured, true);
   assert.equal(status.local.online, true);
   assert.deepEqual(status.local.models.map((row) => row.name), ['qwen:test', 'embed:test']);
-
   const rendered = renderModelsStatus(status);
   assert.match(rendered, /OpenAI/);
   assert.match(rendered, /qwen:test/);
-  assert.doesNotMatch(rendered, /secret-openai|secret-xai/);
+  assert.doesNotMatch(rendered, /secret-openai|secret-xai|secret-anthropic/);
+});
+
+test('exact hosted model availability is verified against the provider inventory', async () => {
+  const status = await collectModelsStatus({
+    env: { OPENAI_API_KEY: 'secret-openai', OLLAMA_BASE_URL: 'http://127.0.0.1:11434' },
+    fetchImpl: async () => response({ models: [] }),
+    providerFetchImpl: async () => response({ data: [{ id: 'gpt-6-astra' }, { id: 'some-other-model' }] }),
+  });
+  assert.equal(status.discovery.openai.ok, true);
+  assert.equal(status.discovery.openai.returnedModelCount, 2);
+  assert.deepEqual(status.availableModels.map((row) => row.provider_model_id), ['gpt-6-astra']);
+  assert.equal(status.catalogModels[0].availability, 'available');
 });

package/test/npm10-lock.test.mjs

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lockPath = path.join(root, 'apps/local-studio/package-lock.json');
+
+describe('local-studio npm 10 lockfile', () => {
+  it('pins lru-cache@11.5.2 so Cloudflare npm ci can resolve it', () => {
+    const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    assert.equal(lock.lockfileVersion, 3);
+    const pkgs = lock.packages || {};
+    const hits = Object.entries(pkgs).filter(([key, meta]) => key.includes('lru-cache') && meta.version === '11.5.2');
+    assert.ok(hits.length >= 1, 'Missing: lru-cache@11.5.2 from lock file');
+    const [, meta] = hits[0];
+    assert.match(meta.resolved || '', /lru-cache-11\.5\.2\.tgz/);
+    assert.ok(meta.integrity);
+  });
+
+  it('verify-npm10-lock script exits 0 against the current lock', () => {
+    const script = path.join(root, 'apps/local-studio/scripts/verify-npm10-lock.mjs');
+    const r = spawnSync(process.execPath, [script], { encoding: 'utf8' });
+    assert.equal(r.status, 0, r.stderr || r.stdout);
+    assert.match(r.stdout, /lru-cache@11\.5\.2/);
+  });
+});

package/test/openai-responses.test.mjs

@@ -0,0 +1,95 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createOpenAIResponsesAdapter } from '../src/providers/index.js';
+
+function jsonResponse(body, status = 200) {
+  return { ok: status >= 200 && status < 300, status, async json() { return body; } };
+}
+
+test('Responses adapter sends reasoning/service tier without legacy sampling parameters and reconciles provider usage', async () => {
+  let request = null;
+  const events = [];
+  const adapter = createOpenAIResponsesAdapter({
+    apiKey: 'test-key',
+    emit: event => events.push(event),
+    fetchImpl: async (url, options) => {
+      request = { url, options, body: JSON.parse(options.body) };
+      return jsonResponse({
+        id: 'resp_test', status: 'completed', model: 'gpt-6-astra', service_tier: 'fast',
+        output: [{ type: 'message', content: [{ type: 'output_text', text: 'done' }] }],
+        usage: {
+          input_tokens: 100_000,
+          input_tokens_details: { cached_tokens: 80_000, cache_write_tokens: 10_000 },
+          output_tokens: 5_000,
+          output_tokens_details: { reasoning_tokens: 2_000 },
+        },
+      });
+    },
+  });
+  const result = await adapter.create({ model: 'gpt-6-astra', input: 'work', reasoningEffort: 'high', serviceTier: 'fast' });
+  assert.equal(request.url, 'https://api.openai.com/v1/responses');
+  assert.equal(request.body.reasoning.effort, 'high');
+  assert.equal(request.body.service_tier, 'fast');
+  assert.equal(request.body.truncation, 'disabled');
+  assert.equal('temperature' in request.body, false);
+  assert.equal('top_p' in request.body, false);
+  assert.equal(result.output_text, 'done');
+  assert.equal(result.usage_snapshot.current_context.input_tokens, 100_000);
+  assert.equal(result.usage_snapshot.current_context.window_tokens, 1_050_000);
+  assert.equal(result.actual_service_tier, 'fast');
+  assert.equal(result.cost.rates_per_million.input, 20);
+  assert.deepEqual(events.map(event => event.type), ['model.started', 'usage.snapshot', 'cost.snapshot', 'model.completed']);
+});
+
+test('Responses adapter preserves function call_id when returning tool output', async () => {
+  const bodies = [];
+  const adapter = createOpenAIResponsesAdapter({
+    apiKey: 'test-key',
+    fetchImpl: async (_url, options) => {
+      const body = JSON.parse(options.body);
+      bodies.push(body);
+      if (bodies.length === 1) {
+        return jsonResponse({
+          id: 'resp_calls', status: 'completed', service_tier: 'default',
+          output: [{ type: 'function_call', id: 'fc_1', call_id: 'call_abc', name: 'repository_snapshot', arguments: '{"depth":"quick"}', status: 'completed' }],
+          usage: { input_tokens: 100, output_tokens: 20 },
+        });
+      }
+      return jsonResponse({
+        id: 'resp_done', status: 'completed', service_tier: 'default',
+        output: [{ type: 'message', content: [{ type: 'output_text', text: 'complete' }] }],
+        usage: { input_tokens: 200, output_tokens: 30 },
+      });
+    },
+  });
+  const first = await adapter.create({
+    model: 'gpt-6-astra', input: 'inspect', reasoningEffort: 'low', serviceTier: 'default',
+    tools: [{ type: 'function', name: 'repository_snapshot', description: 'Snapshot repo', parameters: { type: 'object', properties: {} } }],
+  });
+  assert.equal(first.tool_calls[0].call_id, 'call_abc');
+  const second = await adapter.continueWithToolOutputs({
+    model: 'gpt-6-astra', previousResponseId: first.response_id, reasoningEffort: 'low', serviceTier: 'default',
+    toolOutputs: [{ call_id: first.tool_calls[0].call_id, output: { ok: true } }],
+  });
+  assert.equal(bodies[1].previous_response_id, 'resp_calls');
+  assert.deepEqual(bodies[1].input, [{ type: 'function_call_output', call_id: 'call_abc', output: '{"ok":true}' }]);
+  assert.equal(second.output_text, 'complete');
+});
+
+test('compaction is an explicit provider operation and has no arbitrary default wall-clock timeout', async () => {
+  let signal = 'unset';
+  let body = null;
+  const adapter = createOpenAIResponsesAdapter({
+    apiKey: 'test-key',
+    fetchImpl: async (url, options) => {
+      assert.equal(url, 'https://api.openai.com/v1/responses/compact');
+      signal = options.signal;
+      body = JSON.parse(options.body);
+      return jsonResponse({ id: 'cmp_1', object: 'response.compaction', output: [{ type: 'compaction', encrypted_content: 'opaque' }], usage: { input_tokens: 1_000, output_tokens: 100 } });
+    },
+  });
+  const compacted = await adapter.compact({ model: 'gpt-6-astra', previousResponseId: 'resp_previous' });
+  assert.equal(signal, undefined);
+  assert.equal(body.previous_response_id, 'resp_previous');
+  assert.equal(compacted.compaction_id, 'cmp_1');
+});

package/test/provider-credentials.test.mjs

@@ -0,0 +1,52 @@
+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 { describeProviderCredential, resolveProviderCredential } from '../src/lib/provider-credentials.js';
+
+function fixtureHome(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-credentials-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(home, '.agentsam', 'env.d'), { recursive: true });
+  return home;
+}
+
+test('provider credential resolver loads a secure AgentSam env file without exposing it in status', t => {
+  const home = fixtureHome(t);
+  const filename = path.join(home, '.agentsam', 'env.d', 'openai.env');
+  fs.writeFileSync(filename, 'export OPENAI_API_KEY="secret-from-file"\n', { mode: 0o600 });
+  if (process.platform !== 'win32') fs.chmodSync(filename, 0o600);
+
+  const resolved = resolveProviderCredential('openai', { env: {}, home });
+  assert.equal(resolved.configured, true);
+  assert.equal(resolved.source, 'agentsam_env_file');
+  assert.equal(resolved.value, 'secret-from-file');
+
+  const safe = describeProviderCredential('openai', { env: {}, home });
+  assert.equal(safe.configured, true);
+  assert.equal(safe.source, 'agentsam_env_file');
+  assert.equal(Object.hasOwn(safe, 'value'), false);
+  assert.doesNotMatch(JSON.stringify(safe), /secret-from-file/);
+});
+
+test('environment credential wins over disk fallback', t => {
+  const home = fixtureHome(t);
+  const filename = path.join(home, '.agentsam', 'env.d', 'openai.env');
+  fs.writeFileSync(filename, 'OPENAI_API_KEY=file-value\n', { mode: 0o600 });
+  if (process.platform !== 'win32') fs.chmodSync(filename, 0o600);
+  const resolved = resolveProviderCredential('openai', { env: { OPENAI_API_KEY: 'env-value' }, home });
+  assert.equal(resolved.source, 'environment');
+  assert.equal(resolved.value, 'env-value');
+});
+
+test('AgentSam refuses provider credential files with broad POSIX permissions', { skip: process.platform === 'win32' }, t => {
+  const home = fixtureHome(t);
+  const filename = path.join(home, '.agentsam', 'env.d', 'openai.env');
+  fs.writeFileSync(filename, 'OPENAI_API_KEY=unsafe-value\n', { mode: 0o644 });
+  fs.chmodSync(filename, 0o644);
+  const resolved = resolveProviderCredential('openai', { env: {}, home });
+  assert.equal(resolved.configured, false);
+  assert.equal(resolved.error, 'permissions_too_open');
+  assert.equal(resolved.value, '');
+});

package/test/rehydrate.test.mjs

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import test from 'node:test';
+import { compactConsumedToolResult, rehydrateContextRef } from '../src/context/index.js';
+
+const sha = value => `sha256:${createHash('sha256').update(value).digest('hex')}`;
+
+test('large consumed evidence can leave active context and later rehydrate by stable ref/hash', async () => {
+  const source = 'important evidence '.repeat(800);
+  const ref = 'tool:call_123';
+  const digest = sha(source);
+  const compacted = compactConsumedToolResult(source, { ref, hash: digest });
+  assert.equal(compacted.compacted, true);
+  assert.equal(compacted.chars, 4_000);
+  assert.equal(compacted.source_chars, source.length);
+  const adapter = { async read(requested) { assert.equal(requested, ref); return { content: source, hash: digest, kind: 'tool_result' }; } };
+  const restored = await rehydrateContextRef(ref, adapter, { expectedHash: digest, kind: 'tool_result', maxChars: 64_000 });
+  assert.equal(restored.content, source);
+  assert.equal(restored.hash, digest);
+  assert.equal(restored.truncated, false);
+});
+
+test('rehydration fails closed when stable source hash changed', async () => {
+  await assert.rejects(() => rehydrateContextRef('file:x', async () => ({ content: 'changed' }), { expectedHash: sha('original') }), /rehydration_hash_mismatch/);
+});

package/test/release-hygiene.test.mjs

@@ -6,15 +6,15 @@ import test from 'node:test';
 const root = path.resolve(import.meta.dirname, '..');
 const read = (rel) => fs.readFileSync(path.join(root, rel), 'utf8');
 
-test('2.5 release metadata and public terminal vocabulary are aligned', () => {
+test('2.6 release metadata and public terminal vocabulary are aligned', () => {
   const pkg = JSON.parse(read('package.json'));
   const manifest = read('agentsam.yaml');
   const readme = read('README.md');
 
-  assert.equal(pkg.version, '2.5.0');
-  assert.match(manifest, /target_version: "2\.5\.0"/);
+  assert.equal(pkg.version, '2.6.0');
+  assert.match(manifest, /target_version: "2.6.0"/);
   assert.match(manifest, /state: release_candidate/);
-  assert.match(manifest, /current_latest: "2\.4\.1"/);
+  assert.match(manifest, /current_latest: "2.5.0"/);
   assert.doesNotMatch(manifest, /^\s*- tui\s*$/m);
   assert.doesNotMatch(readme, /agentsam tui|CLI\/TUI/);
 });

package/test/responses-runner.test.mjs

@@ -0,0 +1,148 @@
+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 { createCapabilityAdapter } from '../src/agent/capability-adapter.js';
+import { buildAgentToolSurface, capabilityFunctionName, runResponsesAgent } from '../src/agent/responses-runner.js';
+
+function usage(input = 10_000, cumulative = input) {
+  return {
+    current_context: { input_tokens: input, window_tokens: 1_050_000 },
+    cumulative: { input_tokens: cumulative, output_tokens: 100, cached_input_tokens: 0, cache_write_tokens: 0, reasoning_tokens: 0 },
+    estimate_kind: 'provider', provider_authoritative: true,
+  };
+}
+function cost(total = 0.1) { return { total_usd: total }; }
+
+test('capability adapter hydrates packaged JSON schemas and tool surface exposes only selected executable schemas', () => {
+  const adapter = createCapabilityAdapter();
+  const descriptors = adapter.toolDescriptors();
+  assert.deepEqual(descriptors.map((row) => row.name).sort(), ['cloudflare.cpu.profile', 'cloudflare.wrangler.native', 'repository.snapshot']);
+  const repository = descriptors.find((row) => row.name === 'repository.snapshot');
+  assert.equal(repository.input_schema.type, 'object');
+  assert.ok(repository.input_schema.properties.cwd);
+  const surface = buildAgentToolSurface(adapter, 'snapshot inspect repository');
+  assert.equal(surface.tools.length, 1);
+  assert.equal(surface.tools[0].name, capabilityFunctionName('repository.snapshot'));
+  assert.equal(surface.tools[0].parameters.type, 'object');
+  assert.equal(surface.receipt.catalog_tools, 3);
+});
+
+test('runner owns cwd, executes selected tool, preserves call_id and returns provider-authoritative continuation', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runner-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(root, '.git'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"runner-demo"}');
+  let invoked = null;
+  const capabilityAdapter = createCapabilityAdapter({
+    handlers: {
+      'repository.snapshot': async input => {
+        invoked = input;
+        return { ok: true, cwd: input.cwd, evidence: 'x'.repeat(500) };
+      },
+    },
+  });
+  const provider = {
+    async create(params) {
+      assert.equal(params.model, 'gpt-6-astra');
+      assert.equal(params.reasoningEffort, 'high');
+      assert.equal(params.serviceTier, 'fast');
+      assert.equal(params.tools.length, 1);
+      return {
+        response_id: 'resp_1', output_text: '', actual_service_tier: 'fast',
+        tool_calls: [{ call_id: 'call_1', name: capabilityFunctionName('repository.snapshot'), arguments: '{"cwd":"/tmp/attacker","churnDays":7}' }],
+        usage_snapshot: usage(20_000), cost: cost(0.2),
+      };
+    },
+    async continueWithToolOutputs(params) {
+      assert.equal(params.previousResponseId, 'resp_1');
+      assert.equal(params.toolOutputs[0].call_id, 'call_1');
+      assert.match(params.toolOutputs[0].output, /runner-demo|runner-/);
+      return { response_id: 'resp_2', output_text: 'done', actual_service_tier: 'fast', tool_calls: [], usage_snapshot: usage(21_000, 41_000), cost: cost(0.3) };
+    },
+    async compact() { throw new Error('should_not_compact'); },
+  };
+  const events = [];
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: root, prompt: 'snapshot inspect repository', model: 'gpt-6-astra', reasoningEffort: 'high', serviceTier: 'fast',
+    emit: event => events.push(event),
+  });
+  assert.equal(invoked.cwd, root);
+  assert.equal(invoked.churnDays, 7);
+  assert.equal(result.output_text, 'done');
+  assert.equal(result.response_id, 'resp_2');
+  assert.equal(result.total_cost_usd, 0.5);
+  assert.equal(result.continuation.compact_before_next_turn, false);
+  assert.ok(events.some(event => event.type === 'tool.search'));
+  assert.ok(events.some(event => event.type === 'tool.completed'));
+});
+
+test('runtime approval hook can deny a model-triggered tool before execution', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runner-denied-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"denied-demo"}');
+  let invoked = false;
+  const capabilityAdapter = createCapabilityAdapter({
+    handlers: {
+      'repository.snapshot': async () => { invoked = true; return { ok: true }; },
+    },
+  });
+  const provider = {
+    async create() {
+      return {
+        response_id: 'resp_deny', output_text: '', actual_service_tier: 'default',
+        tool_calls: [{ call_id: 'call_deny', name: capabilityFunctionName('repository.snapshot'), arguments: '{}' }],
+        usage_snapshot: usage(10_000), cost: cost(0.01),
+      };
+    },
+    async continueWithToolOutputs() { throw new Error('continuation_should_not_run'); },
+  };
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: root, prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    beforeTool: async request => {
+      assert.equal(request.capability_id, 'repository.snapshot');
+      assert.equal(request.cwd, root);
+      return false;
+    },
+  }), /tool_execution_not_approved:repository\.snapshot/);
+  assert.equal(invoked, false);
+});
+
+test('runner compacts before a projected high-context continuation rather than crossing normal policy blindly', async () => {
+  let compactCalls = 0;
+  let createInput = null;
+  const capabilityAdapter = createCapabilityAdapter();
+  const provider = {
+    async compact(params) {
+      compactCalls += 1;
+      assert.equal(params.previousResponseId, 'resp_old');
+      return { output: [{ type: 'compaction', encrypted_content: 'opaque-small' }] };
+    },
+    async create(params) {
+      createInput = params.input;
+      assert.equal(params.previousResponseId, undefined);
+      return { response_id: 'resp_new', output_text: 'ok', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(30_000), cost: cost(0.1) };
+    },
+    async continueWithToolOutputs() { throw new Error('unused'); },
+  };
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'continue repository work', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    previousResponseId: 'resp_old', previousUsageSnapshot: usage(179_500),
+  });
+  assert.equal(compactCalls, 1);
+  assert.ok(Array.isArray(createInput));
+  assert.equal(createInput[0].type, 'compaction');
+  assert.equal(result.compacted_before_turn, true);
+});
+
+test('runner refuses an oversized initial context and supports an explicit projected call-cost ceiling', async () => {
+  const capabilityAdapter = createCapabilityAdapter();
+  const provider = { async create() { throw new Error('provider_should_not_run'); }, async continueWithToolOutputs() {}, async compact() {} };
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'x'.repeat(800_000), model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+  }), /context_preflight_(pricing_threshold|max_normal|compaction_required)/);
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'small task', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'fast', maxCallCostUsd: 0.01,
+  }), /projected_call_cost_exceeds_budget/);
+});