feat: normalize OmniRoute model metadata and deduplicate alias entries

[Alph4d0g]

Summary

This PR addresses the review feedback from #18 by implementing comprehensive model metadata normalization and deduplication:

Changes

1. Extended Types (src/types.ts)

   • Added snake_case fields (context_length, max_input_tokens, max_output_tokens) to OmniRouteModel
   • Added capabilities object with vision, tool_calling, reasoning, thinking, attachment, temperature fields
   • Added top-level snake_case capability fields (vision, tool_calling) for direct API mapping

2. Comprehensive Normalization (src/models.ts)

   • Extracted inline normalization into standalone normalizeModel() function
   • Reads all field variants with proper precedence: camelCase > snake_case > capabilities object
   • Handles context limits, streaming, vision, tools, reasoning, attachment, and temperature

3. Provider Alias Mapping (src/constants.ts)

   • Added PROVIDER_ALIAS_TO_CANONICAL mapping for known aliases:
     • ollamacloud → ollama-cloud
     • cc → claude
     • gh → github
     • cx → codex
     • kr → kiro
     • if → qoder

4. Smart Deduplication (src/models.ts)

   • Added deduplicateModels() that groups by canonical provider+model key
   • Only deduplicates known aliases; preserves unknown provider prefixes to avoid breaking user metadata
   • Prefers canonical metadata when both alias and canonical exist
   • Normalizes alias IDs to canonical form even when canonical is missing

5. Metadata Key Canonicalization (src/plugin.ts)

   • Added resolveProviderAliasForMetadata() to canonicalize model IDs for metadata lookups
   • Added isProviderAlias() helper
   • User metadata with alias keys (e.g., cx/gpt-5.5) is merged into canonical keys (e.g., codex/gpt-5.5)
   • Generated metadata uses canonical keys to match deduplicated model IDs

6. Test Coverage (test/models.test.mjs)

   • normalizeModel reads snake_case fields - verifies capabilities object and snake_case field reading
   • normalizeModel prefers camelCase over snake_case - verifies precedence rules
   • deduplication removes alias when canonical exists - verifies canonical preference
   • deduplication keeps alias when canonical is missing - verifies alias normalization

Test Results

All 42 tests passing:

• 38 existing tests (no regressions)
• 4 new tests for normalization and deduplication

Design Decisions

• Precedence: camelCase > snake_case > capabilities object (consistent with existing code)
• Selective Deduplication: Only known aliases are deduplicated to preserve user metadata for unknown providers
• Metadata Key Canonicalization: User metadata keys are canonicalized to match deduplicated model IDs
• Timing: Normalization and deduplication happen before models.dev enrichment

Backward Compatibility

• All existing tests pass without modification (except updating expectations for canonical IDs)
• Unknown provider prefixes are preserved as-is
• User metadata with alias keys continues to work (merged into canonical keys)

[Alph4d0g]

Implementation Complete

This PR implements the comprehensive normalization + deduplication plan discussed in #18.

Key Implementation Details

Normalization Precedence:

camelCase fields > snake_case fields > capabilities object

Example: If API returns both contextWindow: 64000 and context_length: 32000, we use 64000.

Deduplication Logic:

• Only deduplicates known aliases from PROVIDER_ALIAS_TO_CANONICAL
• Unknown provider prefixes are kept as-is to preserve user metadata
• When both alias and canonical exist: keeps canonical, drops alias
• When only alias exists: normalizes ID to canonical form

Metadata Handling:

• User metadata keys with aliases (e.g., cx/gpt-5.5) are merged into canonical keys (e.g., codex/gpt-5.5)
• Generated metadata from fetched models uses canonical keys
• This ensures metadata lookups work correctly after deduplication

Verification

npm test
# 42 tests passing (38 existing + 4 new)

npm run build
# TypeScript compilation: clean

npx tsc --noEmit
# Type checking: no errors

Files Changed

• src/types.ts - Extended OmniRouteModel interface
• src/models.ts - Added normalizeModel(), deduplicateModels(), resolveProviderAliasForMetadata(), isProviderAlias()
• src/constants.ts - Added PROVIDER_ALIAS_TO_CANONICAL mapping
• src/plugin.ts - Updated metadata generation to use canonical keys
• test/models.test.mjs - Added 4 new test cases
• test/plugin.test.mjs - Updated expectations for canonical IDs

Ready for review!

[gemini-code-assist]

Code Review

This pull request introduces a wide range of improvements to the OmniRoute plugin, including a shift to asynchronous logging, enhanced model normalization, and a deduplication system for provider aliases. It expands the model metadata schema to support temperature, reasoning, and attachments, and implements a mechanism for handling model variants like reasoning effort. Review feedback points out critical issues in the implementation of metadata merging and deduplication: specifically, the need for proper precedence and validation in array-based metadata configurations, and the risk of data loss or unreachable logic when merging canonical model entries with their aliases.

[gemini-code-assist]

There are two issues here:

1. Precedence: In most OpenCode matching systems, the first matching block in the modelMetadata array wins. By prepending generatedBlocks, user-defined overrides in userConfig will be ignored for any model already present in the generated metadata. userConfig should be placed first.
2. Validation: Unlike the object-based merge logic below, the array-based merge does not validate the user-provided metadata blocks. Invalid metadata should be filtered out to prevent issues in the OpenCode framework.

  if (Array.isArray(userConfig)) {
    const validUserConfig = userConfig.filter((block) => {
      const validation = isValidModelMetadata(block);
      if (!validation.valid) {
        warn(`Invalid metadata block for match "${sanitizeForLog(String(block.match))}" (field: ${sanitizeForLog(validation.field ?? '')}), skipping`);
        return false;
      }
      return true;
    });

    const generatedBlocks = Object.entries(generated).map(([id, metadata]) => ({
      match: id,
      ...metadata,
    }));

    // User config should come first to take precedence in first-match-wins systems
    return [...validUserConfig, ...generatedBlocks];
  }

[gemini-code-assist]

When a canonical model entry is encountered, it currently overwrites any existing entry in the seen map. If an alias entry for the same model was processed first, any metadata unique to that alias entry will be lost. It is better to merge the metadata while ensuring the canonical entry's fields take precedence.

Suggested change

	if (!canonicalPrefix) {
	seen.set(model.id, model);
	continue;
	}
	if (!canonicalPrefix) {
	const existing = seen.get(model.id);
	seen.set(model.id, existing ? { ...existing, ...model } : model);
	continue;
	}

[gemini-code-assist]

The current deduplication logic for aliases has two issues: it contains dead code (the if (!isAlias) block is unreachable because canonicalPrefix is only defined for aliases) and it fails to merge metadata from the alias into an existing canonical entry. Merging metadata ensures that fields present in the alias but missing in the canonical entry are preserved.

    const existing = seen.get(canonicalId);
    if (!existing) {
      seen.set(canonicalId, { ...model, id: canonicalId });
    } else {
      // Current model is an alias, merge into existing preferring existing fields
      // (which might be the canonical entry or a previously seen alias)
      seen.set(canonicalId, { ...model, ...existing, id: canonicalId });
    }