@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.8

package/test/integration/plugins-cloudflare.integration.test.mjs

@@ -1,28 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import {
-  AGENTSAM_MCP_PLUGIN_MANIFEST,
-  INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST,
-} from '../../src/plugins/index.js';
-
-test('Cloudflare OAuth installations have distinct client and callback contracts', () => {
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.plugin_key, 'agentsam-mcp');
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.auth_type, 'oauth');
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.oauth_connect_url, '/api/connections/cloudflare/start');
-  assert.equal(
-    AGENTSAM_MCP_PLUGIN_MANIFEST.config.callback_url,
-    'https://agentsam.inneranimalmedia.com/api/connections/cloudflare/callback',
-  );
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.config.token_auth_method, 'none_pkce');
-
-  assert.equal(INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.plugin_key, 'inneranimalmedia-cf-oauth');
-  assert.equal(INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.auth_type, 'oauth_via_iam');
-  assert.equal(
-    INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.oauth_connect_url,
-    'https://inneranimalmedia.com/api/oauth/cloudflare/start',
-  );
-  assert.equal(
-    INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.config.callback_url,
-    'https://inneranimalmedia.com/api/oauth/cloudflare/callback',
-  );
-});

package/test/integration/provider-env-cli.test.mjs

@@ -1,60 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import test from 'node:test';
-
-const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
-/** Repo bin first — clean CI has no global `agentsam`; loader requires it on PATH. */
-function testEnv(home, extra = {}) {
-  return {
-    ...process.env,
-    ...extra,
-    HOME: home,
-    PATH: `${path.join(repoRoot, 'bin')}${path.delimiter}${process.env.PATH || ''}`,
-  };
-}
-
-test('agentsam env init creates provider profile and reusable source loader', { skip: process.platform === 'win32' }, t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-cli-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const env = testEnv(home);
-  const result = spawnSync(process.execPath, ['src/cli.js', 'env', 'init', 'openai'], { cwd: repoRoot, env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh(?:\s|$)/);
-  assert.doesNotMatch(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh openai/);
-  assert.equal(fs.statSync(path.join(home, '.agentsam', 'env.d', 'openai.env')).mode & 0o777, 0o600);
-  assert.equal(fs.statSync(path.join(home, '.agentsam', 'load-agent-env.sh')).mode & 0o777, 0o700);
-});
-
-
-test('Cloudflare env init backfills exactly one Wrangler account without printing credentials', async t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-cf-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const { runEnv } = await import('../../src/commands/env.js');
-  let output = '';
-  await runEnv(['init', 'cloudflare'], {
-    home, env: { HOME: home }, write: text => { output += text; },
-    spawnSyncImpl: () => ({ status: 0, stdout: JSON.stringify({ accounts: [{ id: '11111111111111111111111111111111', name: 'Example' }] }), stderr: '' }),
-  });
-  const profile = fs.readFileSync(path.join(home, '.agentsam', 'env.d', 'cloudflare.env'), 'utf8');
-  assert.match(profile, /CLOUDFLARE_ACCOUNT_ID="11111111111111111111111111111111"/);
-  assert.match(profile, /CLOUDFLARE_API_TOKEN=""/);
-  assert.match(output, /account  detected\/configured/);
-  assert.doesNotMatch(output, /CLOUDFLARE_API_TOKEN=.*[^ ]/);
-});
-
-
-test('generated loader exports the selected provider profile into the caller shell', { skip: process.platform === 'win32' }, t => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-source-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const env = testEnv(home);
-  let result = spawnSync(process.execPath, ['src/cli.js', 'env', 'init', 'openai'], { cwd: repoRoot, env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-  fs.writeFileSync(path.join(home, '.agentsam', 'env.d', 'openai.env'), 'export OPENAI_API_KEY="sentinel-provider-key"\
-', { mode: 0o600 });
-  // Use bash -c (not -lc): a login shell resets PATH and drops the repo bin/agentsam needed on clean CI.
-  result = spawnSync('bash', ['-c', 'source "$HOME/.agentsam/load-agent-env.sh" openai && test "$OPENAI_API_KEY" = "sentinel-provider-key"'], { env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-});

package/test/integration/provider-factory.test.mjs

@@ -1,197 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createProviderAdapter } from '../../src/providers/index.js';
-
-function response(body, status = 200, headers = {}) {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    headers: { get(name) { return headers[String(name).toLowerCase()] || null; } },
-    async json() { return body; },
-    async text() { return JSON.stringify(body); },
-  };
-}
-
-test('OpenAI-compatible adapter accepts provider-discovered records and preserves cache key', async () => {
-  let body;
-  const record = {
-    model_key: 'openai:account-model',
-    provider: 'openai',
-    provider_model_id: 'account-model',
-    context_window: 128000,
-    max_output_tokens: 8192,
-    reasoning_efforts: ['auto'],
-    service_tiers: ['default'],
-    capabilities: { responses: true },
-    pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'key' },
-    fetchImpl: async (url, init) => {
-      assert.match(url, /\/v1\/responses$/);
-      body = JSON.parse(init.body);
-      return response({
-        id: 'resp_1',
-        status: 'completed',
-        output_text: 'hello',
-        output: [],
-        usage: { input_tokens: 12, output_tokens: 3, input_tokens_details: { cached_tokens: 5 } },
-      });
-    },
-  });
-  const result = await provider.create({
-    model: record.provider_model_id,
-    modelRecord: record,
-    input: 'hi',
-    reasoningEffort: 'auto',
-    serviceTier: 'default',
-    promptCacheKey: 'session-1',
-  });
-  assert.equal(body.prompt_cache_key, 'session-1');
-  assert.equal(body.reasoning, undefined);
-  assert.equal(result.output_text, 'hello');
-  assert.equal(result.provider_state.previous_response_id, 'resp_1');
-  assert.equal(result.usage_snapshot.current_context.window_tokens, 128000);
-});
-
-
-
-test('xAI adapter supports native compaction without requiring a live API key in tests', async () => {
-  const requests = [];
-  const record = {
-    model_key: 'grok:grok-test',
-    provider: 'grok',
-    provider_model_id: 'grok-test',
-    context_window: 256000,
-    max_output_tokens: 8192,
-    reasoning_efforts: ['auto'],
-    service_tiers: ['default'],
-    capabilities: { responses: true, compaction: true, prompt_caching: true },
-    pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'xai-key' },
-    fetchImpl: async (url, init) => {
-      const body = JSON.parse(init.body);
-      requests.push({ url, body });
-      if (url.endsWith('/responses/compact')) {
-        return response({
-          id: 'cmp_1',
-          object: 'response.compaction',
-          output: [{ type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' }],
-          usage: { input_tokens: 1000, output_tokens: 120, input_tokens_details: { cached_tokens: 0 } },
-        });
-      }
-      return response({
-        id: 'resp_xai_1',
-        status: 'completed',
-        output_text: 'first answer',
-        output: [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'first answer' }] }],
-        usage: { input_tokens: 50, output_tokens: 10, input_tokens_details: { cached_tokens: 20 } },
-      });
-    },
-  });
-
-  const first = await provider.create({
-    modelRecord: record,
-    input: 'hello',
-    instructions: 'stable system prefix',
-    promptCacheKey: 'session-xai',
-  });
-  assert.equal(first.provider_state.previous_response_id, 'resp_xai_1');
-  assert.equal(Array.isArray(first.provider_state.compaction_input), true);
-  assert.equal(first.provider_state.compaction_input[0].role, 'system');
-
-  const compacted = await provider.compact({
-    modelRecord: record,
-    providerState: first.provider_state,
-    tokensBefore: 1000,
-  });
-  assert.match(requests.at(-1).url, /\/v1\/responses\/compact$/);
-  assert.equal(Array.isArray(requests.at(-1).body.input), true);
-  assert.equal(requests.at(-1).body.previous_response_id, undefined);
-  assert.deepEqual(compacted.provider_state.compaction_input, [
-    { type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' },
-  ]);
-  assert.equal(compacted.provider_state.previous_response_id, null);
-
-  await provider.create({
-    modelRecord: record,
-    providerState: compacted.provider_state,
-    input: 'continue after compaction',
-    promptCacheKey: 'session-xai',
-  });
-  assert.deepEqual(requests.at(-1).body.input, [
-    { type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' },
-    { role: 'user', content: 'continue after compaction' },
-  ]);
-});
-
-
-test('Anthropic adapter keeps append-only provider state and tool calls', async () => {
-  const record = {
-    model_key: 'anthropic:claude-test', provider: 'anthropic', provider_model_id: 'claude-test',
-    context_window: 200000, max_output_tokens: 4096, reasoning_efforts: ['auto'], service_tiers: ['default'], pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'key' },
-    fetchImpl: async () => response({
-      id: 'msg_1', stop_reason: 'tool_use',
-      content: [{ type: 'tool_use', id: 'toolu_1', name: 'as_test', input: { a: 1 } }],
-      usage: { input_tokens: 20, output_tokens: 5, cache_read_input_tokens: 7 },
-    }),
-  });
-  const result = await provider.create({
-    modelRecord: record,
-    input: 'do it',
-    instructions: 'stable prefix',
-    tools: [{ type: 'function', name: 'as_test', description: 'test', parameters: { type: 'object', properties: {} } }],
-  });
-  assert.equal(result.tool_calls[0].call_id, 'toolu_1');
-  assert.equal(result.provider_state.messages.at(-1).role, 'assistant');
-  assert.equal(result.usage_snapshot.cumulative.cached_input_tokens, 7);
-});
-
-test('Gemini adapter maps provider token limits and function calls into AgentSam shape', async () => {
-  const record = {
-    model_key: 'gemini:gemini-test', provider: 'gemini', provider_model_id: 'gemini-test',
-    context_window: 1000000, max_output_tokens: 8192, reasoning_efforts: ['auto'], service_tiers: ['default'], pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'key' },
-    fetchImpl: async () => response({
-      responseId: 'gem_1',
-      candidates: [{ finishReason: 'STOP', content: { role: 'model', parts: [{ functionCall: { name: 'as_test', args: { x: 2 } } }] } }],
-      usageMetadata: { promptTokenCount: 30, candidatesTokenCount: 8, cachedContentTokenCount: 10, thoughtsTokenCount: 2 },
-    }),
-  });
-  const result = await provider.create({ modelRecord: record, input: 'go', tools: [{ type: 'function', name: 'as_test', parameters: { type: 'object' } }] });
-  assert.equal(result.tool_calls[0].name, 'as_test');
-  assert.equal(result.usage_snapshot.current_context.window_tokens, 1000000);
-  assert.equal(result.usage_snapshot.cumulative.reasoning_tokens, 2);
-});
-
-test('Cloudflare adapter executes account-scoped Workers AI through the connected account', async () => {
-  let seen;
-  const record = {
-    model_key: 'cloudflare:@cf/test/model', provider: 'cloudflare', provider_model_id: '@cf/test/model',
-    context_window: null, max_output_tokens: null, reasoning_efforts: ['auto'], service_tiers: ['default'], pricing: null,
-  };
-  const provider = createProviderAdapter({
-    modelRecord: record,
-    credential: { value: 'cf-token', account_id: '1234567890abcdef1234567890abcdef' },
-    fetchImpl: async (url, init) => {
-      seen = { url, headers: init.headers, body: JSON.parse(init.body) };
-      return response({ id: 'cf_1', choices: [{ finish_reason: 'stop', message: { role: 'assistant', content: 'done' } }], usage: { prompt_tokens: 9, completion_tokens: 2 } });
-    },
-  });
-  const result = await provider.create({ modelRecord: record, input: 'go' });
-  assert.match(seen.url, /accounts\/1234567890abcdef1234567890abcdef\/ai\/v1\/chat\/completions$/);
-  assert.equal(seen.headers['cf-aig-gateway-id'], 'default');
-  assert.equal(seen.body.model, '@cf/test/model');
-  assert.equal(result.output_text, 'done');
-});

package/test/integration/repository-company-graph.test.mjs

@@ -1,90 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { test } from 'node:test';
-import {
-  COMPANY_REPOSITORY_GRAPH_SCHEMA_VERSION,
-  createRepositoryContract,
-  createRepositoryDependency,
-  createRepositoryIdentity,
-} from '../../packages/agentsam-repository/src/contracts.js';
-
-const root = path.resolve(import.meta.dirname, '../..');
-
-function schema(relative) {
-  return JSON.parse(fs.readFileSync(path.join(root, relative), 'utf8'));
-}
-
-test('portable repository identity is account-independent', () => {
-  const identity = createRepositoryIdentity({
-    repository_id: 'repo_agentsam_sdk',
-    full_name: 'SamPrimeaux/agentsam-sdk',
-    role: 'contract/runtime SDK',
-    default_branch: 'main',
-  });
-  assert.equal(identity.schema_version, COMPANY_REPOSITORY_GRAPH_SCHEMA_VERSION);
-  assert.equal(identity.repository_id, 'repo_agentsam_sdk');
-  assert.equal(Object.hasOwn(identity, 'account_id'), false);
-  assert.throws(() => createRepositoryIdentity({
-    repository_id: 'repo_x', full_name: 'owner/repo', role: 'test', account_id: 'au_test',
-  }), /must not embed account_id/);
-});
-
-test('repository contracts use account and repository SSOT only', () => {
-  const record = createRepositoryContract({
-    id: 'rct_runtime_receipts_v2',
-    account_id: 'au_test',
-    repository_id: 'repo_agentsam_sdk',
-    contract_key: 'runtime-receipts',
-    contract_version: '2',
-    contract_type: 'schema',
-    name: 'Runtime receipts',
-    manifest_path: 'protocol/telemetry',
-    contract_hash: `sha256:${'1'.repeat(64)}`,
-  });
-  assert.equal(record.account_id, 'au_test');
-  assert.equal(record.contract_type, 'schema');
-  assert.equal(record.status, 'active');
-  assert.throws(() => createRepositoryContract({
-    ...record, id: 'bad', workspace_id: 'ws_old',
-  }), /legacy ownership field/);
-});
-
-test('repository dependencies encode cross-repo criticality and failure policy', () => {
-  const edge = createRepositoryDependency({
-    id: 'rdep_iam_execos',
-    account_id: 'au_test',
-    source_repository_id: 'repo_inneranimalmedia',
-    target_repository_id: 'repo_execos',
-    dependency_type: 'runtime',
-    criticality: 'critical',
-    required_version: '1',
-    required_contract_hash: `sha256:${'2'.repeat(64)}`,
-    failure_policy: 'block_deploy',
-  });
-  assert.equal(edge.dependency_type, 'runtime');
-  assert.equal(edge.criticality, 'critical');
-  assert.equal(edge.failure_policy, 'block_deploy');
-  assert.throws(() => createRepositoryDependency({ ...edge, criticality: 'whatever' }), /unsupported criticality/);
-  assert.throws(() => createRepositoryDependency({ ...edge, owner_user_id: 'usr_old' }), /legacy ownership field/);
-});
-
-test('published JSON schemas expose the same ownership boundary', () => {
-  const identity = schema('protocol/repository/repository-identity.schema.json');
-  const contract = schema('protocol/repository/repository-contract.schema.json');
-  const dependency = schema('protocol/repository/repository-dependency.schema.json');
-
-  assert.equal(identity.additionalProperties, false);
-  assert.equal(Object.hasOwn(identity.properties, 'account_id'), false);
-  assert.ok(contract.required.includes('account_id'));
-  assert.ok(contract.required.includes('repository_id'));
-  assert.ok(dependency.required.includes('account_id'));
-  assert.ok(dependency.required.includes('source_repository_id'));
-  assert.ok(dependency.required.includes('target_repository_id'));
-
-  for (const item of [identity, contract, dependency]) {
-    for (const legacy of ['tenant_id', 'workspace_id', 'user_id', 'owner_user_id']) {
-      assert.equal(Object.hasOwn(item.properties, legacy), false, `${legacy} must not be part of ${item.title}`);
-    }
-  }
-});

package/test/integration/runtime-migrations.test.mjs

@@ -1,87 +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 { createLocalSqliteDatabase } from '../../src/local/sqlite.js';
-import { applyRuntimeMigrations } from '../../src/local/migrations.js';
-
-const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
-
-test('portable runtime migration installs AgentSam CLI state tables idempotently', async (t) => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runtime-migration-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const db = await createLocalSqliteDatabase(path.join(root, 'agentsam.sqlite'));
-  try {
-    const first = await applyRuntimeMigrations(db);
-    const migrationCount = fs.readdirSync(path.join(repoRoot, 'migrations', 'runtime'))
-      .filter((name) => /^\d+.*\.sql$/i.test(name)).length;
-    assert.equal(first.applied, migrationCount);
-
-    const tables = await db.prepare(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'agentsam_%' ORDER BY name"
-    ).all();
-    const names = new Set(tables.results.map((row) => row.name));
-    for (const name of [
-      'agentsam_agent_run',
-      'agentsam_approval_queue',
-      'agentsam_compaction_events',
-      'agentsam_context_digest',
-      'agentsam_cron_runs',
-      'agentsam_plans',
-      'agentsam_project_sessions',
-      'agentsam_schema_migrations',
-      'agentsam_todo',
-    ]) assert.equal(names.has(name), true, name);
-
-    const timers = await db.prepare(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name='active_timers'"
-    ).first();
-    assert.equal(timers.name, 'active_timers');
-
-    const second = await applyRuntimeMigrations(db);
-    assert.equal(second.applied, 0);
-    assert.equal(second.results[0].status, 'already_applied');
-  } finally {
-    db.close();
-  }
-});
-
-test('ephemeral context digests expire and refresh while durable digests stay durable', async (t) => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-digest-migration-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const db = await createLocalSqliteDatabase(path.join(root, 'agentsam.sqlite'));
-  try {
-    await applyRuntimeMigrations(db);
-
-    await db.prepare(
-      "INSERT INTO agentsam_context_digest (id,digest_type,source_hash,digest_hash,digest_text) VALUES (?,?,?,?,?)"
-    ).bind('repo_1', 'repo', 's1', 'h1', 'durable').run();
-    const durable = await db.prepare(
-      'SELECT expires_at_unix FROM agentsam_context_digest WHERE id=?'
-    ).bind('repo_1').first();
-    assert.equal(durable.expires_at_unix, null);
-
-    await db.prepare(
-      "INSERT INTO agentsam_context_digest (id,digest_type,source_hash,digest_hash,digest_text) VALUES (?,?,?,?,?)"
-    ).bind('session_1', 'session', 's2', 'h2', 'ephemeral').run();
-    const initial = await db.prepare(
-      'SELECT expires_at_unix FROM agentsam_context_digest WHERE id=?'
-    ).bind('session_1').first();
-    assert.equal(Number(initial.expires_at_unix) > 0, true);
-
-    await db.prepare(
-      'UPDATE agentsam_context_digest SET expires_at_unix = unixepoch() + 60 WHERE id=?'
-    ).bind('session_1').run();
-    await db.prepare(
-      'UPDATE agentsam_context_digest SET hit_count = hit_count + 1 WHERE id=?'
-    ).bind('session_1').run();
-    const refreshed = await db.prepare(
-      'SELECT expires_at_unix, hit_count FROM agentsam_context_digest WHERE id=?'
-    ).bind('session_1').first();
-    assert.equal(refreshed.hit_count, 1);
-    assert.equal(Number(refreshed.expires_at_unix) > Math.floor(Date.now() / 1000) + 2_500_000, true);
-  } finally {
-    db.close();
-  }
-});