// Mos1961: existing provider identities are translated only with supplied proxy context.
import test from 'node:test';
import assert from 'node:assert/strict';
import { sessionModel } from '../src/bundle.mjs';
const resolved = { instance: 'fixture', vars: { harness: 'pi', model: 'selected', thinking: 'low' } };
for (const [provider, model, expected] of [
  ['anthropic', 'glm-looking-id', 'anthropic'],
  ['zai', 'gpt-looking-id', 'glm'],
]) {
  test(`joined proxy context maps provider ${provider} by identity, not model name`, () => {
    const selected = sessionModel(resolved, { selected: { provider, model } }, 'primary', { proxy: true });
    assert.equal(selected.proxyRoute, expected);
    assert.equal(selected.provider, provider, 'public/accounting provider identity is retained');
    assert.equal(selected.model, model);
  });
}
test('no proxy context preserves an arbitrary nonproxy provider and original route shape', () => {
  assert.deepEqual(sessionModel(resolved, { selected: { provider: 'custom-provider', model: 'fixture-id' } }), {
    harness: 'pi', provider: 'custom-provider', model: 'fixture-id', modelKey: 'selected', thinking: 'low',
  });
});
test('joined proxy context refuses unsupported provider rather than using an upstream credential or guessed API', () => {
  assert.throws(() => sessionModel(resolved, { selected: { provider: 'custom-provider', model: 'claude-looking-id' } }, 'primary', { proxy: true }), {
    code: 'proxy-provider-unsupported',
  });
});
test('provider proxy still requires an explicit route inside joined context', () => {
  assert.throws(() => sessionModel(resolved, { selected: { provider: 'proxy', model: 'claude-looking-id' } }, 'primary', { proxy: true }), {
    code: 'proxy-route-missing',
  });
  assert.throws(() => sessionModel(resolved, { selected: { provider: 'proxy', model: 'fixture', route: 'custom' } }, 'primary', { proxy: true }), {
    code: 'proxy-route-unknown',
  });
  assert.equal(sessionModel(resolved, { selected: { provider: 'proxy', model: 'claude-looking-id', route: 'codex' } }, 'primary', { proxy: true }).proxyRoute, 'codex');
});
test('a module-backed selection carries the provider transport descriptor without changing accounting', () => {
  const selected = sessionModel(resolved, { selected: { provider: 'codex', model: 'fixture-codex', module: 'cliproxy', upstream: 'codex' } }, 'primary', { proxy: true });
  assert.equal(selected.provider, 'codex');
  assert.equal(selected.proxyTransport.api, 'openai-responses');
  assert.equal(selected.proxyTransport.piProvider, 'mosaic-proxy-codex');
});

test('module transport accepts bounded declarative compatibility for another protocol variant', () => {
 const entry={provider:'fixture',model:'fixture-id',module:'fixture',upstream:'fixture'};
 const resolver=()=>({provider:'fixture',model:'fixture-id',upstream:'fixture',routeId:'fixture',endpoint:'v1',api:'openai-completions',piProvider:'fixture',compat:{thinkingFormat:'openai',zaiToolStream:false}});
 const selected=sessionModel(resolved,{selected:entry},'primary',{proxy:true,resolver});
 assert.deepEqual(selected.proxyTransport.compat,{thinkingFormat:'openai',zaiToolStream:false});
});

test('transport accepts bounded compatibility flags declared by a provider module', () => {
 const entry={provider:'fixture',model:'fixture-id'};
 const resolver=()=>({provider:'fixture',model:'fixture-id',routeId:'fixture',endpoint:'v1',api:'openai-completions',piProvider:'fixture',compat:{supportsStore:false,thinkingFormat:'openai'}});
 assert.deepEqual(sessionModel(resolved,{selected:entry},'primary',{proxy:true,resolver}).proxyTransport.compat,{supportsStore:false,thinkingFormat:'openai'});
});