Skip to content

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.

9.2 KB
Raw Blame
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))];
}