carthagent 0.0.0-stage → 1.0.7

package/tests/subscription-models.test.mjs

@@ -0,0 +1,416 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  ANTHROPIC_PROVIDER_ID,
+  OPENAI_CODEX_PROVIDER_ID,
+  anthropicDiscoveryProviderConfig,
+  codexDiscoveryProviderConfig,
+  codexModelDefinition,
+  codexThinkingLevelMap,
+  credentialKey,
+  decodeChatGptAccountId,
+  fileSubscriptionCache,
+  matchCachedDiscovery,
+  mergeDiscoveredModels,
+  parseAnthropicModels,
+  parseCodexModels,
+  registerSubscriptionProviders,
+} from '../lib/providers/subscription-models.mjs';
+
+function jsonResponse(payload, status = 200) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => payload,
+    text: async () => JSON.stringify(payload),
+  };
+}
+
+function fakeJwt(claims) {
+  return ['h', Buffer.from(JSON.stringify(claims)).toString('base64url'), 's'].join('.');
+}
+
+const signal = () => new AbortController().signal;
+const noKnown = async () => [];
+const memoryCache = () => {
+  const entries = new Map();
+  return { read: async id => entries.get(id) ?? null, write: async (id, entry) => entries.set(id, entry), entries };
+};
+
+test('anthropic discovery fetches /v1/models with the subscription OAuth headers', async () => {
+  const calls = [];
+  const fetchImpl = async (url, options) => {
+    calls.push({ url: String(url), options });
+    return jsonResponse({ data: [
+      { type: 'model', id: 'claude-opus-9', display_name: 'Claude Opus 9' },
+      { type: 'model', id: 'claude-sonnet-9', display_name: 'Claude Sonnet 9' },
+    ], has_more: false });
+  };
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'oauth', access: 'sk-ant-oat', expires: Date.now() + 60_000 },
+    signal: signal(),
+    stored: undefined,
+  });
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].url, /^https:\/\/api\.anthropic\.com\/v1\/models\?/);
+  assert.equal(calls[0].options.headers.authorization, 'Bearer sk-ant-oat');
+  assert.equal(calls[0].options.headers['anthropic-beta'], 'oauth-2025-04-20');
+  assert.equal(calls[0].options.headers['anthropic-version'], '2023-06-01');
+  assert.deepEqual(refreshed.map(m => m.id), ['claude-opus-9', 'claude-sonnet-9']);
+  assert.equal(refreshed[0].api, 'anthropic-messages');
+  assert.equal(refreshed[0].reasoning, true);
+});
+
+test('anthropic discovery uses x-api-key for API key credentials and paginates', async () => {
+  const calls = [];
+  const fetchImpl = async (url, options) => {
+    calls.push({ url: String(url), options });
+    if (!String(url).includes('after_id')) {
+      return jsonResponse({ data: [{ type: 'model', id: 'claude-a' }], has_more: true, last_id: 'claude-a' });
+    }
+    return jsonResponse({ data: [{ type: 'model', id: 'claude-b' }], has_more: false });
+  };
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'api_key', key: 'sk-ant-key' },
+    signal: signal(),
+  });
+  assert.equal(calls.length, 2);
+  assert.equal(calls[0].options.headers['x-api-key'], 'sk-ant-key');
+  assert.equal(calls[0].options.headers.authorization, undefined);
+  assert.match(calls[1].url, /after_id=claude-a/);
+  assert.deepEqual(refreshed.map(m => m.id), ['claude-a', 'claude-b']);
+});
+
+test('codex discovery fetches /codex/models with bearer, account id, and originator', async () => {
+  const access = fakeJwt({ 'https://api.openai.com/auth': { chatgpt_account_id: 'acct-123' } });
+  const calls = [];
+  const fetchImpl = async (url, options) => {
+    calls.push({ url: String(url), options });
+    return jsonResponse({ models: [
+      { slug: 'gpt-9-codex', display_name: 'GPT-9 Codex', visibility: 'list', supported_reasoning_levels: ['low', 'medium', 'high', 'xhigh'] },
+      { slug: 'gpt-9-internal', visibility: 'hide' },
+    ] });
+  };
+  const config = codexDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'oauth', access },
+    signal: signal(),
+  });
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].url, /^https:\/\/chatgpt\.com\/backend-api\/codex\/models/);
+  assert.equal(calls[0].options.headers.authorization, `Bearer ${access}`);
+  assert.equal(calls[0].options.headers['chatgpt-account-id'], 'acct-123');
+  assert.equal(calls[0].options.headers.originator, 'pi');
+  assert.deepEqual(refreshed.map(m => m.id), ['gpt-9-codex']);
+  const discovered = refreshed[0];
+  assert.equal(discovered.api, 'openai-codex-responses');
+  assert.equal(discovered.baseUrl, 'https://chatgpt.com/backend-api');
+  assert.deepEqual(discovered.thinkingLevelMap, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: null });
+});
+
+test('stored catalog metadata wins over defaults for known ids; new ids get fallbacks', async () => {
+  const fetchImpl = async () => jsonResponse({ data: [
+    { type: 'model', id: 'claude-opus-4-5', display_name: 'Claude Opus 4.5' },
+    { type: 'model', id: 'claude-new-thing', display_name: 'Claude New Thing' },
+  ] });
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const stored = { models: [{
+    id: 'claude-opus-4-5', name: 'Claude Opus 4.5 (latest)', provider: 'anthropic',
+    api: 'anthropic-messages', baseUrl: 'https://api.anthropic.com',
+    contextWindow: 1_000_000, maxTokens: 128_000, reasoning: true,
+    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  }] };
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'oauth', access: 'tok' },
+    signal: signal(),
+    stored,
+  });
+  const known = refreshed.find(m => m.id === 'claude-opus-4-5');
+  assert.equal(known.contextWindow, 1_000_000);
+  assert.deepEqual(known.cost, { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 });
+  const unknown = refreshed.find(m => m.id === 'claude-new-thing');
+  assert.equal(unknown.contextWindow, 200_000);
+  assert.equal(unknown.maxTokens, 64_000);
+  assert.equal(unknown.name, 'Claude New Thing');
+  assert.equal(unknown.cost, undefined);
+});
+
+test('builtin definitions keep cost and limits when no stored entry exists', async () => {
+  const fetchImpl = async () => jsonResponse({ data: [
+    { type: 'model', id: 'claude-sonnet-4-5', display_name: 'Claude Sonnet 4.5' },
+  ] });
+  const builtin = {
+    id: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5', provider: 'anthropic',
+    api: 'anthropic-messages', baseUrl: 'https://api.anthropic.com',
+    contextWindow: 1_000_000, maxTokens: 64_000, reasoning: true,
+    cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  };
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: async () => [builtin] });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'api_key', key: 'k' },
+    signal: signal(),
+    stored: undefined,
+  });
+  const model = refreshed.find(m => m.id === 'claude-sonnet-4-5');
+  assert.equal(model.contextWindow, 1_000_000);
+  assert.deepEqual(model.cost, { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 });
+});
+
+test('stored catalog entries the endpoint did not return stay visible', async () => {
+  const fetchImpl = async () => jsonResponse({ data: [{ type: 'model', id: 'claude-b' }] });
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'oauth', access: 'tok' },
+    signal: signal(),
+    stored: { models: [
+      { id: 'claude-a', name: 'Claude A', provider: 'anthropic' },
+      { id: 'claude-b', name: 'Claude B stored', provider: 'anthropic', contextWindow: 42 },
+      { id: 'claude-c', name: 'Claude C', provider: 'anthropic' },
+    ] },
+  });
+  assert.deepEqual(refreshed.map(m => m.id), ['claude-b', 'claude-a', 'claude-c']);
+  assert.equal(refreshed[0].contextWindow, 42);
+});
+
+test('codex models the endpoint marks hidden are excluded from the stored fallback', async () => {
+  const access = fakeJwt({ 'https://api.openai.com/auth': { chatgpt_account_id: 'acct' } });
+  const fetchImpl = async () => jsonResponse({ models: [
+    { slug: 'gpt-new', visibility: 'list' },
+    { slug: 'gpt-old', visibility: 'hide' },
+  ] });
+  const config = codexDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'oauth', access },
+    signal: signal(),
+    stored: { models: [
+      { id: 'gpt-old', name: 'GPT Old', provider: 'openai-codex' },
+      { id: 'gpt-remote-extra', name: 'Remote Extra', provider: 'openai-codex' },
+    ] },
+  });
+  assert.deepEqual(refreshed.map(m => m.id), ['gpt-new', 'gpt-remote-extra']);
+});
+
+test('missing credentials and empty discovery leave the catalog untouched', async () => {
+  let called = 0;
+  const fetchImpl = async () => { called++; return jsonResponse({ data: [{ id: 'x' }] }); };
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  assert.equal(await config.refreshModels({ allowNetwork: true, signal: signal() }), undefined);
+  assert.equal(await config.refreshModels({ allowNetwork: true, credential: { type: 'other' }, signal: signal() }), undefined);
+  const empty = anthropicDiscoveryProviderConfig({ fetchImpl: async () => jsonResponse({ data: [] }), knownModels: noKnown });
+  assert.equal(await empty.refreshModels({ allowNetwork: true, credential: { type: 'api_key', key: 'k' }, signal: signal() }), undefined);
+  assert.equal(called, 0);
+});
+
+test('offline refresh restores the cached discovery for the same credential', async () => {
+  const cache = memoryCache();
+  const fetchImpl = async () => jsonResponse({ data: [
+    { type: 'model', id: 'claude-new-9', display_name: 'Claude New 9' },
+  ] });
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown, cache });
+  const credential = { type: 'oauth', access: 'tok', refresh: 'rt-1' };
+  await config.refreshModels({ allowNetwork: true, credential, signal: signal() });
+  assert.equal(cache.entries.get(ANTHROPIC_PROVIDER_ID).credential, credentialKey(credential));
+
+  const offline = await config.refreshModels({ allowNetwork: false, credential, signal: signal() });
+  assert.deepEqual(offline.map(m => m.id), ['claude-new-9']);
+  assert.equal(offline[0].api, 'anthropic-messages');
+});
+
+test('cached discovery is not restored for a different credential once migration expires', async () => {
+  const cache = memoryCache();
+  const fetchImpl = async () => jsonResponse({ data: [{ type: 'model', id: 'claude-new-9' }] });
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown, cache, cacheGraceMs: -1 });
+  await config.refreshModels({ allowNetwork: true, credential: { type: 'api_key', key: 'sk-one' }, signal: signal() });
+  assert.equal(await config.refreshModels({ allowNetwork: false, credential: { type: 'api_key', key: 'sk-two' }, signal: signal() }), undefined);
+});
+
+test('offline restore migrates to a rotated refresh token for a bounded window', async () => {
+  const cache = memoryCache();
+  const fetchImpl = async () => jsonResponse({ data: [{ type: 'model', id: 'claude-new-9' }] });
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown, cache });
+  const before = { type: 'oauth', access: 'tok-1', refresh: 'rt-1' };
+  const rotated = { type: 'oauth', access: 'tok-2', refresh: 'rt-2' };
+  assert.notEqual(credentialKey(rotated), credentialKey(before));
+  await config.refreshModels({ allowNetwork: true, credential: before, signal: signal() });
+  const offline = await config.refreshModels({ allowNetwork: false, credential: rotated, signal: signal() });
+  assert.deepEqual(offline.map(m => m.id), ['claude-new-9']);
+  assert.equal(offline[0].api, 'anthropic-messages');
+});
+
+test('a discovery under a rotated credential demotes the previous epoch and keeps it restorable', async () => {
+  const cache = memoryCache();
+  const fetchImpl = async () => jsonResponse({ data: [{ type: 'model', id: 'claude-m' }] });
+  const config = anthropicDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown, cache });
+  const first = { type: 'oauth', access: 'tok-1', refresh: 'rt-1' };
+  const second = { type: 'oauth', access: 'tok-2', refresh: 'rt-2' };
+  await config.refreshModels({ allowNetwork: true, credential: first, signal: signal() });
+  await config.refreshModels({ allowNetwork: true, credential: second, signal: signal() });
+  const entry = cache.entries.get(ANTHROPIC_PROVIDER_ID);
+  assert.equal(entry.credential, credentialKey(second));
+  assert.equal(entry.previous.credential, credentialKey(first));
+  assert.equal(entry.previous.discovered[0].id, 'claude-m');
+  // A same-credential re-discovery keeps the existing lineage.
+  await config.refreshModels({ allowNetwork: true, credential: second, signal: signal() });
+  assert.equal(cache.entries.get(ANTHROPIC_PROVIDER_ID).previous.credential, credentialKey(first));
+  // The demoted epoch still restores offline under the previous credential.
+  const restored = await config.refreshModels({ allowNetwork: false, credential: first, signal: signal() });
+  assert.deepEqual(restored.map(m => m.id), ['claude-m']);
+});
+
+test('matchCachedDiscovery matches exact, demoted, migrated, and expired epochs', () => {
+  const now = 1_000_000_000;
+  const day = 24 * 60 * 60 * 1000;
+  const graceMs = day;
+  const epoch = { credential: 'k1', checkedAt: now - 1000, discovered: [{ id: 'm' }], hiddenIds: [] };
+  assert.equal(matchCachedDiscovery(epoch, 'k1', { now, graceMs }), epoch);
+  // Exact matches are not bounded by the window.
+  const stale = { ...epoch, checkedAt: now - 30 * day };
+  assert.equal(matchCachedDiscovery(stale, 'k1', { now, graceMs }), stale);
+  // Credential changed without a discovery in between: migration fallback.
+  const migrated = { ...epoch, credential: 'k2' };
+  assert.equal(matchCachedDiscovery(migrated, 'k1', { now, graceMs }), migrated);
+  const expired = { ...epoch, credential: 'k2', checkedAt: now - day - 1 };
+  assert.equal(matchCachedDiscovery(expired, 'k1', { now, graceMs }), null);
+  // Demoted lineage is restorable under its own credential within the window.
+  const lineage = { ...epoch, credential: 'k3', previous: epoch };
+  assert.equal(matchCachedDiscovery(lineage, 'k3', { now, graceMs }), lineage);
+  assert.equal(matchCachedDiscovery(lineage, 'k1', { now, graceMs }), epoch);
+  assert.equal(matchCachedDiscovery(lineage, 'k1', { now, graceMs: -1 }), null);
+  // Malformed entries and credentials never match.
+  assert.equal(matchCachedDiscovery(null, 'k1', { now, graceMs }), null);
+  assert.equal(matchCachedDiscovery({}, 'k1', { now, graceMs }), null);
+  assert.equal(matchCachedDiscovery({ credential: 'k1' }, 'k1', { now, graceMs }), null);
+  assert.equal(matchCachedDiscovery({ credential: 'k1', discovered: [] }, 'k1', { now, graceMs }), null);
+});
+
+test('codex discovery requires an OAuth credential', async () => {
+  let called = 0;
+  const fetchImpl = async () => { called++; return jsonResponse({ models: [] }); };
+  const config = codexDiscoveryProviderConfig({ fetchImpl, knownModels: noKnown });
+  const refreshed = await config.refreshModels({
+    allowNetwork: true,
+    credential: { type: 'api_key', key: 'sk-not-a-subscription' },
+    signal: signal(),
+  });
+  assert.equal(refreshed, undefined);
+  assert.equal(called, 0);
+});
+
+test('parsers dedupe, skip non-model entries, and tolerate odd shapes', () => {
+  assert.deepEqual(parseAnthropicModels({ data: [
+    { type: 'model', id: 'claude-a', display_name: 'A' },
+    { type: 'model', id: 'claude-a' },
+    { type: 'other', id: 'not-a-model' },
+    { id: 'claude-b' },
+    { type: 'model' },
+    null,
+  ] }).map(m => m.id), ['claude-a', 'claude-b']);
+  const parsed = parseCodexModels({ models: [
+    { slug: 'gpt-a', display_name: 'A' },
+    { slug: 'gpt-a' },
+    { id: 'gpt-b' },
+    'gpt-c',
+    { slug: '' },
+    { slug: 'gpt-secret', visibility: 'hide' },
+  ] });
+  assert.deepEqual(parsed.models.map(m => m.id), ['gpt-a', 'gpt-b', 'gpt-c']);
+  assert.deepEqual([...parsed.hiddenIds], ['gpt-secret']);
+  assert.deepEqual(parseCodexModels({}).models, []);
+  assert.deepEqual(parseCodexModels(null).models, []);
+});
+
+test('codexThinkingLevelMap mirrors the endpoint levels; absent input stays unset', () => {
+  assert.equal(codexThinkingLevelMap(undefined), undefined);
+  assert.equal(codexThinkingLevelMap([]), undefined);
+  assert.deepEqual(codexThinkingLevelMap(['low', 'high']), {
+    off: null, minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: null,
+  });
+  assert.equal(codexThinkingLevelMap(['none']).off, 'none');
+  const definition = codexModelDefinition({ id: 'gpt-x', name: 'X', reasoningLevels: ['medium'] });
+  assert.equal(definition.thinkingLevelMap.medium, 'medium');
+  const preserved = codexModelDefinition({ id: 'gpt-y', name: 'Y' }, { thinkingLevelMap: { off: null, minimal: null, low: null, medium: null, high: 'high', xhigh: 'xhigh', max: 'max' } });
+  assert.equal(preserved.thinkingLevelMap.high, 'high');
+});
+
+test('decodeChatGptAccountId reads the claim and ignores malformed tokens', () => {
+  const token = fakeJwt({ 'https://api.openai.com/auth': { chatgpt_account_id: 'acct' } });
+  assert.equal(decodeChatGptAccountId(token), 'acct');
+  assert.equal(decodeChatGptAccountId('not-a-jwt'), null);
+  assert.equal(decodeChatGptAccountId(fakeJwt({})), null);
+});
+
+test('credentialKey stays stable per account and differs across credentials', () => {
+  assert.equal(credentialKey({ type: 'oauth', access: 'a', refresh: 'r', accountId: 'acct-1' }), 'oauth:acct-1');
+  assert.equal(credentialKey({ type: 'oauth', access: 'a', refresh: 'r' }), credentialKey({ type: 'oauth', access: 'b', refresh: 'r' }));
+  assert.notEqual(credentialKey({ type: 'api_key', key: 'k1' }), credentialKey({ type: 'api_key', key: 'k2' }));
+  assert.equal(credentialKey({ type: 'weird' }), null);
+  assert.equal(credentialKey(undefined), null);
+});
+
+test('mergeDiscoveredModels keeps upstream order, appends unseen stored entries, honors exclusions', () => {
+  const merged = mergeDiscoveredModels(
+    [{ id: 'a' }, { id: 'b' }, { id: 'hidden' }],
+    [{ id: 'b', x: 1 }, { id: 'c' }],
+    { excludeIds: new Set(['hidden']) },
+  );
+  assert.deepEqual(merged.map(m => m.id), ['b', 'c', 'a']);
+  assert.equal(merged[0].x, 1);
+});
+
+test('fileSubscriptionCache round-trips entries per provider', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'ctg-sub-cache-'));
+  const cache = fileSubscriptionCache(dir);
+  await cache.write(ANTHROPIC_PROVIDER_ID, { credential: 'k', discovered: [{ id: 'm' }], hiddenIds: [] });
+  const persisted = JSON.parse(readFileSync(cache.file, 'utf8'));
+  assert.equal(persisted[ANTHROPIC_PROVIDER_ID].discovered[0].id, 'm');
+  assert.deepEqual(await cache.read(ANTHROPIC_PROVIDER_ID), { credential: 'k', discovered: [{ id: 'm' }], hiddenIds: [] });
+  assert.equal(await cache.read(OPENAI_CODEX_PROVIDER_ID), null);
+});
+
+test('fileSubscriptionCache serializes concurrent writes across cache instances', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'ctg-sub-cache-'));
+  const anthropic = fileSubscriptionCache(dir);
+  const codex = fileSubscriptionCache(dir);
+  await Promise.all([
+    anthropic.write(ANTHROPIC_PROVIDER_ID, { credential: 'k-a', discovered: [{ id: 'claude-a' }], hiddenIds: [] }),
+    codex.write(OPENAI_CODEX_PROVIDER_ID, { credential: 'k-c', discovered: [{ id: 'gpt-a' }], hiddenIds: [] }),
+  ]);
+  const persisted = JSON.parse(readFileSync(anthropic.file, 'utf8'));
+  assert.equal(persisted[ANTHROPIC_PROVIDER_ID]?.credential, 'k-a');
+  assert.equal(persisted[OPENAI_CODEX_PROVIDER_ID]?.credential, 'k-c');
+  const anthropicEntry = await codex.read(ANTHROPIC_PROVIDER_ID);
+  const codexEntry = await anthropic.read(OPENAI_CODEX_PROVIDER_ID);
+  assert.deepEqual(anthropicEntry?.discovered, [{ id: 'claude-a' }]);
+  assert.deepEqual(codexEntry?.discovered, [{ id: 'gpt-a' }]);
+  // Later writes merge over the existing entries instead of replacing them.
+  await Promise.all([
+    anthropic.write(ANTHROPIC_PROVIDER_ID, { credential: 'k-a2', discovered: [{ id: 'claude-a2' }], hiddenIds: [] }),
+    codex.write(OPENAI_CODEX_PROVIDER_ID, { credential: 'k-c2', discovered: [{ id: 'gpt-a2' }], hiddenIds: [] }),
+  ]);
+  const merged = JSON.parse(readFileSync(anthropic.file, 'utf8'));
+  assert.equal(merged[ANTHROPIC_PROVIDER_ID]?.credential, 'k-a2');
+  assert.equal(merged[OPENAI_CODEX_PROVIDER_ID]?.credential, 'k-c2');
+});
+
+test('registerSubscriptionProviders overlays both builtin providers', () => {
+  const registrations = [];
+  registerSubscriptionProviders({ registerProvider: (id, config) => registrations.push([id, config]) });
+  assert.deepEqual(registrations.map(([id]) => id), [ANTHROPIC_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID]);
+  for (const [, config] of registrations) {
+    assert.equal(typeof config.refreshModels, 'function');
+    assert.equal(typeof config.api, 'string');
+    assert.equal(typeof config.baseUrl, 'string');
+  }
+});

package/tests/subscriptions-extension.test.mjs

@@ -0,0 +1,27 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const requireEngine = createRequire(import.meta.url);
+const { createJiti } = requireEngine('jiti');
+const jiti = createJiti(import.meta.url, {
+  alias: { '@earendil-works/pi-coding-agent': fileURLToPath(new URL('../vendor/agent/index.js', import.meta.url)) },
+});
+const factory = await jiti.import(fileURLToPath(new URL('../extensions/subscriptions.ts', import.meta.url)), { default: true });
+
+test('subscriptions extension registers both overlays and refreshes them on session_start', async () => {
+  const providers = [];
+  const hooks = {};
+  factory({
+    registerProvider(id, config) { providers.push([id, config]); },
+    on(name, callback) { hooks[name] = callback; },
+  });
+  assert.deepEqual(providers.map(([id]) => id), ['anthropic', 'openai-codex']);
+  for (const [, config] of providers) assert.equal(typeof config.refreshModels, 'function');
+
+  assert.equal(typeof hooks.session_start, 'function');
+  const calls = [];
+  await hooks.session_start({}, { modelRegistry: { refresh: options => calls.push(options) } });
+  assert.deepEqual(calls, [{ providers: ['anthropic', 'openai-codex'] }]);
+});

package/tests/terminal-title.test.mjs

@@ -0,0 +1,13 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { terminalTitleSequence } from '../lib/tui/title.mjs';
+
+test('terminal title uses Carthagent branding and the workspace folder', () => {
+  assert.equal(terminalTitleSequence('/work/my-project'), '\x1b]0;Carthagent - my-project\x07');
+  assert.equal(terminalTitleSequence('/'), '\x1b]0;Carthagent\x07');
+  assert.equal(terminalTitleSequence('/work/café app'), '\x1b]0;Carthagent - café app\x07');
+});
+
+test('terminal title strips control characters from folder names', () => {
+  assert.equal(terminalTitleSequence('/work/project\x07\x1b\n\r\x9c'), '\x1b]0;Carthagent - project\x07');
+});

package/tests/test_grade_minecraft_clone.py

@@ -0,0 +1,199 @@
+import json
+import subprocess
+import sys
+import textwrap
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+ROOT = Path(__file__).resolve().parents[1]
+GRADER = ROOT / "scenarios" / "game" / "grade_minecraft_clone.py"
+sys.path.insert(0, str(GRADER.parent))
+
+from grade_minecraft_clone import nested_ursina_callbacks, playable_frame, run
+
+
+def write_file(path, body):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(textwrap.dedent(body).lstrip())
+
+
+def write_common_files(work):
+    write_file(work / "README.md", """
+        # Minecraft demo
+
+        Run with `python minecraft.py`. Use W/A/S/D to move, mouse to look,
+        number keys to select blocks, click to break/place, P to pause, and S to save.
+    """)
+    write_file(work / "tests" / "test_game.py", """
+        import unittest
+
+        class GameTests(unittest.TestCase):
+            def test_world_math(self):
+                self.assertEqual(2 + 2, 4)
+
+        if __name__ == "__main__":
+            unittest.main()
+    """)
+
+
+def write_probe(path):
+    write_file(path, """
+        import json
+        import sys
+        from pathlib import Path
+        from PIL import Image
+
+        shot = Path(sys.argv[sys.argv.index('--screenshot') + 1])
+        shot.parent.mkdir(parents=True, exist_ok=True)
+        image = Image.new('RGB', (96, 64), (120, 180, 220))
+        for i in range(16):
+            for x in range(i * 6, i * 6 + 6):
+                for y in range(0, 64):
+                    image.putpixel((x, y), ((i * 30) % 255, (50 + i * 20) % 255, (100 + i * 10) % 255))
+        image.save(shot)
+        print('URSINA_PROBE_RESULT ' + json.dumps({'status': 'passed', 'captures': [{'sampled_colors': 16}]}))
+    """)
+
+
+def write_candidate(path, marker=True, dark=False, save_world=True):
+    marker_line = """
+    print('GAME_SMOKE_RESULT ' + json.dumps({
+        'spawn_safe': True,
+        'moved': True,
+        'jumped': True,
+        'looked': True,
+        'selected_block_changed': True,
+        'break_changed_world': True,
+        'place_changed_world': True,
+        'pause_toggled': True,
+        'save_roundtrip': True,
+        'block_type_count': 8,
+        'world_blocks_before': 40,
+        'world_blocks_after_break': 39,
+        'world_blocks_after_place': 40,
+    }))
+    """ if marker else ""
+    image_body = """
+    image = Image.new('RGB', (96, 64), (0, 0, 0))
+    """ if dark else """
+    image = Image.new('RGB', (96, 64), (120, 180, 220))
+    for i in range(16):
+        for x in range(i * 6, i * 6 + 6):
+            for y in range(0, 64):
+                image.putpixel((x, y), ((i * 30) % 255, (50 + i * 20) % 255, (100 + i * 10) % 255))
+    """
+    world = "{str((i, 0, 0)): 'stone' for i in range(40)}" if save_world else "{}"
+    body = f"""import argparse
+import json
+from pathlib import Path
+from PIL import Image
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--smoke', action='store_true')
+    parser.add_argument('--screenshot', default='artifacts/smoke.png')
+    parser.add_argument('--save', default='saves/world.json')
+    args = parser.parse_args()
+    paused = False
+    if not args.smoke:
+        print('launch minecraft game')
+        return
+    shot = Path(args.screenshot)
+    shot.parent.mkdir(parents=True, exist_ok=True)
+{textwrap.indent(textwrap.dedent(image_body).strip(), '    ')}
+    image.save(shot)
+    save = Path(args.save)
+    save.parent.mkdir(parents=True, exist_ok=True)
+    save.write_text(json.dumps({{'world': {world}, 'selected_block': 1}}))
+{textwrap.indent(textwrap.dedent(marker_line).strip(), '    ')}
+
+if __name__ == '__main__':
+    main()
+"""
+    write_file(path, body)
+
+
+class GradeMinecraftCloneTests(unittest.TestCase):
+    def run_grade(self, work):
+        probe = work / "probe.py"
+        write_probe(probe)
+        return subprocess.run(
+            [sys.executable, str(GRADER), str(work), "--probe", str(probe), "--skip-interactive"],
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            timeout=15,
+        )
+
+    def test_accepts_gameplay_smoke_protocol(self):
+        with TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            write_common_files(work)
+            write_candidate(work / "minecraft.py")
+            result = self.run_grade(work)
+            self.assertEqual(result.returncode, 0, result.stdout)
+            self.assertIn("GAME_GRADE_RESULT", result.stdout)
+
+    def test_rejects_renderer_only_smoke(self):
+        with TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            write_common_files(work)
+            write_candidate(work / "minecraft.py", marker=False)
+            result = self.run_grade(work)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("Missing GAME_SMOKE_RESULT", result.stdout)
+
+    def test_rejects_pause_overlay_as_smoke_evidence(self):
+        with TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            write_common_files(work)
+            write_candidate(work / "minecraft.py", dark=True)
+            result = self.run_grade(work)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("mostly dark", result.stdout)
+
+    def test_rejects_empty_saved_world(self):
+        with TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            write_common_files(work)
+            write_candidate(work / "minecraft.py", save_world=False)
+            result = self.run_grade(work)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("meaningful world progress", result.stdout)
+
+    def test_command_timeout_is_reported_as_a_failed_result(self):
+        with TemporaryDirectory() as tmp:
+            result = run(
+                [sys.executable, "-c", "import time; time.sleep(1)"],
+                Path(tmp),
+                timeout=0.01,
+            )
+            self.assertEqual(result.returncode, 124)
+            self.assertIn("Timed out", result.stdout)
+
+    def test_playable_frame_rejects_empty_sky(self):
+        with TemporaryDirectory() as tmp:
+            shot = Path(tmp) / "sky.png"
+            from PIL import Image
+            Image.new("RGB", (96, 64), (120, 190, 220)).save(shot)
+            self.assertFalse(playable_frame(shot))
+
+    def test_reports_nested_ursina_callbacks(self):
+        with TemporaryDirectory() as tmp:
+            entry = Path(tmp) / "minecraft.py"
+            write_file(entry, """
+                def main():
+                    def input(key):
+                        return key
+                    def update():
+                        return None
+
+                def module_helper():
+                    return None
+            """)
+            self.assertEqual(nested_ursina_callbacks(entry), ["input", "update"])
+
+
+if __name__ == "__main__":
+    unittest.main()