Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
import { randomId } from '../../random-id.ts';
import type {
CandidateModelView,
ComputeCandidateRef,
ComputeManagementChange,
ComputeSaveResult,
ModelConnectionDraft,
ModelDeclaration,
ModelConnectionDraftInput,
ModelConnectionCheckView,
RevisionSet,
} from './types';
import type { ManagedSource } from '../models/types';
export function savedSourceConnectionFields(source: ManagedSource) {
const baseUrl = (target: ManagedSource['target']) => {
const host = target.authority.includes(':') && !target.authority.startsWith('[')
? `[${target.authority}]`
: target.authority;
return `${target.scheme}://${host}:${target.port}`;
};
return {
display_template_id: source.display_template_id ?? null,
base_url: baseUrl(source.target),
request_path_override: source.target.request_path,
inventory_path_override: source.inventory_path ?? null,
protocol: source.target.upstream_protocol as ModelConnectionDraft['protocol'],
protocol_profile_id: source.target.protocol_profile_id,
protocol_profile_revision: source.target.protocol_profile_revision,
authentication: source.authentication,
additional_endpoints: (source.additional_native_endpoints ?? []).map(endpoint => ({
base_url: baseUrl(endpoint.target),
base_kind: 'api_root' as const,
request_path_override: endpoint.target.request_path,
inventory_path_override: endpoint.recheck?.inventory_path ?? null,
protocol: endpoint.target.upstream_protocol as ModelConnectionDraft['protocol'],
protocol_profile_id: endpoint.target.protocol_profile_id,
protocol_profile_revision: endpoint.target.protocol_profile_revision,
authentication: endpoint.authentication,
})),
};
}
export function buildCheckDraft(draft: ModelConnectionDraft): ModelConnectionDraftInput {
if (draft.provenance.kind !== 'user_configured') {
throw new Error('MODEL_CONNECTION_PROVENANCE_UNAVAILABLE');
}
const {
entry_kind: _entryKind,
provenance,
qualification: _qualification,
models,
...wireDraft
} = draft;
return {
...wireDraft,
configuration_revision: provenance.configuration_revision,
models: models.filter(model => model.upstream_model_id).map(({ client_id: _clientId, ...model }) => ({ ...model, display_name: model.display_name.trim() || model.upstream_model_id })),
};
}
export type CheckExpectation = {
candidateRef: string | null;
editRevision: number;
checkId: string;
};
export function checkMatches(result: ModelConnectionCheckView, expected: CheckExpectation): boolean {
const candidate = result.candidate;
const actualRef = candidate.candidate.candidate_ref;
return (expected.candidateRef === null || expected.candidateRef === actualRef)
&& candidate.correlation.candidate_ref === actualRef
&& candidate.correlation.edit_revision === expected.editRevision
&& candidate.correlation.check_id === expected.checkId
&& candidate.correlation.input_digest === result.input_digest;
}
export function saveEligibility(result: ModelConnectionCheckView | null, enable: boolean): {
allowed: boolean;
reason: 'check_required' | 'approval_required' | 'credential_required' | 'explicit_failure' | 'model_required' | null;
} {
if (!result) return { allowed: false, reason: 'check_required' };
if (result.candidate.fact_state === 'pending_approval') return { allowed: false, reason: 'approval_required' };
if (enable && result.candidate.fact_state === 'pending_credential') return { allowed: false, reason: 'credential_required' };
if (enable && (result.authentication === 'rejected' || result.inference === 'failed')) {
return { allowed: false, reason: 'explicit_failure' };
}
if (enable && !result.candidate.models.some(model => model.selectable)) {
return { allowed: false, reason: 'model_required' };
}
return { allowed: true, reason: null };
}
export function modelSaveCompleted(result: ComputeSaveResult): boolean {
return result.disposition === 'saved';
}
export function modelCanBeSelected(
result: ModelConnectionCheckView,
model: CandidateModelView,
enable: boolean,
): boolean {
return model.selectable || (
!enable
&& result.candidate.producer === 'native'
&& model.membership === 'user_declared'
&& model.reason === 'model_connections.connection_check_required'
);
}
export function defaultSelectedModelRefs(result: ModelConnectionCheckView): string[] {
return result.candidate.models
.filter(model => modelCanBeSelected(result, model, false))
.map(model => model.model_ref);
}
/** Carry explicit choices across a tool recheck, never across a connection edit. */
export function selectedModelRefsAfterRecheck(
previous: ModelConnectionCheckView | null,
selected: ReadonlySet<string>,
checked: ModelConnectionCheckView,
): Set<string> {
if (!previous
|| previous.candidate.candidate.candidate_ref !== checked.candidate.candidate.candidate_ref
|| previous.candidate.correlation.edit_revision !== checked.candidate.correlation.edit_revision) {
return new Set();
}
const identities = new Set(previous.candidate.models
.filter(model => selected.has(model.model_ref))
.map(model => model.upstream_model_id));
return new Set(checked.candidate.models
.filter(model => identities.has(model.upstream_model_id) && modelCanBeSelected(checked, model, true))
.map(model => model.model_ref));
}
export function selectedModelRefsForSave(
result: ModelConnectionCheckView,
selected: ReadonlySet<string>,
enable: boolean,
): string[] {
return result.candidate.models
.filter(model => selected.has(model.model_ref) && modelCanBeSelected(result, model, enable))
.map(model => model.model_ref);
}
export function buildSaveChange(input: {
result: ModelConnectionCheckView;
expectedRevisions: RevisionSet;
selectedModelRefs: string[];
enable: boolean;
protectedInput: ComputeCandidateRef | null;
}): ComputeManagementChange {
return {
schema: 'hiroute.compute-management-change/v2',
subject: { kind: 'candidate', candidate: input.result.candidate.candidate },
expected_revisions: input.expectedRevisions,
selected_model_refs: input.selectedModelRefs,
intent: input.enable ? 'save_ready' : 'save_disabled',
key_edits: input.protectedInput
? [{ action: 'add', input_candidate: input.protectedInput.candidate_ref === input.result.candidate.candidate.candidate_ref
? input.result.candidate.candidate : input.protectedInput }]
: [],
...(input.result.candidate.validation ? { validation: input.result.candidate.validation } : {}),
};
}
export function clientOperationId(prefix: string): string {
return `${prefix}/${randomId()}`;
}
export function clientIdempotencyKey(prefix: string): string {
const safePrefix = prefix.replace(/[^A-Za-z0-9._-]/g, '-').slice(0, 31) || 'desktop';
const entropy = Array.from(
globalThis.crypto.getRandomValues(new Uint8Array(32)),
byte => byte.toString(16).padStart(2, '0'),
).join('');
return `${safePrefix}:${entropy}`.slice(0, 64);
}
export function blankModel(upstreamModelId = '', displayName = upstreamModelId): ModelDeclaration {
return {
client_id: clientOperationId('model'),
upstream_model_id: upstreamModelId,
display_name: displayName,
catalog_configuration_id: null,
membership: 'user_declared',
capabilities: {
tool: { value: true, basis: 'user_declared' },
vision: { value: false, basis: 'user_declared' },
streaming: { value: true, basis: 'user_declared' },
context_tokens: { value: 200_000, basis: 'user_declared' },
max_output_tokens: { value: 32_768, basis: 'user_declared' },
native_reasoning: { value: { kind: 'toggle', parameter: 'enable_thinking' }, basis: 'user_declared' },
},
};
}
/** Apply editable execution defaults only where a model still has no capability fact. */
export function withCapabilityFallback(model: ModelDeclaration): ModelDeclaration {
const fallback = blankModel().capabilities;
const capabilities = { ...model.capabilities };
for (const key of Object.keys(fallback) as Array<keyof ModelDeclaration['capabilities']>) {
if (capabilities[key].value === null) {
// Each capability has a different value type; this assignment preserves the keyed shape.
Object.assign(capabilities, { [key]: fallback[key] });
}
}
if (capabilities.max_output_tokens.value! > capabilities.context_tokens.value!) {
capabilities.max_output_tokens = { value: capabilities.context_tokens.value, basis: 'user_declared' };
}
return { ...model, capabilities };
}
/** Include the full template catalog while preserving explicit model edits. */
export function withRegisteredModels(
models: ModelDeclaration[],
candidates: ReadonlyArray<Pick<ModelDeclaration, 'upstream_model_id' | 'display_name'> &
{ capability_prefill?: ModelDeclaration['capabilities'] }>,
): ModelDeclaration[] {
const ids = new Set(models.map(model => model.upstream_model_id));
return [...models, ...candidates.filter(candidate => !ids.has(candidate.upstream_model_id))
.map(candidate => candidate.capability_prefill
? { ...blankModel(candidate.upstream_model_id, candidate.display_name), capabilities: candidate.capability_prefill }
: blankModel(candidate.upstream_model_id, candidate.display_name))];
}