@machina.ai/cell-cli-core 1.13.0-rc5 → 1.16.0-rc2

package/dist/src/services/modelConfigService.js

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export class ModelConfigService {
+    config;
+    // TODO(12597): Process config to build a typed alias hierarchy.
+    constructor(config) {
+        this.config = config;
+    }
+    resolveAlias(aliasName, aliases, visited = new Set()) {
+        if (visited.has(aliasName)) {
+            throw new Error(`Circular alias dependency: ${[...visited, aliasName].join(' -> ')}`);
+        }
+        visited.add(aliasName);
+        const alias = aliases[aliasName];
+        if (!alias) {
+            throw new Error(`Alias "${aliasName}" not found.`);
+        }
+        if (!alias.extends) {
+            return alias;
+        }
+        const baseAlias = this.resolveAlias(alias.extends, aliases, visited);
+        return {
+            modelConfig: {
+                model: alias.modelConfig.model ?? baseAlias.modelConfig.model,
+                generateContentConfig: this.deepMerge(baseAlias.modelConfig.generateContentConfig, alias.modelConfig.generateContentConfig),
+            },
+        };
+    }
+    internalGetResolvedConfig(context) {
+        const config = this.config || {};
+        const { aliases = {}, overrides = [] } = config;
+        let baseModel = context.model;
+        let resolvedConfig = {};
+        // Step 1: Alias Resolution
+        if (aliases[context.model]) {
+            const resolvedAlias = this.resolveAlias(context.model, aliases);
+            baseModel = resolvedAlias.modelConfig.model; // This can now be undefined
+            resolvedConfig = this.deepMerge(resolvedConfig, resolvedAlias.modelConfig.generateContentConfig);
+        }
+        // If an alias was used but didn't resolve to a model, `baseModel` is undefined.
+        // We still need a model for matching overrides. We'll use the original alias name
+        // for matching if no model is resolved yet.
+        const modelForMatching = baseModel ?? context.model;
+        const finalContext = {
+            ...context,
+            model: modelForMatching,
+        };
+        // Step 2: Override Application
+        const matches = overrides
+            .map((override, index) => {
+            const matchEntries = Object.entries(override.match);
+            if (matchEntries.length === 0) {
+                return null;
+            }
+            const isMatch = matchEntries.every(([key, value]) => {
+                if (key === 'model') {
+                    return value === context.model || value === finalContext.model;
+                }
+                if (key === 'overrideScope' && value === 'core') {
+                    // The 'core' overrideScope is special. It should match if the
+                    // overrideScope is explicitly 'core' or if the overrideScope
+                    // is not specified.
+                    return context.overrideScope === 'core' || !context.overrideScope;
+                }
+                return finalContext[key] === value;
+            });
+            if (isMatch) {
+                return {
+                    specificity: matchEntries.length,
+                    modelConfig: override.modelConfig,
+                    index,
+                };
+            }
+            return null;
+        })
+            .filter((match) => match !== null);
+        // The override application logic is designed to be both simple and powerful.
+        // By first sorting all matching overrides by specificity (and then by their
+        // original order as a tie-breaker), we ensure that as we merge the `config`
+        // objects, the settings from the most specific rules are applied last,
+        // correctly overwriting any values from broader, less-specific rules.
+        // This achieves a per-property override effect without complex per-property logic.
+        matches.sort((a, b) => {
+            if (a.specificity !== b.specificity) {
+                return a.specificity - b.specificity;
+            }
+            return a.index - b.index;
+        });
+        // Apply matching overrides
+        for (const match of matches) {
+            if (match.modelConfig.model) {
+                baseModel = match.modelConfig.model;
+            }
+            if (match.modelConfig.generateContentConfig) {
+                resolvedConfig = this.deepMerge(resolvedConfig, match.modelConfig.generateContentConfig);
+            }
+        }
+        return {
+            model: baseModel,
+            generateContentConfig: resolvedConfig,
+        };
+    }
+    getResolvedConfig(context) {
+        const resolved = this.internalGetResolvedConfig(context);
+        if (!resolved.model) {
+            throw new Error(`Could not resolve a model name for alias "${context.model}". Please ensure the alias chain or a matching override specifies a model.`);
+        }
+        return {
+            model: resolved.model,
+            generateContentConfig: resolved.generateContentConfig,
+        };
+    }
+    isObject(item) {
+        return !!item && typeof item === 'object' && !Array.isArray(item);
+    }
+    deepMerge(config1, config2) {
+        return this.genericDeepMerge(config1, config2);
+    }
+    genericDeepMerge(...objects) {
+        return objects.reduce((acc, obj) => {
+            if (!obj) {
+                return acc;
+            }
+            Object.keys(obj).forEach((key) => {
+                const accValue = acc[key];
+                const objValue = obj[key];
+                // For now, we only deep merge objects, and not arrays. This is because
+                // If we deep merge arrays, there is no way for the user to completely
+                // override the base array.
+                // TODO(joshualitt): Consider knobs here, i.e. opt-in to deep merging
+                // arrays on a case-by-case basis.
+                if (this.isObject(accValue) && this.isObject(objValue)) {
+                    acc[key] = this.deepMerge(accValue, objValue);
+                }
+                else {
+                    acc[key] = objValue;
+                }
+            });
+            return acc;
+        }, {});
+    }
+}
+//# sourceMappingURL=modelConfigService.js.map

package/dist/src/services/modelConfigService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelConfigService.js","sourceRoot":"","sources":["../../../src/services/modelConfigService.ts"],"names":[],"mappings":"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"}

package/dist/src/services/modelConfigService.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/services/modelConfigService.test.js

@@ -0,0 +1,509 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect } from 'vitest';
+import { ModelConfigService } from './modelConfigService.js';
+describe('ModelConfigService', () => {
+    it('should resolve a basic alias to its model and settings', () => {
+        const config = {
+            aliases: {
+                classifier: {
+                    modelConfig: {
+                        model: 'gemini-1.5-flash-latest',
+                        generateContentConfig: {
+                            temperature: 0,
+                            topP: 0.9,
+                        },
+                    },
+                },
+            },
+            overrides: [],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({ model: 'classifier' });
+        expect(resolved.model).toBe('gemini-1.5-flash-latest');
+        expect(resolved.generateContentConfig).toEqual({
+            temperature: 0,
+            topP: 0.9,
+        });
+    });
+    it('should apply a simple override on top of an alias', () => {
+        const config = {
+            aliases: {
+                classifier: {
+                    modelConfig: {
+                        model: 'gemini-1.5-flash-latest',
+                        generateContentConfig: {
+                            temperature: 0,
+                            topP: 0.9,
+                        },
+                    },
+                },
+            },
+            overrides: [
+                {
+                    match: { model: 'classifier' },
+                    modelConfig: {
+                        generateContentConfig: {
+                            temperature: 0.5,
+                            maxOutputTokens: 1000,
+                        },
+                    },
+                },
+            ],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({ model: 'classifier' });
+        expect(resolved.model).toBe('gemini-1.5-flash-latest');
+        expect(resolved.generateContentConfig).toEqual({
+            temperature: 0.5,
+            topP: 0.9,
+            maxOutputTokens: 1000,
+        });
+    });
+    it('should apply the most specific override rule', () => {
+        const config = {
+            aliases: {},
+            overrides: [
+                {
+                    match: { model: 'gemini-pro' },
+                    modelConfig: { generateContentConfig: { temperature: 0.5 } },
+                },
+                {
+                    match: { model: 'gemini-pro', overrideScope: 'my-agent' },
+                    modelConfig: { generateContentConfig: { temperature: 0.1 } },
+                },
+            ],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({
+            model: 'gemini-pro',
+            overrideScope: 'my-agent',
+        });
+        expect(resolved.model).toBe('gemini-pro');
+        expect(resolved.generateContentConfig).toEqual({ temperature: 0.1 });
+    });
+    it('should use the last override in case of a tie in specificity', () => {
+        const config = {
+            aliases: {},
+            overrides: [
+                {
+                    match: { model: 'gemini-pro' },
+                    modelConfig: {
+                        generateContentConfig: { temperature: 0.5, topP: 0.8 },
+                    },
+                },
+                {
+                    match: { model: 'gemini-pro' },
+                    modelConfig: { generateContentConfig: { temperature: 0.1 } },
+                },
+            ],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({ model: 'gemini-pro' });
+        expect(resolved.model).toBe('gemini-pro');
+        expect(resolved.generateContentConfig).toEqual({
+            temperature: 0.1,
+            topP: 0.8,
+        });
+    });
+    it('should correctly pass through generation config from an alias', () => {
+        const config = {
+            aliases: {
+                'thinking-alias': {
+                    modelConfig: {
+                        model: 'gemini-pro',
+                        generateContentConfig: {
+                            candidateCount: 500,
+                        },
+                    },
+                },
+            },
+            overrides: [],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({ model: 'thinking-alias' });
+        expect(resolved.generateContentConfig).toEqual({ candidateCount: 500 });
+    });
+    it('should let an override generation config win over an alias config', () => {
+        const config = {
+            aliases: {
+                'thinking-alias': {
+                    modelConfig: {
+                        model: 'gemini-pro',
+                        generateContentConfig: {
+                            candidateCount: 500,
+                        },
+                    },
+                },
+            },
+            overrides: [
+                {
+                    match: { model: 'thinking-alias' },
+                    modelConfig: {
+                        generateContentConfig: {
+                            candidateCount: 1000,
+                        },
+                    },
+                },
+            ],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({ model: 'thinking-alias' });
+        expect(resolved.generateContentConfig).toEqual({
+            candidateCount: 1000,
+        });
+    });
+    it('should merge settings from global, alias, and multiple matching overrides', () => {
+        const config = {
+            aliases: {
+                'test-alias': {
+                    modelConfig: {
+                        model: 'gemini-test-model',
+                        generateContentConfig: {
+                            topP: 0.9,
+                            topK: 50,
+                        },
+                    },
+                },
+            },
+            overrides: [
+                {
+                    match: { model: 'gemini-test-model' },
+                    modelConfig: {
+                        generateContentConfig: {
+                            topK: 40,
+                            maxOutputTokens: 2048,
+                        },
+                    },
+                },
+                {
+                    match: { overrideScope: 'test-agent' },
+                    modelConfig: {
+                        generateContentConfig: {
+                            maxOutputTokens: 4096,
+                        },
+                    },
+                },
+                {
+                    match: { model: 'gemini-test-model', overrideScope: 'test-agent' },
+                    modelConfig: {
+                        generateContentConfig: {
+                            temperature: 0.2,
+                        },
+                    },
+                },
+            ],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({
+            model: 'test-alias',
+            overrideScope: 'test-agent',
+        });
+        expect(resolved.model).toBe('gemini-test-model');
+        expect(resolved.generateContentConfig).toEqual({
+            // From global, overridden by most specific override
+            temperature: 0.2,
+            // From alias, not overridden
+            topP: 0.9,
+            // From alias, overridden by less specific override
+            topK: 40,
+            // From first matching override, overridden by second matching override
+            maxOutputTokens: 4096,
+        });
+    });
+    it('should match an agent:core override when agent is undefined', () => {
+        const config = {
+            aliases: {},
+            overrides: [
+                {
+                    match: { overrideScope: 'core' },
+                    modelConfig: {
+                        generateContentConfig: {
+                            temperature: 0.1,
+                        },
+                    },
+                },
+            ],
+        };
+        const service = new ModelConfigService(config);
+        const resolved = service.getResolvedConfig({
+            model: 'gemini-pro',
+            overrideScope: undefined, // Explicitly undefined
+        });
+        expect(resolved.model).toBe('gemini-pro');
+        expect(resolved.generateContentConfig).toEqual({
+            temperature: 0.1,
+        });
+    });
+    describe('alias inheritance', () => {
+        it('should resolve a simple "extends" chain', () => {
+            const config = {
+                aliases: {
+                    base: {
+                        modelConfig: {
+                            model: 'gemini-1.5-pro-latest',
+                            generateContentConfig: {
+                                temperature: 0.7,
+                                topP: 0.9,
+                            },
+                        },
+                    },
+                    'flash-variant': {
+                        extends: 'base',
+                        modelConfig: {
+                            model: 'gemini-1.5-flash-latest',
+                        },
+                    },
+                },
+            };
+            const service = new ModelConfigService(config);
+            const resolved = service.getResolvedConfig({ model: 'flash-variant' });
+            expect(resolved.model).toBe('gemini-1.5-flash-latest');
+            expect(resolved.generateContentConfig).toEqual({
+                temperature: 0.7,
+                topP: 0.9,
+            });
+        });
+        it('should override parent properties from child alias', () => {
+            const config = {
+                aliases: {
+                    base: {
+                        modelConfig: {
+                            model: 'gemini-1.5-pro-latest',
+                            generateContentConfig: {
+                                temperature: 0.7,
+                                topP: 0.9,
+                            },
+                        },
+                    },
+                    'flash-variant': {
+                        extends: 'base',
+                        modelConfig: {
+                            model: 'gemini-1.5-flash-latest',
+                            generateContentConfig: {
+                                temperature: 0.2,
+                            },
+                        },
+                    },
+                },
+            };
+            const service = new ModelConfigService(config);
+            const resolved = service.getResolvedConfig({ model: 'flash-variant' });
+            expect(resolved.model).toBe('gemini-1.5-flash-latest');
+            expect(resolved.generateContentConfig).toEqual({
+                temperature: 0.2,
+                topP: 0.9,
+            });
+        });
+        it('should resolve a multi-level "extends" chain', () => {
+            const config = {
+                aliases: {
+                    base: {
+                        modelConfig: {
+                            model: 'gemini-1.5-pro-latest',
+                            generateContentConfig: {
+                                temperature: 0.7,
+                                topP: 0.9,
+                            },
+                        },
+                    },
+                    'base-flash': {
+                        extends: 'base',
+                        modelConfig: {
+                            model: 'gemini-1.5-flash-latest',
+                        },
+                    },
+                    'classifier-flash': {
+                        extends: 'base-flash',
+                        modelConfig: {
+                            generateContentConfig: {
+                                temperature: 0,
+                            },
+                        },
+                    },
+                },
+            };
+            const service = new ModelConfigService(config);
+            const resolved = service.getResolvedConfig({
+                model: 'classifier-flash',
+            });
+            expect(resolved.model).toBe('gemini-1.5-flash-latest');
+            expect(resolved.generateContentConfig).toEqual({
+                temperature: 0,
+                topP: 0.9,
+            });
+        });
+        it('should throw an error for circular dependencies', () => {
+            const config = {
+                aliases: {
+                    a: { extends: 'b', modelConfig: {} },
+                    b: { extends: 'a', modelConfig: {} },
+                },
+            };
+            const service = new ModelConfigService(config);
+            expect(() => service.getResolvedConfig({ model: 'a' })).toThrow('Circular alias dependency: a -> b -> a');
+        });
+        describe('abstract aliases', () => {
+            it('should allow an alias to extend an abstract alias without a model', () => {
+                const config = {
+                    aliases: {
+                        'abstract-base': {
+                            modelConfig: {
+                                generateContentConfig: {
+                                    temperature: 0.1,
+                                },
+                            },
+                        },
+                        'concrete-child': {
+                            extends: 'abstract-base',
+                            modelConfig: {
+                                model: 'gemini-1.5-pro-latest',
+                                generateContentConfig: {
+                                    topP: 0.9,
+                                },
+                            },
+                        },
+                    },
+                };
+                const service = new ModelConfigService(config);
+                const resolved = service.getResolvedConfig({ model: 'concrete-child' });
+                expect(resolved.model).toBe('gemini-1.5-pro-latest');
+                expect(resolved.generateContentConfig).toEqual({
+                    temperature: 0.1,
+                    topP: 0.9,
+                });
+            });
+            it('should throw an error if a resolved alias chain has no model', () => {
+                const config = {
+                    aliases: {
+                        'abstract-base': {
+                            modelConfig: {
+                                generateContentConfig: { temperature: 0.7 },
+                            },
+                        },
+                    },
+                };
+                const service = new ModelConfigService(config);
+                expect(() => service.getResolvedConfig({ model: 'abstract-base' })).toThrow('Could not resolve a model name for alias "abstract-base". Please ensure the alias chain or a matching override specifies a model.');
+            });
+            it('should resolve an abstract alias if an override provides the model', () => {
+                const config = {
+                    aliases: {
+                        'abstract-base': {
+                            modelConfig: {
+                                generateContentConfig: {
+                                    temperature: 0.1,
+                                },
+                            },
+                        },
+                    },
+                    overrides: [
+                        {
+                            match: { model: 'abstract-base' },
+                            modelConfig: {
+                                model: 'gemini-1.5-flash-latest',
+                            },
+                        },
+                    ],
+                };
+                const service = new ModelConfigService(config);
+                const resolved = service.getResolvedConfig({ model: 'abstract-base' });
+                expect(resolved.model).toBe('gemini-1.5-flash-latest');
+                expect(resolved.generateContentConfig).toEqual({
+                    temperature: 0.1,
+                });
+            });
+        });
+        it('should throw an error if an extended alias does not exist', () => {
+            const config = {
+                aliases: {
+                    'bad-alias': {
+                        extends: 'non-existent',
+                        modelConfig: {},
+                    },
+                },
+            };
+            const service = new ModelConfigService(config);
+            expect(() => service.getResolvedConfig({ model: 'bad-alias' })).toThrow('Alias "non-existent" not found.');
+        });
+    });
+    describe('deep merging', () => {
+        it('should deep merge nested config objects from aliases and overrides', () => {
+            const config = {
+                aliases: {
+                    'base-safe': {
+                        modelConfig: {
+                            model: 'gemini-pro',
+                            generateContentConfig: {
+                                safetySettings: {
+                                    HARM_CATEGORY_HARASSMENT: 'BLOCK_ONLY_HIGH',
+                                    HARM_CATEGORY_HATE_SPEECH: 'BLOCK_ONLY_HIGH',
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                },
+                            },
+                        },
+                    },
+                },
+                overrides: [
+                    {
+                        match: { model: 'base-safe' },
+                        modelConfig: {
+                            generateContentConfig: {
+                                safetySettings: {
+                                    HARM_CATEGORY_HATE_SPEECH: 'BLOCK_NONE',
+                                    HARM_CATEGORY_SEXUALLY_EXPLICIT: 'BLOCK_MEDIUM_AND_ABOVE',
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                },
+                            },
+                        },
+                    },
+                ],
+            };
+            const service = new ModelConfigService(config);
+            const resolved = service.getResolvedConfig({ model: 'base-safe' });
+            expect(resolved.model).toBe('gemini-pro');
+            expect(resolved.generateContentConfig.safetySettings).toEqual({
+                // From alias
+                HARM_CATEGORY_HARASSMENT: 'BLOCK_ONLY_HIGH',
+                // From alias, overridden by override
+                HARM_CATEGORY_HATE_SPEECH: 'BLOCK_NONE',
+                // From override
+                HARM_CATEGORY_SEXUALLY_EXPLICIT: 'BLOCK_MEDIUM_AND_ABOVE',
+            });
+        });
+        it('should not deeply merge merge arrays from aliases and overrides', () => {
+            const config = {
+                aliases: {
+                    base: {
+                        modelConfig: {
+                            model: 'gemini-pro',
+                            generateContentConfig: {
+                                stopSequences: ['foo'],
+                            },
+                        },
+                    },
+                },
+                overrides: [
+                    {
+                        match: { model: 'base' },
+                        modelConfig: {
+                            generateContentConfig: {
+                                stopSequences: ['overrideFoo'],
+                            },
+                        },
+                    },
+                ],
+            };
+            const service = new ModelConfigService(config);
+            const resolved = service.getResolvedConfig({ model: 'base' });
+            expect(resolved.model).toBe('gemini-pro');
+            expect(resolved.generateContentConfig.stopSequences).toEqual([
+                'overrideFoo',
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=modelConfigService.test.js.map