@promptbook/core 0.89.0 → 0.92.0-3

package/esm/typings/src/_packages/core.index.d.ts

@@ -87,6 +87,7 @@ import { FORMFACTOR_DEFINITIONS } from '../formfactors/index';
 import { MatcherFormfactorDefinition } from '../formfactors/matcher/MatcherFormfactorDefinition';
 import { SheetsFormfactorDefinition } from '../formfactors/sheets/SheetsFormfactorDefinition';
 import { TranslatorFormfactorDefinition } from '../formfactors/translator/TranslatorFormfactorDefinition';
+import { filterModels } from '../llm-providers/_common/filterModels';
 import { $llmToolsMetadataRegister } from '../llm-providers/_common/register/$llmToolsMetadataRegister';
 import { $llmToolsRegister } from '../llm-providers/_common/register/$llmToolsRegister';
 import { createLlmToolsFromConfiguration } from '../llm-providers/_common/register/createLlmToolsFromConfiguration';
@@ -225,6 +226,7 @@ export { FORMFACTOR_DEFINITIONS };
 export { MatcherFormfactorDefinition };
 export { SheetsFormfactorDefinition };
 export { TranslatorFormfactorDefinition };
+export { filterModels };
 export { $llmToolsMetadataRegister };
 export { $llmToolsRegister };
 export { createLlmToolsFromConfiguration };

package/esm/typings/src/llm-providers/_common/filterModels.d.ts

@@ -0,0 +1,15 @@
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+/**
+ * Creates a wrapper around LlmExecutionTools that only exposes models matching the filter function
+ *
+ * @param llmTools The original LLM execution tools to wrap
+ * @param modelFilter Function that determines whether a model should be included
+ * @returns A new LlmExecutionTools instance with filtered models
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function filterModels<TLlmTools extends LlmExecutionTools>(llmTools: TLlmTools, modelFilter: (model: AvailableModel) => boolean): TLlmTools;
+/**
+ * TODO: !!! [models] Test that this is working
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/core",
-    "version": "0.89.0",
+    "version": "0.92.0-3",
     "description": "It's time for a paradigm shift. The future of software in plain English, French or Latin",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -27,7 +27,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.89.0';
+    const PROMPTBOOK_ENGINE_VERSION = '0.92.0-3';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -9904,6 +9904,81 @@
         },
     };
 
+    /**
+     * Creates a wrapper around LlmExecutionTools that only exposes models matching the filter function
+     *
+     * @param llmTools The original LLM execution tools to wrap
+     * @param modelFilter Function that determines whether a model should be included
+     * @returns A new LlmExecutionTools instance with filtered models
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function filterModels(llmTools, modelFilter) {
+        const filteredTools = {
+            // Keep all properties from the original llmTools
+            ...llmTools,
+            get description() {
+                return `${llmTools.description} (filtered)`;
+            },
+            // Override listModels to filter the models
+            async listModels() {
+                const originalModels = await llmTools.listModels();
+                // Handle both synchronous and Promise return types
+                if (originalModels instanceof Promise) {
+                    return originalModels.then((models) => models.filter(modelFilter));
+                }
+                else {
+                    return originalModels.filter(modelFilter);
+                }
+            },
+        };
+        // Helper function to validate if a model is allowed
+        async function isModelAllowed(modelName) {
+            const models = await filteredTools.listModels();
+            return models.some((model) => model.modelName === modelName);
+        }
+        // Override callChatModel if it exists in the original tools
+        if (llmTools.callChatModel) {
+            filteredTools.callChatModel = async (prompt) => {
+                var _a;
+                const modelName = (_a = prompt.modelRequirements) === null || _a === void 0 ? void 0 : _a.modelName;
+                // If a specific model is requested, check if it's allowed
+                if (modelName && !(await isModelAllowed(modelName))) {
+                    throw new PipelineExecutionError(`Model ${modelName} is not allowed by the filter for chat calls`);
+                }
+                return llmTools.callChatModel(prompt);
+            };
+        }
+        // Override callCompletionModel if it exists in the original tools
+        if (llmTools.callCompletionModel) {
+            filteredTools.callCompletionModel = async (prompt) => {
+                var _a;
+                const modelName = (_a = prompt.modelRequirements) === null || _a === void 0 ? void 0 : _a.modelName;
+                // If a specific model is requested, check if it's allowed
+                if (modelName && !(await isModelAllowed(modelName))) {
+                    throw new PipelineExecutionError(`Model ${modelName} is not allowed by the filter for completion calls`);
+                }
+                return llmTools.callCompletionModel(prompt);
+            };
+        }
+        // Override callEmbeddingModel if it exists in the original tools
+        if (llmTools.callEmbeddingModel) {
+            filteredTools.callEmbeddingModel = async (prompt) => {
+                var _a;
+                const modelName = (_a = prompt.modelRequirements) === null || _a === void 0 ? void 0 : _a.modelName;
+                // If a specific model is requested, check if it's allowed
+                if (modelName && !(await isModelAllowed(modelName))) {
+                    throw new PipelineExecutionError(`Model ${modelName} is not allowed by the filter for embedding calls`);
+                }
+                return llmTools.callEmbeddingModel(prompt);
+            };
+        }
+        return filteredTools;
+    }
+    /**
+     * TODO: !!! [models] Test that this is working
+     */
+
     /**
      * @@@
      *
@@ -11167,6 +11242,7 @@
     exports.embeddingVectorToString = embeddingVectorToString;
     exports.executionReportJsonToString = executionReportJsonToString;
     exports.extractParameterNamesFromTask = extractParameterNamesFromTask;
+    exports.filterModels = filterModels;
     exports.getPipelineInterface = getPipelineInterface;
     exports.identificationToPromptbookToken = identificationToPromptbookToken;
     exports.isPassingExpectations = isPassingExpectations;