@celljs/ai-core 3.8.0 → 4.0.0

package/esm/common/embedding/embedding-protocol.d.ts

@@ -0,0 +1,120 @@
+import { MimeType } from '@celljs/core';
+import { Usage } from '../chat/metadata/metadata-protocol.js';
+import { Model, ModelOptions, ModelRequest, ModelResponse, ModelResult, ResponseMetadata, ResultMetadata } from '../model/model-protocol.js';
+export declare const EmbeddingModel: unique symbol;
+/**
+ * Enum representing the modality type of the source data.
+ */
+export declare enum ModalityType {
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    AUDIO = "AUDIO",
+    VIDEO = "VIDEO"
+}
+/**
+ * Represents the metadata for an embedding result.
+ */
+export interface EmbeddingResultMetadata extends ResultMetadata {
+    /**
+     * The modality type of the source data used to generate the embedding.
+     */
+    modalityType: ModalityType;
+    /**
+     * The document ID associated with the embedding.
+     */
+    documentId: string;
+    /**
+     * The MIME type of the source data used to generate the embedding.
+     */
+    mimeType: MimeType;
+    /**
+     * The document data associated with the embedding.
+     */
+    documentData: any;
+}
+export declare namespace EmbeddingResultMetadata {
+    const EMPTY: EmbeddingResultMetadata;
+}
+/**
+ * Utility class for modality-related operations.
+ */
+export declare class ModalityUtils {
+    private static TEXT_MIME_TYPE;
+    private static IMAGE_MIME_TYPE;
+    private static VIDEO_MIME_TYPE;
+    private static AUDIO_MIME_TYPE;
+    /**
+     * Infers the {@link ModalityType} of the source data used to generate the
+     * embedding using the source data {@link MimeType}.
+     * @param mimeType the {@link MimeType} of the source data.
+     * @return Returns the {@link ModalityType} of the source data used to generate
+     * the embedding.
+     */
+    static getModalityType(mimeType: MimeType): ModalityType;
+}
+/**
+ * Metadata for the embedding response.
+ */
+export interface EmbeddingResponseMetadata extends ResponseMetadata {
+    /**
+     * The model that handled the request.
+     */
+    model: string;
+    /**
+     * The AI provider specific metadata on API usage.
+     * @see Usage
+     */
+    usage: Usage;
+}
+/**
+ * Represents a single embedding vector.
+ */
+export interface Embedding extends ModelResult<number[]> {
+    /**
+     * The embedding vector values.
+     */
+    embedding: number[];
+    /**
+     * The embedding index in a list of embeddings.
+     */
+    index: number;
+    /**
+     * The metadata associated with the embedding.
+     */
+    metadata: EmbeddingResultMetadata;
+}
+export interface EmbeddingOptions extends ModelOptions {
+    /**
+     * The name of the embedding model to use.
+     */
+    model?: string;
+    /**
+     * The dimensionality of the embedding vectors.
+     */
+    dimensions?: number;
+}
+export interface EmbeddingRequest extends ModelRequest<string[]> {
+    /**
+     * The list of input strings for the embedding request.
+     */
+    inputs: string[];
+    /**
+     * The options for the embedding request.
+     */
+    options: EmbeddingOptions;
+}
+/**
+ * Embedding response object.
+ */
+export interface EmbeddingResponse extends ModelResponse<Embedding> {
+    /**
+     * Embedding data.
+     */
+    embeddings: Embedding[];
+    /**
+     * Embedding metadata.
+     */
+    metadata: EmbeddingResponseMetadata;
+}
+export interface EmbeddingModel extends Model<EmbeddingRequest, EmbeddingResponse> {
+}

package/esm/common/embedding/embedding-protocol.js

@@ -0,0 +1,56 @@
+import { MimeTypeUtils } from '@celljs/core';
+export const EmbeddingModel = Symbol('EmbeddingModel');
+/**
+ * Enum representing the modality type of the source data.
+ */
+export var ModalityType;
+(function (ModalityType) {
+    ModalityType["TEXT"] = "TEXT";
+    ModalityType["IMAGE"] = "IMAGE";
+    ModalityType["AUDIO"] = "AUDIO";
+    ModalityType["VIDEO"] = "VIDEO";
+})(ModalityType || (ModalityType = {}));
+export var EmbeddingResultMetadata;
+(function (EmbeddingResultMetadata) {
+    EmbeddingResultMetadata.EMPTY = {
+        modalityType: ModalityType.TEXT,
+        documentId: '',
+        mimeType: MimeTypeUtils.TEXT_PLAIN,
+        documentData: undefined
+    };
+})(EmbeddingResultMetadata || (EmbeddingResultMetadata = {}));
+/**
+ * Utility class for modality-related operations.
+ */
+export class ModalityUtils {
+    /**
+     * Infers the {@link ModalityType} of the source data used to generate the
+     * embedding using the source data {@link MimeType}.
+     * @param mimeType the {@link MimeType} of the source data.
+     * @return Returns the {@link ModalityType} of the source data used to generate
+     * the embedding.
+     */
+    static getModalityType(mimeType) {
+        if (!mimeType) {
+            return ModalityType.TEXT;
+        }
+        if (mimeType.isCompatibleWith(ModalityUtils.IMAGE_MIME_TYPE)) {
+            return ModalityType.IMAGE;
+        }
+        else if (mimeType.isCompatibleWith(ModalityUtils.AUDIO_MIME_TYPE)) {
+            return ModalityType.AUDIO;
+        }
+        else if (mimeType.isCompatibleWith(ModalityUtils.VIDEO_MIME_TYPE)) {
+            return ModalityType.VIDEO;
+        }
+        else if (mimeType.isCompatibleWith(ModalityUtils.TEXT_MIME_TYPE)) {
+            return ModalityType.TEXT;
+        }
+        throw new Error('Unsupported MimeType: ' + mimeType);
+    }
+}
+ModalityUtils.TEXT_MIME_TYPE = MimeTypeUtils.parseMimeType('text/*');
+ModalityUtils.IMAGE_MIME_TYPE = MimeTypeUtils.parseMimeType('image/*');
+ModalityUtils.VIDEO_MIME_TYPE = MimeTypeUtils.parseMimeType('video/*');
+ModalityUtils.AUDIO_MIME_TYPE = MimeTypeUtils.parseMimeType('audio/*');
+//# sourceMappingURL=embedding-protocol.js.map

package/esm/common/embedding/embedding-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-protocol.js","sourceRoot":"","sources":["../../../src/common/embedding/embedding-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,aAAa,EAAE,MAAM,cAAc,CAAC;AAIvD,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAEvD;;GAEG;AACH,MAAM,CAAN,IAAY,YAKX;AALD,WAAY,YAAY;IACpB,6BAAa,CAAA;IACb,+BAAe,CAAA;IACf,+BAAe,CAAA;IACf,+BAAe,CAAA;AACnB,CAAC,EALW,YAAY,KAAZ,YAAY,QAKvB;AA2BD,MAAM,KAAW,uBAAuB,CAOvC;AAPD,WAAiB,uBAAuB;IACvB,6BAAK,GAA4B;QAC1C,YAAY,EAAE,YAAY,CAAC,IAAI;QAC/B,UAAU,EAAE,EAAE;QACd,QAAQ,EAAE,aAAa,CAAC,UAAU;QAClC,YAAY,EAAE,SAAS;KAC1B,CAAC;AACN,CAAC,EAPgB,uBAAuB,KAAvB,uBAAuB,QAOvC;AAED;;GAEG;AACH,MAAM,OAAO,aAAa;IAMtB;;;;;;OAMG;IACI,MAAM,CAAC,eAAe,CAAC,QAAkB;QAC5C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,OAAO,YAAY,CAAC,IAAI,CAAC;QAC7B,CAAC;QAED,IAAI,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,eAAe,CAAC,EAAE,CAAC;YAC3D,OAAO,YAAY,CAAC,KAAK,CAAC;QAC9B,CAAC;aAAM,IAAI,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,eAAe,CAAC,EAAE,CAAC;YAClE,OAAO,YAAY,CAAC,KAAK,CAAC;QAC9B,CAAC;aAAM,IAAI,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,eAAe,CAAC,EAAE,CAAC;YAClE,OAAO,YAAY,CAAC,KAAK,CAAC;QAC9B,CAAC;aAAM,IAAI,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,CAAC;YACjE,OAAO,YAAY,CAAC,IAAI,CAAC;QAC7B,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,QAAQ,CAAC,CAAC;IACzD,CAAC;CACJ;AA7BkB,4BAAc,GAAG,aAAa,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;AACvD,6BAAe,GAAG,aAAa,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;AACzD,6BAAe,GAAG,aAAa,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;AACzD,6BAAe,GAAG,aAAa,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC"}

package/esm/common/embedding/index.d.ts

@@ -0,0 +1 @@
+export * from './embedding-protocol.js';

package/esm/common/embedding/index.js

@@ -0,0 +1,2 @@
+export * from './embedding-protocol.js';
+//# sourceMappingURL=index.js.map

package/esm/common/embedding/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/embedding/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/esm/common/error/error.d.ts

@@ -0,0 +1,7 @@
+import { CustomError } from '@celljs/core';
+export declare class AIError extends CustomError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends AIError {
+    constructor(message: string);
+}

package/esm/common/error/error.js

@@ -0,0 +1,12 @@
+import { CustomError } from '@celljs/core';
+export class AIError extends CustomError {
+    constructor(message) {
+        super(message);
+    }
+}
+export class NotFoundError extends AIError {
+    constructor(message) {
+        super(message);
+    }
+}
+//# sourceMappingURL=error.js.map

package/esm/common/error/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../src/common/error/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,OAAO,OAAQ,SAAQ,WAAW;IACpC,YAAY,OAAe;QACvB,KAAK,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;CACJ;AAED,MAAM,OAAO,aAAc,SAAQ,OAAO;IACtC,YAAY,OAAe;QACvB,KAAK,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;CACJ"}

package/esm/common/error/index.d.ts

@@ -0,0 +1 @@
+export * from './error.js';

package/esm/common/error/index.js

@@ -0,0 +1,2 @@
+export * from './error.js';
+//# sourceMappingURL=index.js.map

package/esm/common/error/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/error/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/esm/common/index.d.ts

@@ -0,0 +1,6 @@
+export * from './chat/index.js';
+export * from './model/index.js';
+export * from './embedding/index.js';
+export * from './sse/index.js';
+export * from './utils/index.js';
+export * from './error/index.js';

package/esm/common/index.js

@@ -0,0 +1,7 @@
+export * from './chat/index.js';
+export * from './model/index.js';
+export * from './embedding/index.js';
+export * from './sse/index.js';
+export * from './utils/index.js';
+export * from './error/index.js';
+//# sourceMappingURL=index.js.map

package/esm/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/esm/common/model/function/function-callback-register.d.ts

@@ -0,0 +1,8 @@
+import { FunctionCallback, FunctionCallbackRegister, ToolContext } from './function-protocol.js';
+export declare class FunctionCallbackRegisterImpl implements FunctionCallbackRegister {
+    private functionCallbacks;
+    register(functionCallback: FunctionCallback): void;
+    unregister(functionName: string): void;
+    call(functionName: string, functionArguments: string, toolContext: ToolContext): Promise<string>;
+    resolve(functionNames: string[]): FunctionCallback[];
+}

package/esm/common/model/function/function-callback-register.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component } from '@celljs/core';
+import { FunctionCallbackRegister } from './function-protocol.js';
+import { NotFoundError } from '../../error/index.js';
+let FunctionCallbackRegisterImpl = class FunctionCallbackRegisterImpl {
+    constructor() {
+        this.functionCallbacks = new Map();
+    }
+    register(functionCallback) {
+        this.functionCallbacks.set(functionCallback.name, functionCallback);
+    }
+    unregister(functionName) {
+        this.functionCallbacks.delete(functionName);
+    }
+    call(functionName, functionArguments, toolContext) {
+        const functionCallback = this.functionCallbacks.get(functionName);
+        if (functionCallback) {
+            return functionCallback.call(functionArguments, toolContext);
+        }
+        throw new NotFoundError(`Function ${functionName} not found`);
+    }
+    resolve(functionNames) {
+        const functionCallbacks = [];
+        new Set(functionNames).forEach(functionName => {
+            const functionCallback = this.functionCallbacks.get(functionName);
+            if (functionCallback) {
+                functionCallbacks.push(functionCallback);
+            }
+            else {
+                throw new NotFoundError(`No function callback found for name: ${functionName}`);
+            }
+        });
+        return functionCallbacks;
+    }
+};
+FunctionCallbackRegisterImpl = __decorate([
+    Component(FunctionCallbackRegister)
+], FunctionCallbackRegisterImpl);
+export { FunctionCallbackRegisterImpl };
+//# sourceMappingURL=function-callback-register.js.map

package/esm/common/model/function/function-callback-register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-callback-register.js","sourceRoot":"","sources":["../../../../src/common/model/function/function-callback-register.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAoB,wBAAwB,EAAe,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGrC,IAAM,4BAA4B,GAAlC,MAAM,4BAA4B;IAAlC;QAEK,sBAAiB,GAAkC,IAAI,GAAG,EAA4B,CAAC;IA8BnG,CAAC;IA5BG,QAAQ,CAAC,gBAAkC;QACvC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IACxE,CAAC;IAED,UAAU,CAAC,YAAoB;QAC3B,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC;IAED,IAAI,CAAC,YAAoB,EAAE,iBAAyB,EAAE,WAAwB;QAC1E,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAClE,IAAI,gBAAgB,EAAE,CAAC;YACnB,OAAO,gBAAgB,CAAC,IAAI,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,IAAI,aAAa,CAAC,YAAY,YAAY,YAAY,CAAC,CAAC;IAClE,CAAC;IAED,OAAO,CAAC,aAAuB;QAC3B,MAAM,iBAAiB,GAAuB,EAAE,CAAC;QACjD,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YAC1C,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAClE,IAAI,gBAAgB,EAAE,CAAC;gBACnB,iBAAiB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YAC7C,CAAC;iBAAM,CAAC;gBACJ,MAAM,IAAI,aAAa,CAAC,wCAAwC,YAAY,EAAE,CAAC,CAAC;YACpF,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,iBAAiB,CAAC;IAC7B,CAAC;CACJ,CAAA;AAhCY,4BAA4B;IADxC,SAAS,CAAC,wBAAwB,CAAC;GACvB,4BAA4B,CAgCxC"}

package/esm/common/model/function/function-protocol.d.ts

@@ -0,0 +1,75 @@
+import { ChatOptions } from '../../chat/prompt/index.js';
+export declare const FunctionCallbackRegister: unique symbol;
+export interface ToolContext extends Record<string, any> {
+}
+export declare namespace ToolContext {
+    const TOOL_CALL_HISTORY = "TOOL_CALL_HISTORY";
+}
+/**
+ * Represents a model function call handler. Implementations are registered with the
+ * Models and called on prompts that trigger the function call.
+ */
+export interface FunctionCallback {
+    /**
+     * The Function name. Unique within the model.
+     */
+    readonly name: string;
+    /**
+     * The function description. This description is used by the model do
+     * decide if the function should be called or not.
+     */
+    readonly description: string;
+    /**
+     * The JSON schema of the function input type.
+     */
+    readonly inputTypeSchema: string;
+    /**
+     * Called when a model detects and triggers a function call. The model is responsible
+     * to pass the function arguments in the pre-configured JSON schema format.
+     * @param functionArguments JSON string with the function arguments to be passed to the
+     * function. The arguments are defined as JSON schema usually registered with the the
+     * model.
+     * @param toolContext Optional tool context to be passed to the function call.
+     * @return String containing the function call response.
+     */
+    call(functionArguments: string, toolContext?: ToolContext): Promise<string>;
+}
+export interface FunctionCallingOptions extends ChatOptions {
+    /**
+     * Function Callbacks to be registered with the ChatClient. For Prompt Options the
+     * functionCallbacks are automatically enabled for the duration of the prompt
+     * execution. For Default Options the FunctionCallbacks are registered but disabled by
+     * default. You have to use "functions" property to list the function names from the
+     * ChatClient registry to be used in the chat completion requests.
+     */
+    functionCallbacks: FunctionCallback[];
+    /**
+     * List of function names from the ChatClient registry to be used in the next
+     * chat completion requests.
+     */
+    functions: Set<string>;
+    proxyToolCalls?: boolean;
+    toolContext?: ToolContext;
+}
+export declare namespace FunctionCallingOptions {
+    function is(obj: any): obj is FunctionCallingOptions;
+    function getEnabledFunctionsToCall(runtimeFunctionOptions: FunctionCallingOptions): Set<string>;
+    /**
+     * Check if the proxyToolCalls is enabled for the given prompt or the default tool
+     * call options. The prompt options take precedence over the default options. When the
+     * proxyToolCalls is enabled the ChatModel implementation will pass the proxyToolCalls to the
+     * function call.
+     * @param chatOptions the chat options to check.
+     * @param defaultOptions the default tool call options to check.
+     * @return true if the proxyToolCalls is enabled, false otherwise.
+     */
+    function isProxyToolCalls(chatOptions: ChatOptions, defaultOptions: FunctionCallingOptions): boolean;
+}
+export interface FunctionCallbackRegister {
+    resolve(functionNames: string[]): FunctionCallback[];
+    register(functionCallback: FunctionCallback): void;
+    unregister(functionName: string): void;
+    call(functionName: string, functionArguments: string, toolContext: ToolContext): Promise<string>;
+}
+export interface PortableFunctionCallingOptions extends FunctionCallingOptions, ChatOptions {
+}

package/esm/common/model/function/function-protocol.js

@@ -0,0 +1,49 @@
+export const FunctionCallbackRegister = Symbol('FunctionCallbackRegister');
+export var ToolContext;
+(function (ToolContext) {
+    ToolContext.TOOL_CALL_HISTORY = 'TOOL_CALL_HISTORY';
+})(ToolContext || (ToolContext = {}));
+export var FunctionCallingOptions;
+(function (FunctionCallingOptions) {
+    function is(obj) {
+        return obj && obj.functionCallbacks !== undefined && obj.functions !== undefined;
+    }
+    FunctionCallingOptions.is = is;
+    function getEnabledFunctionsToCall(runtimeFunctionOptions) {
+        const enabledFunctionsToCall = new Set();
+        if (runtimeFunctionOptions) {
+            // Add the explicitly enabled functions.
+            if (runtimeFunctionOptions.functions) {
+                runtimeFunctionOptions.functions.forEach(fn => {
+                    enabledFunctionsToCall.add(fn);
+                });
+            }
+            if (runtimeFunctionOptions.functionCallbacks) {
+                runtimeFunctionOptions.functionCallbacks.forEach(functionCallback => {
+                    // Automatically enable the function, usually from prompt callback.
+                    enabledFunctionsToCall.add(functionCallback.name);
+                });
+            }
+        }
+        return enabledFunctionsToCall;
+    }
+    FunctionCallingOptions.getEnabledFunctionsToCall = getEnabledFunctionsToCall;
+    /**
+     * Check if the proxyToolCalls is enabled for the given prompt or the default tool
+     * call options. The prompt options take precedence over the default options. When the
+     * proxyToolCalls is enabled the ChatModel implementation will pass the proxyToolCalls to the
+     * function call.
+     * @param chatOptions the chat options to check.
+     * @param defaultOptions the default tool call options to check.
+     * @return true if the proxyToolCalls is enabled, false otherwise.
+     */
+    function isProxyToolCalls(chatOptions, defaultOptions) {
+        var _a;
+        if (FunctionCallingOptions.is(chatOptions) && chatOptions.proxyToolCalls !== undefined) {
+            return chatOptions.proxyToolCalls;
+        }
+        return (_a = defaultOptions.proxyToolCalls) !== null && _a !== void 0 ? _a : false;
+    }
+    FunctionCallingOptions.isProxyToolCalls = isProxyToolCalls;
+})(FunctionCallingOptions || (FunctionCallingOptions = {}));
+//# sourceMappingURL=function-protocol.js.map

package/esm/common/model/function/function-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-protocol.js","sourceRoot":"","sources":["../../../../src/common/model/function/function-protocol.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC;AAI3E,MAAM,KAAW,WAAW,CAE3B;AAFD,WAAiB,WAAW;IACX,6BAAiB,GAAG,mBAAmB,CAAC;AACzD,CAAC,EAFgB,WAAW,KAAX,WAAW,QAE3B;AA2DD,MAAM,KAAW,sBAAsB,CAyCtC;AAzCD,WAAiB,sBAAsB;IACnC,SAAgB,EAAE,CAAC,GAAQ;QACvB,OAAO,GAAG,IAAI,GAAG,CAAC,iBAAiB,KAAK,SAAS,IAAI,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC;IACrF,CAAC;IAFe,uBAAA,EAAE,KAEjB,CAAA;IAED,SAAgB,yBAAyB,CAAC,sBAA8C;QACpF,MAAM,sBAAsB,GAAG,IAAI,GAAG,EAAU,CAAC;QACjD,IAAI,sBAAsB,EAAE,CAAC;YACzB,wCAAwC;YACxC,IAAI,sBAAsB,CAAC,SAAS,EAAE,CAAC;gBACnC,sBAAsB,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;oBAC1C,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACnC,CAAC,CAAC,CAAC;YACP,CAAC;YAED,IAAI,sBAAsB,CAAC,iBAAiB,EAAE,CAAC;gBAC3C,sBAAsB,CAAC,iBAAiB,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE;oBAChE,mEAAmE;oBACnE,sBAAsB,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;gBACtD,CAAC,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QACD,OAAO,sBAAsB,CAAC;IAClC,CAAC;IAlBe,uBAAA,yBAAyB,4BAkBxC,CAAA;IAED;;;;;;;;OAQG;IACH,SAAgB,gBAAgB,CAAC,WAAwB,EAAE,cAAsC;;QAC7F,IAAI,sBAAsB,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACrF,OAAO,WAAW,CAAC,cAAc,CAAC;QACtC,CAAC;QACD,aAAO,cAAc,CAAC,cAAc,mCAAI,KAAK,CAAC;IAClD,CAAC;IALe,uBAAA,gBAAgB,mBAK/B,CAAA;AAEL,CAAC,EAzCgB,sBAAsB,KAAtB,sBAAsB,QAyCtC"}

package/esm/common/model/function/index.d.ts

@@ -0,0 +1,2 @@
+export * from './function-protocol.js';
+export * from './function-callback-register.js';

package/esm/common/model/function/index.js

@@ -0,0 +1,3 @@
+export * from './function-protocol.js';
+export * from './function-callback-register.js';
+//# sourceMappingURL=index.js.map

package/esm/common/model/function/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/common/model/function/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC"}

package/esm/common/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from './model-protocol.js';
+export * from './function/index.js';

package/esm/common/model/index.js

@@ -0,0 +1,3 @@
+export * from './model-protocol.js';
+export * from './function/index.js';
+//# sourceMappingURL=index.js.map

package/esm/common/model/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/model/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/esm/common/model/model-protocol.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Provides a set of interfaces and classes for a generic API designed to interact with
+ * various AI models. This package includes interfaces for handling AI model calls,
+ * requests, responses, results, and associated metadata. It is designed to offer a
+ * flexible and adaptable framework for interacting with different types of AI models,
+ * abstracting the complexities involved in model invocation and result processing. The
+ * use of generics enhances the API's capability to work with a wide range of models,
+ * ensuring a broad applicability across diverse AI scenarios.
+ */
+import { Media } from '../chat/index.js';
+import { Observable } from 'rxjs';
+export declare const Model: unique symbol;
+export declare const StreamingModel: unique symbol;
+/**
+ * Interface representing the customizable options for AI model interactions. This marker
+ * interface allows for the specification of various settings and parameters that can
+ * influence the behavior and output of AI models. It is designed to provide flexibility
+ * and adaptability in different AI scenarios, ensuring that the AI models can be
+ * fine-tuned according to specific requirements.
+ */
+export interface ModelOptions {
+    signal?: AbortSignal;
+    httpHeaders?: Record<string, string>;
+}
+/**
+ * Interface representing metadata associated with the results of an AI model. This
+ * interface focuses on providing additional context and insights into the results
+ * generated by AI models. It could include information like computation time, model
+ * version, or other relevant details that enhance understanding and management of AI
+ * model outputs in various applications.
+ */
+export interface ResultMetadata {
+}
+/**
+ * Interface representing metadata associated with an AI model's response. This interface
+ * is designed to provide additional information about the generative response from an AI
+ * model, including processing details and model-specific data. It serves as a value
+ * object within the core domain, enhancing the understanding and management of AI model
+ * responses in various applications.
+ */
+export interface ResponseMetadata {
+    readonly extra: Record<string, any>;
+}
+/**
+ * This interface provides methods to access the main output of the AI model and the
+ * metadata associated with this result. It is designed to offer a standardized and
+ * comprehensive way to handle and interpret the outputs generated by AI models, catering
+ * to diverse AI applications and use cases.
+ *
+ * @param <T> the type of the output generated by the AI model
+ */
+export interface ModelResult<T> {
+    /**
+     * Retrieves the output generated by the AI model.
+     * The output generated by the AI model
+     */
+    readonly output: T;
+    /**
+     * Retrieves the metadata associated with the result of an AI model.
+     * The metadata associated with the result
+     */
+    readonly metadata: ResultMetadata;
+}
+/**
+ * Interface representing a request to an AI model. This interface encapsulates the
+ * necessary information required to interact with an AI model, including instructions or
+ * inputs (of generic type T) and additional model options. It provides a standardized way
+ * to send requests to AI models, ensuring that all necessary details are included and can
+ * be easily managed.
+ *
+ * @param <T> the type of instructions or input required by the AI model
+ */
+export interface ModelRequest<T> {
+    /**
+     * Retrieves the instructions or input required by the AI model.
+     * The instructions or input required by the AI model
+     */
+    readonly instructions: T;
+    /**
+     * Retrieves the customizable options for AI model interactions.
+     * The customizable options for AI model interactions
+     */
+    readonly options: ModelOptions;
+}
+/**
+ * Interface representing the response received from an AI model. This interface provides
+ * methods to access the main result or a list of results generated by the AI model, along
+ * with the response metadata. It serves as a standardized way to encapsulate and manage
+ * the output from AI models, ensuring easy retrieval and processing of the generated
+ * information.
+ *
+ * @param <T> the type of the result(s) provided by the AI model
+ */
+export interface ModelResponse<T extends ModelResult<any>> {
+    /**
+     * Retrieves the result of the AI model.
+     * The result generated by the AI model
+     */
+    readonly result: T;
+    /**
+     * Retrieves the list of generated outputs by the AI model.
+     * The list of generated outputs
+     */
+    readonly results: T[];
+    /**
+     * Retrieves the response metadata associated with the AI model's response.
+     * The response metadata
+     */
+    readonly metadata: ResponseMetadata;
+}
+/**
+ * The Model interface provides a generic API for invoking AI models. It is designed
+ * to handle the interaction with various types of AI models by abstracting the process of
+ * sending requests and receiving responses. The interface uses Java generics to
+ * accommodate different types of requests and responses, enhancing flexibility and
+ * adaptability across different AI model implementations.
+ *
+ * @param <TReq> the generic type of the request to the AI model
+ * @param <TRes> the generic type of the response from the AI model
+ */
+export interface Model<TReq extends ModelRequest<any>, TRes extends ModelResponse<any>> {
+    /**
+     * Executes a method call to the AI model.
+     * @param request the request object to be sent to the AI model
+     * @return the response from the AI model
+     */
+    call(request: TReq): Promise<TRes>;
+}
+/**
+ * Data structure that contains content and metadata.
+ */
+export interface Content {
+    /**
+     * The content of the message.
+     */
+    content: string;
+    /**
+     * The media associated with the content.
+     */
+    media: Media[];
+    /**
+     * The metadata associated with the content.
+     */
+    metadata: Record<string, any>;
+}
+/**
+ * The StreamingModel interface provides a generic API for invoking an AI models
+ * with streaming response. It abstracts the process of sending requests and receiving a
+ * streaming responses. The interface uses Java generics to accommodate different types of
+ * requests and responses, enhancing flexibility and adaptability across different AI
+ * model implementations.
+ *
+ * @param <TReq> the generic type of the request to the AI model
+ * @param <TResChunk> the generic type of a single item in the streaming response from the
+ * AI model
+ */
+export interface StreamingModel<TReq extends ModelRequest<any>, TResChunk extends ModelResponse<any>> {
+    /**
+     * Executes a method call to the AI model.
+     * @param request the request object to be sent to the AI model
+     * @return the streaming response from the AI model
+     */
+    stream(request: TReq): Promise<Observable<TResChunk>>;
+}

package/esm/common/model/model-protocol.js

@@ -0,0 +1,12 @@
+/**
+ * Provides a set of interfaces and classes for a generic API designed to interact with
+ * various AI models. This package includes interfaces for handling AI model calls,
+ * requests, responses, results, and associated metadata. It is designed to offer a
+ * flexible and adaptable framework for interacting with different types of AI models,
+ * abstracting the complexities involved in model invocation and result processing. The
+ * use of generics enhances the API's capability to work with a wide range of models,
+ * ensuring a broad applicability across diverse AI scenarios.
+ */
+export const Model = Symbol('Model');
+export const StreamingModel = Symbol('StreamingModel');
+//# sourceMappingURL=model-protocol.js.map

package/esm/common/model/model-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-protocol.js","sourceRoot":"","sources":["../../../src/common/model/model-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AACrC,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC"}

package/esm/common/module.d.ts

@@ -0,0 +1,3 @@
+import './index.js';
+declare const _default: import("inversify").interfaces.ContainerModule;
+export default _default;