@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.0

package/test/shell.test.mjs

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import test from 'node:test';
 import { dispatchShellLine, renderShellCatalog, renderShellPrompt, tokenizeShellLine } from '../src/commands/shell.js';
+import { readCliPreferences, writeCliPreferences } from '../src/lib/cli-preferences.js';
 
 const repoRoot = path.resolve(new URL('..', import.meta.url).pathname);
 
@@ -21,47 +22,73 @@ test('interactive prompt derives username and cwd instead of hardcoding Agent Sa
   assert.equal(renderShellPrompt('/tmp/demo', env), 'alice /tmp/demo > ');
 });
 
-test('shell catalog advertises commands that the REPL owns', () => {
+test('shell catalog only advertises implemented core controls', () => {
   const catalog = renderShellCatalog();
-  assert.match(catalog, /\/help\s+Show Agent Sam commands/);
-  assert.match(catalog, /\/status\s+Local project/);
-  assert.match(catalog, /\/exit\s+Exit Agent Sam shell/);
+  for (const command of ['/model', '/reasoning', '/fast', '/flex', '/standard', '/context', '/cf', '/diff', '/clear', '/exit']) {
+    assert.match(catalog, new RegExp(command.replace('/', '\\/')));
+  }
+  assert.match(catalog, /scrollable command picker/);
 });
 
-test('dispatch handles help, pwd, cd, and exit without falling through to host shell', async () => {
+test('dispatch handles help, menu fallback, pwd, cd, and exit without falling through to host shell', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-'));
   const child = path.join(root, 'child folder');
   fs.mkdirSync(child);
   let output = '';
-  const state = { cwd: root, write: (text) => { output += text; } };
-
+  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
   let result = await dispatchShellLine('/help', state);
   assert.equal(result.handled, true);
-  assert.equal(result.exit, false);
   assert.match(output, /Slash commands/);
-
   output = '';
-  result = await dispatchShellLine('/pwd', state);
-  assert.equal(result.handled, true);
+  await dispatchShellLine('/', state);
+  assert.match(output, /Agent Sam Terminal/);
+  output = '';
+  await dispatchShellLine('/pwd', state);
   assert.equal(output.trim(), root);
-
   output = '';
-  result = await dispatchShellLine('/cd "child folder"', state);
-  assert.equal(result.handled, true);
+  await dispatchShellLine('/cd "child folder"', state);
   assert.equal(state.cwd, child);
   assert.equal(output.trim(), child);
-
   result = await dispatchShellLine('/exit', state);
   assert.equal(result.exit, true);
 });
 
+test('reasoning and service-tier commands persist only supported controls for an exact model', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-model-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'model-demo' }));
+  writeCliPreferences(root, { trustedDirectory: true, modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default' });
+  let output = '';
+  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
+  await dispatchShellLine('/reasoning high', state);
+  assert.equal(readCliPreferences(root).reasoningEffort, 'high');
+  await dispatchShellLine('/fast', state);
+  assert.equal(readCliPreferences(root).serviceTier, 'fast');
+  await dispatchShellLine('/flex', state);
+  assert.equal(readCliPreferences(root).serviceTier, 'flex');
+  await dispatchShellLine('/standard', state);
+  assert.equal(readCliPreferences(root).serviceTier, 'default');
+  assert.match(output, /reasoning → high/);
+  assert.match(output, /Fast is a paid latency choice/);
+  assert.match(output, /Flex trades latency/);
+});
+
+test('bare /context shows truthful economics without inventing active token usage', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-context-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'context-demo' }));
+  writeCliPreferences(root, { trustedDirectory: true, modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'medium', serviceTier: 'default' });
+  let output = '';
+  await dispatchShellLine('/context', { cwd: root, write: (text) => { output += text; }, interactive: false });
+  assert.match(output, /1,050,000/);
+  assert.match(output, /272,000/);
+  assert.match(output, /180,000/);
+  assert.match(output, /unavailable · no provider\/local usage snapshot yet/);
+  assert.match(output, /Batch is a separate asynchronous execution lane/);
+});
+
 test('CLI supports a deterministic one-shot slash command for regression tests', () => {
-  const result = spawnSync(process.execPath, ['src/cli.js', 'shell', '--command', '/help'], {
-    cwd: repoRoot,
-    encoding: 'utf8',
-  });
+  const result = spawnSync(process.execPath, ['src/cli.js', 'shell', '--command', '/help'], { cwd: repoRoot, encoding: 'utf8' });
   assert.equal(result.status, 0, result.stderr);
   assert.match(result.stdout, /Agent Sam Terminal/);
-  assert.match(result.stdout, /\/help/);
+  assert.match(result.stdout, /\/model/);
   assert.match(result.stdout, /\/exit/);
 });

package/test/smoke.mjs

@@ -55,9 +55,12 @@ await assert.rejects(() => finalizeInboundOAuth({}, new Request('https://x'), {}
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/deploy'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/db'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/agent'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/model'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/reasoning'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/fast'));
 assert.deepEqual(
   listSlashCommands({ lane: 'deploy' }).map(({ cmd }) => cmd),
-  ['/help', '/models', '/settings', '/deploy', '/exit'],
+  ['/settings', '/deploy', '/help', '/exit'],
   'deploy lane keeps global shell controls and excludes commands from other lanes',
 );
 

package/test/telemetry.test.mjs

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, createUsageSnapshot } from '../src/telemetry/index.js';
+
+test('AgentEvent is compact serializable provider-neutral telemetry', () => {
+  const event = createAgentEvent('context.compaction.completed', { before: 181_000, after: 72_000 }, {
+    runId: 'run_test', sequence: 4, timestamp: '2026-09-12T00:00:00.000Z',
+  });
+  assert.equal(event.type, 'context.compaction.completed');
+  assert.equal(event.run_id, 'run_test');
+  assert.doesNotThrow(() => JSON.stringify(event));
+});
+
+test('current active context and cumulative run usage are different metrics', () => {
+  const usage = createUsageSnapshot({
+    current_context: { input_tokens: 48_000, window_tokens: 1_050_000 },
+    cumulative: { input_tokens: 310_000, output_tokens: 22_000, cached_input_tokens: 120_000, cache_write_tokens: 12_000, reasoning_tokens: 8_000 },
+    estimate_kind: 'provider',
+  });
+  assert.equal(usage.current_context.input_tokens, 48_000);
+  assert.equal(usage.cumulative.input_tokens, 310_000);
+  assert.equal(usage.provider_authoritative, true);
+});
+
+import {
+  createRunReceipt,
+  createUsageReceipt,
+  createApprovalReceipt,
+  createTerminalJobReceipt,
+} from '../src/telemetry/index.js';
+
+test('runtime receipts are account-owned and emit no tenant/workspace/user ownership aliases', () => {
+  const run = createRunReceipt({
+    id: 'arun_1', account_id: 'au_1', mode: 'agent', status: 'running',
+    source_client: 'cli', surface: 'cli', reasoning_effort: 'high', requested_service_tier: 'fast',
+  });
+  assert.equal(run.account_id, 'au_1');
+  assert.equal(run.source_client, 'cli');
+  assert.equal(run.requested_service_tier, 'fast');
+  assert.equal('user_id' in run, false);
+  assert.equal('tenant_id' in run, false);
+  assert.equal('workspace_id' in run, false);
+});
+
+test('usage receipt models exactly one provider call and keeps cache/reasoning economics', () => {
+  const usage = createUsageReceipt({
+    id: 'ue_1', account_id: 'au_1', agent_run_id: 'arun_1', provider: 'openai', model_key: 'gpt-6-astra',
+    model_call_index: 2, provider_request_id: 'resp_1', input_tokens: 1000, cached_input_tokens: 600,
+    cache_write_tokens: 20, output_tokens: 100, reasoning_tokens: 40, cost_usd: 0.12, cost_basis: 'provider',
+  });
+  assert.equal(usage.total_tokens, 1100);
+  assert.equal(usage.cached_input_tokens, 600);
+  assert.equal(usage.reasoning_tokens, 40);
+  assert.equal(usage.model_call_index, 2);
+});
+
+test('approval and terminal receipts preserve lineage without turning D1 into transcript storage', () => {
+  const approval = createApprovalReceipt({
+    id: 'appr_1', account_id: 'au_1', agent_run_id: 'arun_1', tool_call_id: 'call_1', terminal_job_id: 'tjob_1',
+    action_summary: 'Deploy worker', sanitizedInput: { worker: 'api' }, risk_level: 'high',
+  });
+  assert.equal(approval.terminal_job_id, 'tjob_1');
+  assert.match(approval.sanitized_input_json, /worker/);
+
+  const job = createTerminalJobReceipt({
+    id: 'tjob_1', account_id: 'au_1', instance_id: 'tinst_1', connection_id: 'conn_1',
+    execos_run_id: 'xrun_1', status: 'running', idempotency_key: 'idem_1', max_attempts: 1,
+  });
+  assert.equal(job.execos_run_id, 'xrun_1');
+  assert.equal(job.max_attempts, 1);
+  assert.equal('stdout' in job, false);
+  assert.equal('stderr' in job, false);
+  assert.equal('command' in job, false);
+});
+
+test('runtime receipts refuse model-invented account identity', () => {
+  assert.throws(() => createRunReceipt({ id: 'arun_1' }), /account_id is required/);
+  assert.throws(() => createUsageReceipt({ id: 'ue_1', provider: 'openai', model_key: 'gpt-6-astra' }), /account_id is required/);
+});

package/test/tools-search.test.mjs

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { getToolCatalog } from '../src/lib/tools.js';
-import { searchToolCards } from '../src/tools/index.js';
+import { hydrateToolSchemas, searchToolCards } from '../src/tools/index.js';
 import { DEFAULT_RESULT_POLICY } from '../src/context/index.js';
 
 test('every built-in SDK tool inherits a bounded result policy', () => {
@@ -25,3 +25,16 @@ test('tools.search returns compact cards rather than full schemas', () => {
   assert.equal('input_schema' in result.cards[0], false);
   assert.ok(result.receipt.chars < 24_000);
 });
+
+test('selected schemas hydrate without loading the full tool catalog', () => {
+  const catalog = Array.from({ length: 50 }, (_, index) => ({
+    name: `tool.${index}`,
+    description: `Capability ${index}`,
+    input_schema: { type: 'object', properties: { value: { type: 'string' }, padding: { description: 'x'.repeat(300) } } },
+  }));
+  const result = hydrateToolSchemas(catalog, ['tool.4', 'tool.22'], { maxTools: 4, maxChars: 5_000 });
+  assert.deepEqual(result.tools.map((tool) => tool.name), ['tool.4', 'tool.22']);
+  assert.equal(result.receipt.catalog_items, 50);
+  assert.equal(result.receipt.hydrated_tools, 2);
+  assert.ok(result.receipt.schema_chars < 5_000);
+});

package/test/whoami-resume.test.mjs

@@ -0,0 +1,56 @@
+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 { saveAccountSession } from '../src/lib/account-session.js';
+import { createLocalSession } from '../src/lib/local-sessions.js';
+import { collectWhoami } from '../src/commands/whoami.js';
+import { runResume } from '../src/commands/resume.js';
+
+function tempHome(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ux-home-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  return home;
+}
+
+test('whoami validates persisted IAM identity while never returning the SDK or provider secret', async t => {
+  const home = tempHome(t);
+  saveAccountSession({ access_token: 'sdk_do_not_print', user_id: 'au_local' }, { home });
+  const envDir = path.join(home, '.agentsam', 'env.d');
+  fs.mkdirSync(envDir, { recursive: true });
+  const openaiFile = path.join(envDir, 'openai.env');
+  fs.writeFileSync(openaiFile, 'OPENAI_API_KEY=sk-never-print-this\n', { mode: 0o600 });
+  if (process.platform !== 'win32') fs.chmodSync(openaiFile, 0o600);
+
+  const status = await collectWhoami({
+    env: {}, home,
+    contextLoader: async token => {
+      assert.equal(token, 'sdk_do_not_print');
+      return { user_id: 'au_server', account_id: 'acct_server', email: 'dev@example.test', cloudflare: { ok: true }, byok: { openai: { configured: true, masked: 'secret' } } };
+    },
+  });
+  assert.equal(status.authenticated, true);
+  assert.equal(status.identity.account_id, 'acct_server');
+  assert.equal(status.sdk_credential.source, 'agentsam_account_session');
+  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').configured, true);
+  const serialized = JSON.stringify(status);
+  assert.doesNotMatch(serialized, /sdk_do_not_print|sk-never-print-this|masked/);
+});
+
+test('resume restores saved cwd and session through the canonical shell runtime', async t => {
+  const home = tempHome(t);
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-resume-project-'));
+  t.after(() => fs.rmSync(cwd, { recursive: true, force: true }));
+  const session = createLocalSession({ cwd, title: 'Run wrangler whoami', model_key: 'openai:gpt-6-astra' }, { home });
+  let called = null;
+  const restored = await runResume([session.id], {
+    home,
+    write() {},
+    runShellImpl: async (argv, options) => { called = { argv, options }; },
+  });
+  assert.equal(restored.id, session.id);
+  assert.deepEqual(called.argv, []);
+  assert.equal(called.options.cwd, cwd);
+  assert.equal(called.options.session.id, session.id);
+});