language-models 0.1.0

package/.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[*.{js,json,yml}]
+charset = utf-8
+indent_style = space
+indent_size = 2

package/.gitattributes

@@ -0,0 +1,4 @@
+/.yarn/**            linguist-vendored
+/.yarn/releases/*    binary
+/.yarn/plugins/**/*  binary
+/.pnp.*              binary linguist-generated

package/.releaserc.js

@@ -0,0 +1,129 @@
+
+export default {
+  branches: [
+    {name: 'next', prerelease: 'next', channel: 'next'}
+  ],
+  repositoryUrl: 'https://github.com/drivly/ai.git',
+  tagFormat: '${name}@${version}',
+  initialVersion: '0.1.0',
+  npmPublish: true,
+  pkgRoot: '.',
+  plugins: [
+    {
+      verifyConditions: (pluginConfig, context) => {
+        console.log('Verifying conditions for semantic-release...');
+        
+        if (context.nextRelease && context.nextRelease.version) {
+          if (!context.nextRelease.version.startsWith('0.')) {
+            console.log(`Forcing version to start with 0: ${context.nextRelease.version} -> 0.${context.nextRelease.version}`);
+            context.nextRelease.version = '0.' + context.nextRelease.version;
+          }
+        }
+        
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        if (fs.existsSync(pkgPath)) {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          if (!pkg.version.startsWith('0.')) {
+            console.log(`Fixing package.json version: ${pkg.version} -> 0.1.0`);
+            pkg.version = '0.1.0';
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+          }
+        }
+      },
+      analyzeCommits: (pluginConfig, context) => {
+        if (!context.lastRelease.version) {
+          console.log('No previous version found, starting at 0.1.0-next.1');
+          return '0.1.0-next.1'; // Start new packages at 0.1.0-next.1
+        }
+        
+        console.log('Forcing patch release regardless of commit types');
+        return 'patch';
+      },
+      prepare: (pluginConfig, context) => {
+        console.log('Preparing for release...');
+        
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        if (fs.existsSync(pkgPath)) {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          let modified = false;
+          
+          const packageVersions = {};
+          for (const pkgDir of ["/home/runner/work/ai/ai/sdks/actions.do","/home/runner/work/ai/ai/sdks/agents.do","/home/runner/work/ai/ai/sdks/analytics.do","/home/runner/work/ai/ai/sdks/apis.do","/home/runner/work/ai/ai/sdks/database.do","/home/runner/work/ai/ai/sdks/evals.do","/home/runner/work/ai/ai/sdks/experiments.do","/home/runner/work/ai/ai/sdks/functions.do","/home/runner/work/ai/ai/sdks/goals.do","/home/runner/work/ai/ai/sdks/gpt.do","/home/runner/work/ai/ai/sdks/integrations.do","/home/runner/work/ai/ai/sdks/llm.do","/home/runner/work/ai/ai/sdks/mcp.do","/home/runner/work/ai/ai/sdks/models.do","/home/runner/work/ai/ai/sdks/plans.do","/home/runner/work/ai/ai/sdks/projects.do","/home/runner/work/ai/ai/sdks/sdk.do","/home/runner/work/ai/ai/sdks/searches.do","/home/runner/work/ai/ai/sdks/tasks.do","/home/runner/work/ai/ai/sdks/triggers.do","/home/runner/work/ai/ai/sdks/workflows.do","/home/runner/work/ai/ai/pkgs/ai-business","/home/runner/work/ai/ai/pkgs/ai-database","/home/runner/work/ai/ai/pkgs/ai-functions","/home/runner/work/ai/ai/pkgs/ai-models","/home/runner/work/ai/ai/pkgs/ai-providers","/home/runner/work/ai/ai/pkgs/ai-workflows","/home/runner/work/ai/ai/pkgs/apis-do-searches","/home/runner/work/ai/ai/pkgs/apis-do-zapier","/home/runner/work/ai/ai/pkgs/business-as-code","/home/runner/work/ai/ai/pkgs/clickable-apis","/home/runner/work/ai/ai/pkgs/deploy-worker","/home/runner/work/ai/ai/pkgs/durable-objects-cron","/home/runner/work/ai/ai/pkgs/durable-objects-nosql","/home/runner/work/ai/ai/pkgs/eslint-config","/home/runner/work/ai/ai/pkgs/exec-symbols","/home/runner/work/ai/ai/pkgs/language-models","/home/runner/work/ai/ai/pkgs/mdxdb","/home/runner/work/ai/ai/pkgs/mdxld","/home/runner/work/ai/ai/pkgs/motion.md","/home/runner/work/ai/ai/pkgs/payload-agent","/home/runner/work/ai/ai/pkgs/payload-commandbar","/home/runner/work/ai/ai/pkgs/payload-hooks-queue","/home/runner/work/ai/ai/pkgs/payload-theme","/home/runner/work/ai/ai/pkgs/payload-utils","/home/runner/work/ai/ai/pkgs/payload-vscode","/home/runner/work/ai/ai/pkgs/payload-workos","/home/runner/work/ai/ai/pkgs/payload-zapier-apps","/home/runner/work/ai/ai/pkgs/services-as-software","/home/runner/work/ai/ai/pkgs/simple-payload","/home/runner/work/ai/ai/pkgs/tsconfig","/home/runner/work/ai/ai/pkgs/zapier-apis-do"]) {
+            const pkgJsonPath = path.join(pkgDir, 'package.json');
+            if (fs.existsSync(pkgJsonPath)) {
+              const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+              packageVersions[pkgJson.name] = pkgJson.version || '0.1.0';
+            }
+          }
+          
+          if (pkg.dependencies) {
+            for (const [dep, version] of Object.entries(pkg.dependencies)) {
+              if (version.startsWith('workspace:')) {
+                if (packageVersions[dep]) {
+                  console.log(`Converting workspace dependency ${dep} from ${version} to ${packageVersions[dep]}`);
+                  pkg.dependencies[dep] = packageVersions[dep];
+                  modified = true;
+                }
+              }
+            }
+          }
+          
+          if (pkg.devDependencies) {
+            for (const [dep, version] of Object.entries(pkg.devDependencies)) {
+              if (version.startsWith('workspace:')) {
+                if (packageVersions[dep]) {
+                  console.log(`Converting workspace devDependency ${dep} from ${version} to ${packageVersions[dep]}`);
+                  pkg.devDependencies[dep] = packageVersions[dep];
+                  modified = true;
+                }
+              }
+            }
+          }
+          
+          if (pkg.peerDependencies) {
+            for (const [dep, version] of Object.entries(pkg.peerDependencies)) {
+              if (version.startsWith('workspace:')) {
+                if (packageVersions[dep]) {
+                  console.log(`Converting workspace peerDependency ${dep} from ${version} to ${packageVersions[dep]}`);
+                  pkg.peerDependencies[dep] = packageVersions[dep];
+                  modified = true;
+                }
+              }
+            }
+          }
+          
+          if (modified) {
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+            console.log('Updated package.json with converted workspace dependencies before publishing');
+          }
+        }
+      }
+    },
+    ['@semantic-release/commit-analyzer', {
+      preset: 'angular',
+      releaseRules: [
+        {type: 'feat', release: 'patch'},
+        {type: 'fix', release: 'patch'},
+        {type: 'docs', release: 'patch'},
+        {type: 'style', release: 'patch'},
+        {type: 'refactor', release: 'patch'},
+        {type: 'perf', release: 'patch'},
+        {type: 'test', release: 'patch'},
+        {type: 'build', release: 'patch'},
+        {type: 'ci', release: 'patch'},
+        {type: 'chore', release: 'patch'}
+      ]
+    }],
+    ['@semantic-release/release-notes-generator', {
+      writerOpts: {
+        commitLimit: 100,
+      }
+    }],
+    ['@semantic-release/npm', {
+      npmPublish: true,
+      pkgRoot: '.',
+      npmTag: 'next'
+    }],
+    '@semantic-release/github'
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Driv.ly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# ai-models
+
+Utilities and Tools for the AI SDK, Functions, Workflows, Observability, and Evals
+
+open questions:
+
+    We need to support provider/creator/model
+    Do we need or want a @ sign?
+    Do we also support a creator/model syntax without provider? I think probably
+    I think we should follow/embrace openrouter's syntax wherever possible - extending it though to add our requirements
+    Do we also have our own version of openrouter/auto, openrouter/auto:online
+        Can we tie the routing into the contents of the message and/or priority? (like performance, latency, throughput, cost, etc?)
+    How do we handle reasoning? Follow the :reasoning flag from openrouter?
+    Many new open models do not initially support tools or structured output, as that requires a lot of work by the hosting provider to make that function ... do we want a composite type tool that could use a fast/cheap model like gemini-2-flash-lite or 4o-mini to transform the output of the first model into the specified structured output?
+    How do we want to handle other capabilities/tools?
+    Should we route :online to native search models like gemini, perplexity, or the new 4o-search? or do we just follow the OpenRouter convention of injecting the Search results into the context window before calling?
+    Do we want to support more general purpose tools? (like https://agentic.so/intro)
+    How can we also support our own secure code execution tool (JS not python like Google / OAI)
+
+Clearly we will need to phase and iterate ... but we have to think very carefully because once we start using the API across multiple projects, it's going to be hard to change
+
+@{provider}/{creator}/{model}:{config,capabilities,tools,priorities}
+
+{creator}/{model}:{config,capabilities,tools,priorities}
+?model=deepseek-ai/deepseek-r1-distill-qwen-32b
+
+?model=@openai/openai/gpt-4o-search-preview
+
+?model=openai/gpt-4o:code,online
+
+@openrouter/deepseek-ai/deepseek-r1-distill-qwen-32b
+@cloudflare/deepseek-ai/deepseek-r1-distill-qwen-32b
+@google-vertex/deepseek-ai/deepseek-r1-distill-qwen-32b
+@google-ai-studio/anthropic/claude-3.7-sonnet:thinking
+@google-vertex/anthropic/claude-3.7-sonnet:thinking
+@open-router/anthropic/claude-3.7-sonnet:thinking-low,online,nitro
+
+Use Cases:
+
+    Evals - we need to easily and dynamically/programmatically change models, settings, tools, configuration, and mode
+    (for example - we need to test if something does better with or without reasoning ... and within reasoning, we need low, medium, and high models ... We also in some cases must force structured outputs to be structured outputs, because if tool use is required, say by an anthropic model, that supports structured outputs via tools, then that is incompatible ... but also, there are essentially 4 different ways to get Objects that match a certain schema:
+        structured_output: the best by far, but very limited support ... I think only 3 providers support this today
+        tool_use: There is support for many more providers with tool use, but only a subset actually enforces guaranteed schema ... but also has limitations on number of tools and forced tool to use
+        response_format: Supported on a majority of providers and models - but not universal - this guarantees valid JSON responses, but not any guarantee about the schema. This JSON mode can also be used without a schema to just force the model to respond in a structured data form vs normal text/markdown
+        system prompt: If the model/provider does not support any of the first 3, then you can just ask nicely ... but depending on the model, this will fail 10-50% of the time
+    Experimentation - Humans or LLM-as-Judge can pick the preferred response from 2 or more models (ie. compare 4o, o2, 3.7, 3.7:reasoning, flash 2, flash 2.0 reasoning
+    Specify best model - no cost/price requirements ... 4.5, o1-high, o3-mini-high, r1, 3.7, 3.7:reasoning-high, Flash 2 Pro, Flash 2 Reasoning
+    Specify only reasoning:
+    at runtime, be able to tweak provider/model/settings/tools via a simple query param for example ... ?model=*:reasoning+code would route that to any and all models with reasoning and a code execution tool ... currently adding tool, changing config, etc requires code changes ... we need all of these variables to be tweaked/edited/stored/evaluated at runtime without code changes
+    also we need to opt in/out of caching (and maybe even logging req/res bodies in sensitive PII situations)
+    also probably seed ...
+
+## Usage
+
+Examples:
+
+```ts
+// The name of the exported function should be changed, I just wanted to get the ball rolling
+import { getSupportedModel } from '@drivly/ai-utils'
+
+const model = getSupportedModel('@openai/openai/gpt-4o:code,online')
+const model = getSupportedModel('@anthropic/anthropic/claude-3.7-sonnet:thinking,code,online')
+const model = getSupportedModel([
+  // Fallback support if a certain model is down / doesnt have the full capabilities supported
+  req.args.model, // Attempt to use the model from the request, otherwise fallback to the next one
+  '@openai/openai/gpt-4o:code,online,thinking',
+  '@anthropic/anthropic/claude-3.7-sonnet:thinking,code,online',
+])
+```
+
+# Meta-model Manager
+
+To support complex busines requirements, we need a system that can automatically determine the best model for each task.
+
+### Classification of content
+
+A classification layer will be used to attach weights based on the prompt. The weights indicate the relative importance of each type of content in the prompt:
+
+`'Generate a business plan to sell water to a fish.'` -> `[ 'businessLogic:0.5', 'marketing:0.4', 'legal:0.21' ]`
+
+Each model in our system will maintain a unique set of performance weights, calculated from multiple feedback sources including the Arena as well as direct user-provided Eval Feedback. The classification layer's primary responsibility is to identify and tag content types within prompts.
+
+When users indicate their satisfaction with a model's response through positive feedback (such as giving a `👍`), our system automatically increases that model's score for the identified content tags. This scoring mechanism creates a self-improving selection algorithm that learns which models excel at specific content types over time, leading to increasingly accurate model selection for future similar prompts without requiring manual intervention.
+
+The key difference between this and systems such as NotDiamond is that we can offer multiple meta-models, each with their own focuses and strengths. Another benefit that we offer is that our weights are changing daily as we receive more feedback.
+
+### Ideas and thoughts
+
+- One idea could be to slowly remove weights over time, marking models with less usage as less important. This would allow for newer models to quickly bubble up to the top without needing a vast evaluation dataset. For example, if Gemini 3 releases and people start using it more, the weights for Gemini 2 will slowly decrease, making it less and less likely to be chosen as we can more confident in the newer model.
+- Tags could be generated from the prompt, making it fully dynamic. Works best if we force the classification model to try its best to match an existing tag, but create a new one if it cant.
+- Version pinning.
+
+### Examples
+
+#### Meta model: frontier()
+
+#### Prompt: Generate a business plan to sell water to a fish.
+
+#### Weights: `[ 'businessLogic:0.75', 'marketing:0.4', 'legal:0.21' ]`
+
+#### Models
+
+Using the above information, we can now sort our models using the weights to find the best model within a certain "meta-model". In this example, we're using the `frontier-reasoning` group of models that are best at reasoning and logic.
+
+Thanks to our classification layer, its extremely easy to route the prompt to `claude-3.7-sonnet`, which best matches the `businessLogic` tag (among others).
+
+## Sequence diagram
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Classification as Classification Layer
+    participant MetaManager as Meta-model Manager
+    participant ModelRegistry as Model Registry
+    participant SelectedModel as Selected Model
+    participant Feedback as Feedback System
+
+    User->>Classification: Send prompt "Generate business plan for fish water"
+    Note over Classification: Analyzes content types in prompt
+    Classification->>MetaManager: Provides weights [businessLogic:0.75, marketing:0.4, legal:0.21]
+
+    MetaManager->>ModelRegistry: Request models matching meta-model type (e.g., "frontier-reasoning")
+    ModelRegistry->>MetaManager: Return candidate models with performance weights
+
+    Note over MetaManager: Ranks models based on content weights<br/>and historical performance
+    MetaManager->>SelectedModel: Route prompt to best model (e.g., claude-3.7-sonnet)
+    SelectedModel->>User: Return response
+
+    User->>Feedback: Provides feedback (👍)
+    Feedback->>ModelRegistry: Update model scores for identified content tags
+    Note over ModelRegistry: Increases claude-3.7-sonnet's<br/>score for businessLogic tag
+
+    Note over MetaManager: Future similar prompts more likely<br/>to select same high-performing model
+```
+
+`*:reasoning(sort:pricing,latency)`
+
+## Examples
+
+- Best PDF model thats the cheapest (gemini-2.0-flash) -> `*:pdf(sort:pricing)`
+- PDF with reasoning (claude-3.7-sonnet) -> `*:pdf,reasoning`
+- Creative writing (gpt-4.5) -> `creative`
+- Extremely complex code debugging (o1-pro)
+- Cheap blog post writer (gemini-2.0-flash)
+- Better blog post writer (gpt-4o || claude-3.7-sonnet)
+- Best blog post writer (gpt-4.5)
+- Deal review (o3-mini || claude-3.7-sonnet || gemini-2.5-pro)
+
+#### Example business requirements
+
+```
+Requirements: Must be good at creative writing, but cost less than $15 per million tokens
+Constraints: Must be able to handle complex code
+```
+
+We need to transform the above business requirements into a meta-model:
+
+```
+[
+    "gemini-2.0-flash",
+    ...
+]
+```
+
+From the list, we can then sort by pricing, latency, and other constraints at completion time depending on the users goals.

package/dist/aliases.d.ts

@@ -0,0 +1 @@
+export declare const aliases: Record<string, string>;

package/dist/aliases.js

@@ -0,0 +1,5 @@
+export const aliases = {
+    gemini: 'google/gemini-2.0-flash-001',
+    'claude-3.7-sonnet': 'anthropic/claude-3.7-sonnet',
+    r1: 'deepseek/deepseek-r1',
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './parser';
+export * from './aliases';
+export * from './providers';
+import type { Model } from './types';
+export * from './types';
+export declare const models: Model[];
+export declare const modelPattern: RegExp;

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './parser';
+export * from './aliases';
+export * from './providers';
+import allModels from './models';
+export * from './types';
+export const models = allModels.models;
+export const modelPattern = /^(?:[\w-]+\/)?[\w\.-]+(?:@[\w-]+(?::[\w-]+)?)?(?<!@)\([^()]*(?:\([^()]*\)[^()]*)*\)$/;

package/dist/models.d.ts

@@ -0,0 +1,170 @@
+// --- Reusable Base Interfaces ---
+
+interface Icon {
+  url: string
+  invertRequired?: boolean
+}
+
+interface DataPolicy {
+  termsOfServiceUrl?: string // Optional based on examples
+  privacyPolicyUrl?: string // Optional based on examples
+  training: boolean
+  loggingRetentionDays?: number // Optional based on examples
+  requiresUserIds?: boolean // Optional based on examples
+}
+
+// Base pricing structure, allowing for optional cache fields
+interface Pricing {
+  prompt: string
+  completion: string
+  image: string
+  request: string
+  webSearch: string
+  internalReasoning: string
+  discount: number
+  inputCacheRead?: string // Optional based on examples
+  inputCacheWrite?: string // Optional based on examples
+}
+
+interface ReasoningConfig {
+  startToken: string
+  endToken: string
+}
+
+interface Sorting {
+  topWeekly: number
+  newest: number
+  throughputHighToLow: number
+  latencyLowToHigh: number
+  pricingLowToHigh: number
+  pricingHighToLow: number
+}
+
+interface ProviderInfo {
+  name: string
+  displayName: string
+  baseUrl: string
+  dataPolicy: DataPolicy
+  headquarters?: string // Optional based on examples
+  hasChatCompletions: boolean
+  hasCompletions: boolean
+  isAbortable: boolean
+  moderationRequired: boolean
+  group: string
+  editors: never[] // Assuming these are always empty based on examples
+  owners: never[] // Assuming these are always empty based on examples
+  isMultipartSupported: boolean
+  statusPageUrl: string | null
+  byokEnabled: boolean
+  isPrimaryProvider: boolean
+  icon: Icon
+}
+
+// Represents an entry in the 'providers' array within a Model
+interface ModelProvider {
+  name: string
+  slug: string
+  quantization: string | null
+  context: number
+  maxCompletionTokens: number | null // Can be null in examples
+  pricing: Pricing // Use the common Pricing type
+  supportedParameters: string[]
+  inputCost: number
+  outputCost: number
+  throughput?: number // Optional based on examples
+  latency?: number // Optional based on examples
+}
+
+// Represents the nested 'features.supportedParameters' object
+interface SupportedParametersFeatures {
+  responseFormat?: boolean
+  structuredOutputs?: boolean
+}
+
+// Base Model structure (common fields without nested endpoint/providers)
+// This helps avoid circular type definitions initially
+interface ModelBase {
+  slug: string
+  hfSlug: string | null
+  updatedAt: string
+  createdAt: string
+  hfUpdatedAt: string | null // Assuming string like others, though only null seen
+  name: string
+  shortName: string
+  author: string
+  description: string
+  modelVersionGroupId: string | null
+  contextLength: number
+  inputModalities: string[]
+  outputModalities: string[]
+  hasTextOutput: boolean
+  group: string
+  instructType: string | null
+  defaultSystem: string | null // Assuming string, though only null seen
+  defaultStops: string[] // Use string[] as it can contain values
+  hidden: boolean
+  router: string | null // Assuming string, though only null seen
+  warningMessage: string | null
+  permaslug: string
+  reasoningConfig: ReasoningConfig | null
+}
+
+// Define Endpoint structure, referencing ModelBase for its 'model' property
+interface Endpoint {
+  id: string
+  name: string
+  contextLength: number
+  model: ModelBase // Reference the base model structure
+  modelVariantSlug: string
+  modelVariantPermaslug: string
+  providerName: string
+  providerInfo: ProviderInfo
+  providerDisplayName: string
+  providerModelId: string
+  providerGroup: string
+  isCloaked: boolean
+  quantization: string | null
+  variant: string
+  isSelfHosted: boolean
+  canAbort: boolean
+  maxPromptTokens: number | null
+  maxCompletionTokens: number | null // Endpoint might have different limits
+  maxPromptImages: number | null
+  maxTokensPerImage: number | null
+  supportedParameters: string[]
+  isByok: boolean
+  moderationRequired: boolean
+  dataPolicy: DataPolicy // Data policy specific to the endpoint variant
+  pricing: Pricing // Pricing specific to the endpoint variant
+  isHidden: boolean
+  isDeranked: boolean
+  isDisabled: boolean
+  supportsToolParameters: boolean
+  supportsReasoning: boolean
+  supportsMultipart: boolean
+  limitRpm: number | null
+  limitRpd: number | null
+  hasCompletions: boolean
+  hasChatCompletions: boolean
+  features: {
+    supportedParameters?: SupportedParametersFeatures
+  }
+  providerRegion: string | null // Assuming string, though only null seen
+}
+
+// --- Final Composed Model Interface ---
+
+// Extend ModelBase and add the nested structures
+interface Model extends ModelBase {
+  endpoint: Endpoint | null // Endpoint can be null
+  sorting: Sorting
+  providers: ModelProvider[] // Array can be empty
+}
+
+// --- The Default Export ---
+
+declare const _default: {
+  models: Model[]
+}
+
+export default _default