@promptbook/openai 0.103.0-36 → 0.103.0-37

package/esm/typings/src/errors/0-index.d.ts

@@ -7,6 +7,7 @@ import { ExpectError } from './ExpectError';
 import { KnowledgeScrapeError } from './KnowledgeScrapeError';
 import { LimitReachedError } from './LimitReachedError';
 import { MissingToolsError } from './MissingToolsError';
+import { NotAllowed } from './NotAllowed';
 import { NotFoundError } from './NotFoundError';
 import { NotYetImplementedError } from './NotYetImplementedError';
 import { ParseError } from './ParseError';
@@ -40,6 +41,7 @@ export declare const PROMPTBOOK_ERRORS: {
     readonly PromptbookFetchError: typeof PromptbookFetchError;
     readonly UnexpectedError: typeof UnexpectedError;
     readonly WrappedError: typeof WrappedError;
+    readonly NotAllowed: typeof NotAllowed;
 };
 /**
  * Index of all javascript errors
@@ -88,6 +90,7 @@ export declare const ALL_ERRORS: {
     readonly PromptbookFetchError: typeof PromptbookFetchError;
     readonly UnexpectedError: typeof UnexpectedError;
     readonly WrappedError: typeof WrappedError;
+    readonly NotAllowed: typeof NotAllowed;
 };
 /**
  * Note: [💞] Ignore a discrepancy between file name and entity name

package/esm/typings/src/errors/NotAllowed.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This error indicates that promptbook operation is not allowed
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare class NotAllowed extends Error {
+    readonly name = "NotAllowed";
+    constructor(message: string);
+}

package/esm/typings/src/execution/AvailableModel.d.ts

@@ -46,5 +46,6 @@ export type AvailableModel = {
     readonly isDeprecated?: boolean;
 };
 /**
+ * TODO: [🕛] Extend this from sth like `AgentBasicInformation` / `ModelBasicInformation`
  * TODO: [🧠] Maybe rename to something else - like `ModelInformation` or `ModelMetadata`
  */

package/esm/typings/src/execution/Executables.d.ts

@@ -16,3 +16,6 @@ export type Executables = {
      */
     libreOfficePath?: string_executable_path;
 };
+/**
+ * <- TODO: Add !!! `browserPath` to `Executables`
+ */

package/esm/typings/src/execution/ExecutionTools.d.ts

@@ -67,3 +67,8 @@ export type ExecutionTools = {
      */
     readonly userInterface?: UserInterfaceTools;
 };
+/**
+ * <- TODO: Add !!! `promptbookAgent` to `ExecutionTools`
+ * <- TODO: Add !!! `mcps` to `ExecutionTools`
+ * <- TODO: Add !!! `prepareCache` to `ExecutionTools`
+ */

package/esm/typings/src/execution/LlmExecutionTools.d.ts

@@ -56,7 +56,7 @@ export type LlmExecutionTools = {
     callEmbeddingModel?(prompt: Prompt): Promise<EmbeddingPromptResult>;
 };
 /**
- * TODO: [🕛] Extend this from sth class
+ * TODO: [🕛] Extend this from sth class -  like `AgentBasicInformation` / `ModelBasicInformation``
  * TODO: [🍚] Implement destroyable pattern to free resources
  * TODO: [🏳] Add `callTranslationModel`
  * TODO: [🧠] Emulation of one type of model with another one - emuate chat with completion; emulate translation with chat

package/esm/typings/src/llm-providers/agent/Agent.d.ts

@@ -0,0 +1,44 @@
+import { BehaviorSubject } from 'rxjs';
+import { AgentBasicInformation, BookParameter, LlmExecutionTools, string_agent_name, string_book, string_url_image } from '../../_packages/types.index';
+import { AgentOptions } from './AgentOptions';
+/**
+ * Note: !!!! `Agent` vs `LlmExecutionTools`
+ *
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare class Agent implements AgentBasicInformation {
+    private readonly options;
+    /**
+     * Name of the agent
+     */
+    agentName: string_agent_name | null;
+    /**
+     * Description of the agent
+     */
+    personaDescription: string | null;
+    /**
+     * Metadata like image or color
+     */
+    meta: {
+        image?: string_url_image;
+        link?: string;
+        title?: string;
+        description?: string;
+        [key: string]: string | undefined;
+    };
+    /**
+     * Not used in Agent, always returns empty array
+     */
+    get parameters(): BookParameter[];
+    readonly agentSource: BehaviorSubject<string_book>;
+    constructor(options: AgentOptions);
+    /**
+     * Creates LlmExecutionTools which exposes the agent as a model
+     */
+    getLlmExecutionTools(): LlmExecutionTools;
+}
+/**
+ * TODO: [🧠][😰]Agent is not working with the parameters, should it be?
+ * TODO: !!! Agent on remote server
+ */

package/esm/typings/src/llm-providers/agent/AgentOptions.d.ts

@@ -0,0 +1,17 @@
+import { CommonToolsOptions, ExecutionTools, string_book } from '../../_packages/types.index';
+import { Updatable } from '../../types/Updatable';
+/**
+ * Options for creating an Agent
+ */
+export type AgentOptions = CommonToolsOptions & {
+    /**
+     * The execution tools available to the agent
+     *
+     * Here the agent has access to various LLM models, browser, scrapers, LibreOffice, tools, etc.
+     */
+    executionTools: ExecutionTools;
+    /**
+     * The source of the agent
+     */
+    agentSource: Updatable<string_book>;
+};

package/esm/typings/src/llm-providers/agent/CreateAgentLlmExecutionToolsOptions.d.ts

@@ -0,0 +1,16 @@
+import type { string_book } from '../../_packages/types.index';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { OpenAiAssistantExecutionTools } from '../openai/OpenAiAssistantExecutionTools';
+/**
+ * Options for creating AgentLlmExecutionTools
+ */
+export type CreateAgentLlmExecutionToolsOptions = {
+    /**
+     * The underlying LLM execution tools to wrap
+     */
+    llmTools: LlmExecutionTools | OpenAiAssistantExecutionTools;
+    /**
+     * The agent source string that defines the agent's behavior
+     */
+    agentSource: string_book;
+};

package/esm/typings/src/llm-providers/agent/createAgentLlmExecutionTools.d.ts

@@ -1,19 +1,5 @@
-import type { string_book } from '../../book-2.0/agent-source/string_book';
-import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import { AgentLlmExecutionTools } from './AgentLlmExecutionTools';
-/**
- * Options for creating AgentLlmExecutionTools
- */
-export type CreateAgentLlmExecutionToolsOptions = {
-    /**
-     * The underlying LLM execution tools to wrap
-     */
-    llmTools: LlmExecutionTools;
-    /**
-     * The agent source string that defines the agent's behavior
-     */
-    agentSource: string_book;
-};
+import { CreateAgentLlmExecutionToolsOptions } from './CreateAgentLlmExecutionToolsOptions';
 /**
  * Creates new AgentLlmExecutionTools that wrap underlying LLM tools with agent-specific behavior
  *

package/esm/typings/src/llm-providers/openai/OpenAiAssistantExecutionTools.d.ts

@@ -13,6 +13,7 @@ import { OpenAiExecutionTools } from './OpenAiExecutionTools';
  */
 export declare class OpenAiAssistantExecutionTools extends OpenAiExecutionTools implements LlmExecutionTools {
     private readonly assistantId;
+    private readonly isCreatingNewAssistantsAllowed;
     /**
      * Creates OpenAI Execution Tools.
      *
@@ -25,6 +26,17 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiExecutionTools
      * Calls OpenAI API to use a chat model.
      */
     callChatModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements' | 'format'>): Promise<ChatPromptResult>;
+    createNewAssistant(): Promise<OpenAiAssistantExecutionTools>;
+    /**
+     * Discriminant for type guards
+     */
+    protected get discriminant(): string;
+    /**
+     * Type guard to check if given `LlmExecutionTools` are instanceof `OpenAiAssistantExecutionTools`
+     *
+     * Note: This is useful when you can possibly have multiple versions of `@promptbook/openai` installed
+     */
+    static isOpenAiAssistantExecutionTools(llmExecutionTools: LlmExecutionTools): llmExecutionTools is OpenAiAssistantExecutionTools;
 }
 /**
  * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI

package/esm/typings/src/llm-providers/openai/OpenAiAssistantExecutionToolsOptions.d.ts

@@ -7,8 +7,14 @@ import type { OpenAiCompatibleExecutionToolsOptions } from './OpenAiCompatibleEx
  * @public exported from `@promptbook/openai`
  */
 export type OpenAiAssistantExecutionToolsOptions = OpenAiCompatibleExecutionToolsOptions & ClientOptions & {
+    /**
+     * Whether creating new assistants is allowed
+     *
+     * @default false
+     */
+    readonly isCreatingNewAssistantsAllowed?: boolean;
     /**
      * Which assistant to use
      */
-    assistantId: string_token;
+    readonly assistantId: string_token;
 };

package/esm/typings/src/remote-server/startRemoteServer.d.ts

@@ -11,6 +11,8 @@ import type { RemoteServerOptions } from './types/RemoteServerOptions';
  */
 export declare function startRemoteServer<TCustomOptions = undefined>(options: RemoteServerOptions<TCustomOptions>): RemoteServer;
 /**
+ * TODO !!!! Add agent
+ * TODO: !!!! Allow to chat with agents directly via remote server
  * TODO: [🕋] Use here `aboutPromptbookInformation`
  * TODO: [🌡] Add CORS and security - probably via `helmet`
  * TODO: Split this file into multiple functions - handler for each request

package/esm/typings/src/types/Updatable.d.ts

@@ -0,0 +1,19 @@
+import { BehaviorSubject } from 'rxjs';
+/**
+ * A type that represents a value that can be updated over time:
+ *
+ * 1) It can be a static value of type `TValue`
+ * 2) Or a `BehaviorSubject` that emits values of type `TValue`
+ * 3) Or pair of `[getValue, setValue]` functions for getting and setting the value
+ */
+export type Updatable<TValue> = TValue | BehaviorSubject<TValue> | [TValue, (value: TValue) => void];
+/**
+ * Restricts an Updatable to a (2) BehaviorSubject variant
+ *
+ * @see Updatable
+ * @private internal utility <- TODO: [🧠] Maybe export from `@promptbook/types`
+ */
+export declare function asUpdatableSubject<TValue>(value: Updatable<TValue>): BehaviorSubject<TValue>;
+/**
+ * TODO: [🧠] Maybe `BehaviorSubject` is too heavy for this use case, maybe just tuple `[value,setValue]` is enough
+ */

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.103.0-35`).
+ * It follows semantic versioning (e.g., `0.103.0-36`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/openai",
-    "version": "0.103.0-36",
+    "version": "0.103.0-37",
     "description": "Promptbook: Turn your company's scattered knowledge into AI ready books",
     "private": false,
     "sideEffects": false,
@@ -102,7 +102,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/openai.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.103.0-36"
+        "@promptbook/core": "0.103.0-37"
     },
     "dependencies": {
         "bottleneck": "2.19.5",

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.103.0-36';
+    const PROMPTBOOK_ENGINE_VERSION = '0.103.0-37';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -71,6 +71,19 @@
      * TODO: [🎺]
      */
 
+    /**
+     * This error indicates that promptbook operation is not allowed
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class NotAllowed extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'NotAllowed';
+            Object.setPrototypeOf(this, NotAllowed.prototype);
+        }
+    }
+
     /**
      * This error type indicates that some part of the code is not implemented yet
      *
@@ -3628,11 +3641,18 @@
          * @param options which are relevant are directly passed to the OpenAI client
          */
         constructor(options) {
+            var _a;
             if (options.isProxied) {
                 throw new NotYetImplementedError(`Proxy mode is not yet implemented for OpenAI assistants`);
             }
             super(options);
+            this.isCreatingNewAssistantsAllowed = false;
             this.assistantId = options.assistantId;
+            this.isCreatingNewAssistantsAllowed = (_a = options.isCreatingNewAssistantsAllowed) !== null && _a !== void 0 ? _a : false;
+            if (this.assistantId === null && !this.isCreatingNewAssistantsAllowed) {
+                throw new NotAllowed(`Assistant ID is null and creating new assistants is not allowed - this configuration does not make sense`);
+            }
+            // <- TODO: !!! `OpenAiAssistantExecutionToolsOptions` - Allow `assistantId: null` together with `isCreatingNewAssistantsAllowed: true`
             // TODO: [👱] Make limiter same as in `OpenAiExecutionTools`
         }
         get title() {
@@ -3777,7 +3797,99 @@
                 },
             });
         }
+        async createNewAssistant() {
+            if (!this.isCreatingNewAssistantsAllowed) {
+                throw new NotAllowed(`Creating new assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
+            }
+            const client = await this.getClient();
+            /*
+            TODO: !!!
+            async function downloadFile(url: string, folder = './tmp'): Promise<string> {
+                const filename = path.basename(url.split('?')[0]);
+                const filepath = path.join(folder, filename);
+
+                if (!fs.existsSync(folder)) fs.mkdirSync(folder);
+
+                const res = await fetch(url);
+                if (!res.ok) throw new Error(`Download error: ${url}`);
+                const buffer = await res.arrayBuffer();
+                fs.writeFileSync(filepath, Buffer.from(buffer));
+                console.log(`📥 File downloaded: ${filename}`);
+
+                return filepath;
+            }
+
+            async function uploadFileToOpenAI(filepath: string) {
+                const file = await client.files.create({
+                    file: fs.createReadStream(filepath),
+                    purpose: 'assistants',
+                });
+                console.log(`⬆️  File uploaded to OpenAI: ${file.filename} (${file.id})`);
+                return file;
+            }
+
+            // 🌐 URL addresses of files to upload
+            const fileUrls = [
+                'https://raw.githubusercontent.com/vercel/next.js/canary/packages/next/README.md',
+                'https://raw.githubusercontent.com/openai/openai-cookbook/main/examples/How_to_call_the_Assistants_API_with_Node.js.ipynb',
+            ];
+
+            // 1️⃣ Download files from URL
+            const localFiles = [];
+            for (const url of fileUrls) {
+                const filepath = await downloadFile(url);
+                localFiles.push(filepath);
+            }
+
+            // 2️⃣ Upload files to OpenAI
+            const uploadedFiles = [];
+            for (const filepath of localFiles) {
+                const file = await uploadFileToOpenAI(filepath);
+                uploadedFiles.push(file.id);
+            }
+            */
+            // 3️⃣ Create assistant with uploaded files
+            const assistant = await client.beta.assistants.create({
+                name: 'Next.js documentation assistant',
+                description: 'Assistant that can answer questions about Next.js and working with APIs.',
+                model: 'gpt-4o',
+                instructions: spaceTrim__default["default"](`
+                Answer clearly and comprehensively.
+                Quote parts from uploaded files if needed.
+            `),
+                // <- TODO: !!!! Generate the `instructions` from passed `agentSource` (generate outside of this class)
+                tools: [{ type: 'code_interpreter' }, { type: 'file_search' }],
+                // !!!! file_ids: uploadedFiles,
+            });
+            // TODO: !!!! Change Czech to English
+            console.log(`✅ Assistant created: ${assistant.id}`);
+            return new OpenAiAssistantExecutionTools({
+                ...this.options,
+                isCreatingNewAssistantsAllowed: false,
+                assistantId: assistant.id,
+            });
+        }
+        /**
+         * Discriminant for type guards
+         */
+        get discriminant() {
+            return DISCRIMINANT;
+        }
+        /**
+         * Type guard to check if given `LlmExecutionTools` are instanceof `OpenAiAssistantExecutionTools`
+         *
+         * Note: This is useful when you can possibly have multiple versions of `@promptbook/openai` installed
+         */
+        static isOpenAiAssistantExecutionTools(llmExecutionTools) {
+            return llmExecutionTools.discriminant === DISCRIMINANT;
+        }
     }
+    /**
+     * Discriminant for type guards
+     *
+     * @private const of `OpenAiAssistantExecutionTools`
+     */
+    const DISCRIMINANT = 'OPEN_AI_ASSISTANT_V1';
     /**
      * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI
      * TODO: Maybe make custom OpenAiError
@@ -4013,6 +4125,7 @@
         PromptbookFetchError,
         UnexpectedError,
         WrappedError,
+        NotAllowed,
         // TODO: [🪑]> VersionMismatchError,
     };
     /**