language-models 0.1.0 → 0.2.0

package/.releaserc.js

@@ -1,129 +0,0 @@
-
-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

@@ -1,21 +0,0 @@
-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/dist/parser.d.ts

@@ -1,86 +0,0 @@
-import { Model, Provider } from './types';
-type InternalModel = Model;
-type ParsedModelIdentifier = {
-    provider?: string;
-    author?: string;
-    model?: string;
-    systemConfig?: Record<string, string | number>;
-    alias?: string;
-    priorities?: string[];
-    providerConstraints?: {
-        field: string;
-        value: string;
-        type: 'gt' | 'lt' | 'eq';
-    }[];
-    tools?: Record<string, string | number | boolean | Record<string, unknown>>;
-    capabilities?: Record<string, string | number | boolean>;
-    outputFormat?: string;
-    outputSchema?: string;
-    unasignedParameters?: Record<string, string | number | boolean>;
-};
-export declare function parse(modelIdentifier: string): ParsedModelIdentifier;
-export declare function constructModelIdentifier(parsed: ParsedModelIdentifier): string;
-export declare function modelToIdentifier(model: Model): string;
-type ResolvedModel = Model & {
-    provider: Provider;
-};
-export declare function filterModels(modelIdentifier: string, modelsToFilter?: InternalModel[]): {
-    models: ResolvedModel[];
-    parsed: ParsedModelIdentifier;
-};
-/**
- * Helper function to get the first model that matches a model identifier
- * @param modelIdentifier
- * @returns ResolvedModel
- */
-export declare function getModel(modelIdentifier: string, augments?: Record<string, string | number | boolean | string[]>): {
-    parsed: {
-        provider?: string;
-        author?: string;
-        model?: string;
-        systemConfig?: Record<string, string | number>;
-        alias?: string;
-        priorities?: string[];
-        providerConstraints?: {
-            field: string;
-            value: string;
-            type: "gt" | "lt" | "eq";
-        }[];
-        tools?: Record<string, string | number | boolean | Record<string, unknown>>;
-        capabilities?: Record<string, string | number | boolean>;
-        outputFormat?: string;
-        outputSchema?: string;
-        unasignedParameters?: Record<string, string | number | boolean>;
-    };
-    slug: string;
-    hfSlug?: string | null;
-    updatedAt: string;
-    createdAt: string;
-    hfUpdatedAt: null;
-    name: string;
-    shortName: string;
-    author: string;
-    description: string;
-    modelVersionGroupId: string;
-    contextLength: number;
-    inputModalities: string[];
-    outputModalities: string[];
-    hasTextOutput: boolean;
-    group: string;
-    instructType: null;
-    defaultSystem: null;
-    defaultStops: any[];
-    hidden: boolean;
-    router: null;
-    warningMessage: null;
-    permaslug: string;
-    reasoningConfig: null;
-    endpoint?: import("./types").Endpoint | Provider;
-    sorting?: import("./types").Sorting;
-    providers?: Provider[];
-    provider: Provider;
-};
-export declare function getModels(modelIdentifier: string): (Model & {
-    parsed: ParsedModelIdentifier;
-})[];
-export {};

package/dist/parser.js

@@ -1,390 +0,0 @@
-import camelCase from 'camelcase';
-import { aliases } from './aliases';
-import rawModels from './models';
-const allModels = rawModels;
-// Priorities may be on its own, which indicates to just find the best value for that priority
-// or it may be in one of the following formats:
-// cost:<1 -> A model that has a cost of less than $1 per million tokens
-// latency:<50 -> A model with a latency of less than 50ms
-// throughput:>250 -> A model with a throughput higher than 250 tokens per second
-// Additional notes: if just cost is specified, then it will be treated as outputCost
-const priorities = ['cost', 'latency', 'throughput', 'inputCost', 'outputCost'];
-const capabilities = ['reasoning', 'thinking', 'tools', 'structuredOutput', 'responseFormat', 'pdf'];
-const defaultTools = ['exec', 'online'];
-const systemConfiguration = ['seed', 'thread', 'temperature', 'topP', 'topK'];
-// Any of the following is an output format, anything else that starts with a capital letter is an output *schema*
-const outputFormats = ['Object', 'ObjectArray', 'Text', 'TextArray', 'Markdown', 'Code'];
-export function parse(modelIdentifier) {
-    const output = {
-        model: '',
-    };
-    // Locate all paratheses, even nested ones
-    const parentheses = modelIdentifier.match(/\(([^)]+)\)/g);
-    output.model = modelIdentifier.split('(')[0];
-    const modelName = output.model.includes('/') ? output.model.split('/')[1] : output.model;
-    if (aliases[modelName]) {
-        output.model = aliases[modelName];
-    }
-    if (output.model.includes('/')) {
-        const [author, model] = output.model.split('/');
-        output.author = author;
-        output.model = model;
-    }
-    if (output.model.includes('@')) {
-        // @ indicates a specific provider
-        const [model, provider] = output.model.split('@');
-        output.model = model;
-        output.provider = provider;
-    }
-    // If there are no parentheses, then we can just return the model identifier
-    if (!parentheses) {
-        return output;
-    }
-    // Defaults storage allows us to set defaults for settings if they are missing from the input
-    // The main use case is for output formats, where we want to set the format based on the schema
-    // but only if the format isnt already set. Since we only have access to a single expression at once,
-    // we need to store the defaults and apply them later.
-    const defaultStorage = {};
-    // Split by comma, each part is a new parameter that needs to be stored in the right
-    // place in the output object
-    // For each parathesis, we need to parse the contents
-    for (const parenthesis of parentheses) {
-        const contents = parenthesis.slice(1, -1);
-        const parts = contents.split(',');
-        for (const part of parts) {
-            // Not all parts will have a colon, if not, treat it as a boolean with a value of true.
-            const [key, value] = part
-                // Cheat we can do to make the parsing easier
-                .replace('<', ':<')
-                .replace('>', ':>')
-                .split(':');
-            if (!key) {
-                continue;
-            }
-            let notAKnownParameter = false;
-            switch (true) {
-                case defaultTools.includes(key):
-                    output.tools = output.tools || {};
-                    output.tools[key] = value || true;
-                    break;
-                case systemConfiguration.includes(key):
-                    output.systemConfig = {
-                        ...output.systemConfig,
-                        [key]: value,
-                    };
-                    break;
-                case priorities.includes(key):
-                    if (value) {
-                        output.providerConstraints = output.providerConstraints || [];
-                        output.providerConstraints.push({
-                            field: key,
-                            value: value.replace('>', '').replace('<', ''),
-                            type: value.startsWith('>') ? 'gt' : value.startsWith('<') ? 'lt' : 'eq',
-                        });
-                    }
-                    else {
-                        output.priorities = [...(output.priorities || []), key];
-                    }
-                    break;
-                case capabilities.includes(key):
-                    output.capabilities = {
-                        ...output.capabilities,
-                        [key]: value || true,
-                    };
-                    break;
-                case outputFormats.includes(key):
-                    output.outputFormat = key == 'Code' && !!value ? `Code:${value}` : key;
-                    break;
-                default:
-                    notAKnownParameter = true;
-                    break;
-            }
-            if (!notAKnownParameter) {
-                // No need to process any further
-                continue;
-            }
-            // If it starts with a capital letter, then it is a Schema
-            if (key[0] === key[0].toUpperCase()) {
-                const schema = key;
-                if (schema.includes('[]')) {
-                    defaultStorage.outputFormat = 'ObjectArray';
-                }
-                else {
-                    defaultStorage.outputFormat = 'Object';
-                }
-                output.outputSchema = schema.replace('[]', '');
-            }
-            else if (value?.includes('>') || value?.includes('<')) {
-                // This is most likely a benchmark constraint
-                output.providerConstraints = output.providerConstraints || [];
-                output.providerConstraints.push({
-                    field: key,
-                    value: value.replace('>', '').replace('<', ''),
-                    type: value.startsWith('>') ? 'gt' : 'lt',
-                });
-            }
-            else {
-                output.tools = output.tools || {};
-                output.tools = {
-                    ...output.tools,
-                    [key]: value || true,
-                };
-            }
-        }
-    }
-    // Custom rules / requirements
-    // If someone has tools, they need to have the tools capability
-    if (Object.values(output.tools || {}).length > 0) {
-        if (!output.capabilities?.tools) {
-            output.capabilities = {
-                ...output.capabilities,
-                tools: true,
-            };
-        }
-    }
-    // Finally, apply the defaults
-    Object.entries(defaultStorage).forEach(([key, value]) => {
-        const keyToCheck = key;
-        if (output[keyToCheck] === undefined) {
-            // @ts-expect-error - We know these assignments are safe based on our defaultStorage logic
-            output[keyToCheck] = value;
-        }
-    });
-    return output;
-}
-export function constructModelIdentifier(parsed) {
-    const modelAlias = aliases[parsed.model || ''] || parsed.model || '';
-    let identifier = `${modelAlias}`;
-    if (parsed.provider) {
-        identifier += `@${parsed.provider}`;
-    }
-    const args = [];
-    const formatArgument = (key, value) => {
-        // If the value is a boolean, then we can just return the key
-        if (typeof value === 'boolean') {
-            return value ? key : '';
-        }
-        console.log(key, value);
-        // Otherwise, we need to format the value
-        return `${key}:${value}`;
-    };
-    const keysToFormat = ['capabilities', 'tools', 'systemConfig'];
-    keysToFormat.forEach((key) => {
-        if (parsed[key]) {
-            Object.entries(parsed[key]).forEach(([key, value]) => {
-                args.push(formatArgument(key, value));
-            });
-        }
-    });
-    if (parsed.priorities) {
-        parsed.priorities.forEach((priority) => {
-            args.push(priority);
-        });
-    }
-    // Provider constraints are a bit more complex as they are stored as { field: string, value: string }[]
-    if (parsed.providerConstraints) {
-        parsed.providerConstraints.forEach((constraint) => {
-            args.push(`${constraint.field}${constraint.type === 'gt' ? '>' : constraint.type === 'lt' ? '<' : ':'}${constraint.value}`);
-        });
-    }
-    if (args.length) {
-        identifier += `(${args.join(',')})`;
-    }
-    return identifier;
-}
-export function modelToIdentifier(model) {
-    return constructModelIdentifier({
-        model: model.slug.split('/')[1],
-        provider: model.slug.split('/')[0],
-    });
-}
-export function filterModels(modelIdentifier, modelsToFilter) {
-    const parsed = parse(modelIdentifier);
-    const modelAndProviders = [];
-    let modelsToFilterMixin = modelsToFilter;
-    if (metaModels.find((m) => m.name === parsed.model) && !modelsToFilter?.length) {
-        const metaModelChildren = metaModels.find((m) => m.name === parsed.model)?.models;
-        modelsToFilterMixin = allModels.models.filter((m) => metaModelChildren?.includes(m.slug.split('/')[1]));
-        // Because the parser has no model knowledge, it thinks the meta model name is the model name
-        // Which will always return false.
-        delete parsed.model;
-    }
-    else if (modelsToFilter?.length) {
-        modelsToFilterMixin = modelsToFilter;
-    }
-    else {
-        modelsToFilterMixin = allModels.models;
-    }
-    const filterChain = [];
-    if (parsed.model) {
-        filterChain.push(function modelFilter(model) {
-            // Wildcard search for any model that matches everything else.
-            if (parsed.model == '*') {
-                return true;
-            }
-            // Return true if we're looking for claude-3.7-sonnet
-            // Fixes the issue where we need :thinking to be supported
-            if (parsed.model === 'claude-3.7-sonnet' && model.slug.includes('claude-3.7-sonnet') && !model.slug.includes('beta')) {
-                return true;
-            }
-            return model.slug.split('/')[1] === parsed.model;
-        });
-    }
-    // We're using named functions here so we can console.log the filter chain
-    // and see what filter is being applied and when
-    if (parsed.provider) {
-        filterChain.push(function providerFilter(model, provider) {
-            return provider?.slug === parsed.provider;
-        });
-    }
-    if (parsed?.providerConstraints?.length) {
-        // Since the provider isnt defined, we need to filter based on the provider constraints
-        filterChain.push(function providerConstraintFilter(model, provider) {
-            return (parsed?.providerConstraints?.every((constraint) => {
-                if (!provider) {
-                    return false;
-                }
-                let fieldToCheck = constraint.field;
-                if (constraint.field === 'cost') {
-                    fieldToCheck = 'outputCost';
-                }
-                switch (constraint.type) {
-                    case 'gt':
-                        return Number(provider[fieldToCheck]) > parseFloat(constraint.value);
-                    case 'lt':
-                        return Number(provider[fieldToCheck]) < parseFloat(constraint.value);
-                    case 'eq':
-                        return Number(provider[fieldToCheck]) === parseFloat(constraint.value);
-                    default:
-                        return false;
-                }
-            }) || false);
-        });
-    }
-    if (parsed.capabilities) {
-        filterChain.push(function capabilitiesFilter(model, provider) {
-            return Object.entries(parsed?.capabilities || {}).every(([key, value]) => {
-                return provider?.supportedParameters?.includes(camelCase(key));
-            });
-        });
-    }
-    for (const model of modelsToFilterMixin) {
-        for (const provider of model.providers || []) {
-            if (filterChain.every((f) => f(model, provider))) {
-                modelAndProviders.push({
-                    model,
-                    provider: provider,
-                });
-            }
-        }
-    }
-    const orderBy = (fields) => (a, b) => fields
-        .map((o) => {
-        let dir = 1;
-        if (o[0] === '-') {
-            dir = -1;
-            o = o.substring(1);
-        }
-        // Support for dot notation to access nested properties
-        const getNestedValue = (obj, path) => {
-            return path.split('.').reduce((prev, curr) => (prev && prev[curr] !== undefined ? prev[curr] : undefined), obj);
-        };
-        const aVal = getNestedValue(a, o);
-        const bVal = getNestedValue(b, o);
-        return aVal > bVal ? dir : aVal < bVal ? -dir : 0;
-    })
-        .reduce((p, n) => (p ? p : n), 0);
-    let sortingStrategy = orderBy(parsed?.priorities?.map((f) => `provider.${f}`) || []);
-    // Re-join back on model, replacing the providers with the filtered providers
-    return {
-        models: modelAndProviders
-            .map((x) => ({
-            ...x.model,
-            provider: x.provider,
-        }))
-            .map((x) => {
-            delete x.providers;
-            delete x.endpoint;
-            return x;
-        })
-            .sort(sortingStrategy),
-        parsed,
-    };
-}
-/**
- * Helper function to get the first model that matches a model identifier
- * @param modelIdentifier
- * @returns ResolvedModel
- */
-export function getModel(modelIdentifier, augments = {}) {
-    // Inject the augments into the model string inside the parentheses
-    // Keeping the content of the parentheses intact
-    const parentheses = modelIdentifier.match(/\(([^)]+)\)/);
-    const augmentsString = [];
-    Object.entries(augments).forEach(([key, value]) => {
-        if (key == 'seed')
-            augmentsString.push(`seed:${value}`);
-        else if (key == 'temperature')
-            augmentsString.push(`temperature:${value}`);
-        else if (key == 'topP')
-            augmentsString.push(`topP:${value}`);
-        else if (key == 'topK')
-            augmentsString.push(`topK:${value}`);
-        else if (key == 'thread')
-            augmentsString.push(`thread:${value}`);
-        else if (key == 'requiredCapabilities') {
-            for (const capability of value) {
-                augmentsString.push(capability);
-            }
-        }
-        else
-            augmentsString.push(`${key}:${value}`);
-    });
-    if (parentheses) {
-        modelIdentifier = modelIdentifier.replace(parentheses[0], `(${parentheses[1]},${augmentsString.filter(Boolean).join(',')})`);
-    }
-    else {
-        if (augmentsString.length) {
-            modelIdentifier += `(${augmentsString.join(',')})`;
-        }
-    }
-    const parsed = parse(modelIdentifier);
-    const { models } = filterModels(modelIdentifier);
-    return {
-        ...models[0],
-        parsed: {
-            ...parsed,
-            ...augments,
-        },
-    };
-}
-export function getModels(modelIdentifier) {
-    // Split the modelIdentifier by comma, ignoring commas inside parentheses
-    let result = [];
-    let segment = '';
-    let depth = 0;
-    for (const char of modelIdentifier) {
-        if (char === '(')
-            depth++;
-        else if (char === ')')
-            depth--;
-        else if (char === ',' && depth === 0) {
-            result.push(segment.trim());
-            segment = '';
-            continue;
-        }
-        segment += char;
-    }
-    if (segment.trim())
-        result.push(segment.trim());
-    // Resolve each segment
-    return result.map((r) => getModel(r));
-}
-// TODO: Move this to a database or another source of truth
-// This isnt a good place for this data.
-const metaModels = [
-    {
-        name: 'frontier',
-        models: ['gemini-2.0-flash-001', 'deepseek-r1'],
-    },
-];

package/dist/providers.d.ts

@@ -1 +0,0 @@
-export declare const getProviderName: (provider: string) => string | undefined;