@agentica/core 0.20.0 → 0.22.0

package/lib/functional/assertMcpController.js

@@ -71,7 +71,6 @@ function assertMcpController(props) {
         const { ListToolsResultSchema } = yield Promise.resolve().then(() => __importStar(require("@modelcontextprotocol/sdk/types.js")));
         // get list of tools
         const { tools } = yield props.client.request({ method: "tools/list" }, ListToolsResultSchema);
-        // eslint-disable-next-line ts/no-unsafe-assignment, ts/no-unsafe-call, ts/no-unsafe-member-access
         const application = openapi_1.McpLlm.application({
             model: props.model,
             tools: (() => { const _io0 = input => "string" === typeof input.name && input.name.length <= 64 && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.inputSchema && null !== input.inputSchema && _iu1(input.inputSchema)); const _io1 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && "object" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))) && (undefined === input.$defs || "object" === typeof input.$defs && null !== input.$defs && false === Array.isArray(input.$defs) && _io2(input.$defs)); const _io2 = input => Object.keys(input).every(key => {
@@ -1693,7 +1692,6 @@ function assertMcpController(props) {
             protocol: "mcp",
             name: props.name,
             client: props.client,
-            // eslint-disable-next-line ts/no-unsafe-assignment
             application,
         };
     });

package/lib/functional/assertMcpController.js.map

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

package/lib/histories/AgenticaHistory.d.ts

@@ -4,7 +4,8 @@ import type { AgenticaDescribeHistory } from "./AgenticaDescribeHistory";
 import type { AgenticaExecuteHistory } from "./AgenticaExecuteHistory";
 import type { AgenticaSelectHistory } from "./AgenticaSelectHistory";
 import type { AgenticaTextHistory } from "./AgenticaTextHistory";
-export type AgenticaHistory<Model extends ILlmSchema.Model> = AgenticaCancelHistory<Model> | AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaSelectHistory<Model> | AgenticaTextHistory;
+import type { AgenticaUserInputHistory } from "./AgenticaUserInputHistory";
+export type AgenticaHistory<Model extends ILlmSchema.Model> = AgenticaCancelHistory<Model> | AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaSelectHistory<Model> | AgenticaTextHistory | AgenticaUserInputHistory;
 export declare namespace AgenticaHistory {
     type Type = AgenticaHistory<any>["type"];
     interface Mapper<Model extends ILlmSchema.Model> {
@@ -13,5 +14,6 @@ export declare namespace AgenticaHistory {
         execute: AgenticaExecuteHistory<Model>;
         select: AgenticaSelectHistory<Model>;
         text: AgenticaTextHistory;
+        user_input: AgenticaUserInputHistory;
     }
 }

package/lib/histories/AgenticaTextHistory.d.ts

@@ -1,6 +1,6 @@
 import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
 import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
-export interface AgenticaTextHistory<Role extends "assistant" | "user" = "assistant" | "user"> extends AgenticaHistoryBase<"text", IAgenticaHistoryJson.IText> {
-    role: Role;
+export interface AgenticaTextHistory extends AgenticaHistoryBase<"text", IAgenticaHistoryJson.IText> {
+    role: "assistant";
     text: string;
 }

package/lib/histories/AgenticaUserInputHistory.d.ts

@@ -0,0 +1,80 @@
+import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
+import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
+export interface AgenticaUserInputHistory extends AgenticaHistoryBase<"user_input", IAgenticaHistoryJson.IUserInput> {
+    role: "user";
+    contents: Array<AgenticaUserInputHistory.Contents>;
+}
+export declare namespace AgenticaUserInputHistory {
+    type Contents = Contents.File | Contents.Image | Contents.InputAudio | Contents.Text;
+    namespace Contents {
+        interface ContentsBase<Type extends string> {
+            /**
+             * The type of the content part.
+             */
+            type: Type;
+        }
+        /**
+         * Learn about
+         * [text inputs](https://platform.openai.com/docs/guides/text-generation).
+         */
+        export interface Text extends ContentsBase<"text"> {
+            /**
+             * The text content.
+             */
+            text: string;
+        }
+        /**
+         * Learn about [image inputs](https://platform.openai.com/docs/guides/vision).
+         */
+        export interface Image extends ContentsBase<"image_url"> {
+            image_url: {
+                /**
+                 * Either a URL of the image or the base64 encoded image data.
+                 */
+                url: string;
+                /**
+                 * Specifies the detail level of the image. Learn more in the
+                 * [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
+                 */
+                detail?: "auto" | "high" | "low";
+            };
+        }
+        /**
+         * Learn about [audio inputs](https://platform.openai.com/docs/guides/audio).
+         */
+        export interface InputAudio extends ContentsBase<"input_audio"> {
+            input_audio: {
+                /**
+                 * Base64 encoded audio data.
+                 */
+                data: string;
+                /**
+                 * The format of the encoded audio data. Currently supports "wav" and "mp3".
+                 */
+                format: "wav" | "mp3";
+            };
+        }
+        /**
+         * Learn about [file inputs](https://platform.openai.com/docs/guides/text) for text
+         * generation.
+         */
+        export interface File extends ContentsBase<"file"> {
+            file: {
+                /**
+                 * The base64 encoded file data, used when passing the file to the model as a
+                 * string.
+                 */
+                file_data?: string;
+                /**
+                 * The ID of an uploaded file to use as input.
+                 */
+                file_id?: string;
+                /**
+                 * The name of the file, used when passing the file to the model as a string.
+                 */
+                filename?: string;
+            };
+        }
+        export {};
+    }
+}

package/lib/histories/AgenticaUserInputHistory.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaUserInputHistory.js.map

package/lib/histories/AgenticaUserInputHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserInputHistory.js","sourceRoot":"","sources":["../../src/histories/AgenticaUserInputHistory.ts"],"names":[],"mappings":""}

package/lib/histories/MicroAgenticaHistory.d.ts

@@ -2,7 +2,8 @@ import type { ILlmSchema } from "@samchon/openapi";
 import type { AgenticaDescribeHistory } from "./AgenticaDescribeHistory";
 import type { AgenticaExecuteHistory } from "./AgenticaExecuteHistory";
 import type { AgenticaTextHistory } from "./AgenticaTextHistory";
-export type MicroAgenticaHistory<Model extends ILlmSchema.Model> = AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaTextHistory;
+import type { AgenticaUserInputHistory } from "./AgenticaUserInputHistory";
+export type MicroAgenticaHistory<Model extends ILlmSchema.Model> = AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaTextHistory | AgenticaUserInputHistory;
 export declare namespace MicroAgenticaHistory {
     type Type = MicroAgenticaHistory<any>["type"];
     interface Mapper<Model extends ILlmSchema.Model> {

package/lib/index.mjs

@@ -273,12 +273,14 @@ const AgenticaTokenUsageAggregator = {
 function decodeHistory(history) {
     if (history.type === "describe") {
         return [];
-    } else if (history.type === "text") {
+    }
+    if (history.type === "text") {
         return [ {
             role: history.role,
             content: history.text
         } ];
-    } else if (history.type === "select" || history.type === "cancel") {
+    }
+    if (history.type === "select" || history.type === "cancel") {
         return [ {
             role: "assistant",
             tool_calls: [ {
@@ -300,44 +302,65 @@ function decodeHistory(history) {
             content: ""
         } ];
     }
-    return [ {
-        role: "assistant",
-        tool_calls: [ {
-            type: "function",
-            id: history.id,
-            function: {
-                name: history.operation.name,
-                arguments: JSON.stringify(history.arguments)
-            }
-        } ]
-    }, {
-        role: "tool",
-        tool_call_id: history.id,
-        content: JSON.stringify({
-            function: {
-                protocol: history.operation.protocol,
-                description: history.operation.function.description,
-                parameters: history.operation.function.parameters,
-                output: history.operation.function.output,
+    if (history.type === "execute") {
+        return [ {
+            role: "assistant",
+            tool_calls: [ {
+                type: "function",
+                id: history.id,
+                function: {
+                    name: history.operation.name,
+                    arguments: JSON.stringify(history.arguments)
+                }
+            } ]
+        }, {
+            role: "tool",
+            tool_call_id: history.id,
+            content: JSON.stringify({
+                function: {
+                    protocol: history.operation.protocol,
+                    description: history.operation.function.description,
+                    parameters: history.operation.function.parameters,
+                    output: history.operation.function.output,
+                    ...history.operation.protocol === "http" ? {
+                        method: history.operation.function.method,
+                        path: history.operation.function.path
+                    } : {}
+                },
                 ...history.operation.protocol === "http" ? {
-                    method: history.operation.function.method,
-                    path: history.operation.function.path
-                } : {}
-            },
-            ...history.operation.protocol === "http" ? {
-                status: history.value.status,
-                data: history.value.body
-            } : {
-                value: history.value
-            }
+                    status: history.value.status,
+                    data: history.value.body
+                } : {
+                    value: history.value
+                }
+            })
+        } ];
+    }
+    if (history.type === "user_input") {
+        return [ {
+            role: "user",
+            content: history.contents
+        } ];
+    }
+    throw new Error("Invalid history type");
+}
+
+function createUserInputHistory(props) {
+    return {
+        type: "user_input",
+        role: "user",
+        contents: props.contents,
+        toJSON: () => ({
+            type: "user_input",
+            contents: props.contents
         })
-    } ];
+    };
 }
 
 function createTextHistory(props) {
     const prompt = {
         type: "text",
-        role: props.role,
+        role: "assistant",
         text: props.text
     };
     return {
@@ -414,6 +437,22 @@ function createInitializeEvent() {
     };
 }
 
+function createUserInputEvent(props) {
+    return {
+        type: "user_input",
+        role: "user",
+        contents: props.contents,
+        join: async () => props.contents,
+        toJSON: () => ({
+            type: "user_input",
+            contents: props.contents
+        }),
+        toHistory: () => createUserInputHistory({
+            contents: props.contents
+        })
+    };
+}
+
 function createSelectEvent(props) {
     return {
         type: "select",
@@ -493,22 +532,22 @@ function createExecuteEvent(props) {
 function createTextEvent(props) {
     return {
         type: "text",
-        role: props.role,
+        role: "assistant",
         stream: props.stream,
         join: props.join,
         toJSON: () => ({
             type: "text",
-            role: props.role,
+            role: "assistant",
             done: props.done(),
             text: props.get()
         }),
         toHistory: () => ({
             type: "text",
-            role: props.role,
+            role: "assistant",
             text: props.get(),
             toJSON: () => ({
                 type: "text",
-                role: props.role,
+                role: "assistant",
                 text: props.get()
             })
         })
@@ -560,6 +599,40 @@ function createResponseEvent(props) {
     };
 }
 
+function createOperationSelection(props) {
+    return {
+        operation: props.operation,
+        reason: props.reason,
+        toJSON: () => ({
+            operation: props.operation.toJSON(),
+            reason: props.reason
+        })
+    };
+}
+
+var index$2 = Object.freeze({
+    __proto__: null,
+    createCallEvent,
+    createCancelEvent,
+    createCancelHistory,
+    createDescribeEvent,
+    createDescribeHistory,
+    createExecuteEvent,
+    createExecuteHistory,
+    createInitializeEvent,
+    createOperationSelection,
+    createRequestEvent,
+    createResponseEvent,
+    createSelectEvent,
+    createSelectHistory,
+    createTextEvent,
+    createTextHistory,
+    createUserInputEvent,
+    createUserInputHistory,
+    createValidateEvent,
+    decodeHistory
+});
+
 var AgenticaConstant;
 
 (function(AgenticaConstant) {
@@ -617,17 +690,6 @@ function isAgenticaContext(ctx) {
     return typeof ctx.initialize === "function";
 }
 
-function createOperationSelection(props) {
-    return {
-        operation: props.operation,
-        reason: props.reason,
-        toJSON: () => ({
-            operation: props.operation.toJSON(),
-            reason: props.reason
-        })
-    };
-}
-
 var ByteArrayUtil;
 
 (function(ByteArrayUtil) {
@@ -1251,7 +1313,7 @@ async function call(ctx, operations) {
             content: AgenticaDefaultPrompt.write(ctx.config)
         }, ...ctx.histories.map(decodeHistory).flat(), {
             role: "user",
-            content: ctx.prompt.text
+            content: ctx.prompt.contents
         }, ...ctx.config?.systemPrompt?.execute === null ? [] : [ {
             role: "system",
             content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
@@ -1323,11 +1385,9 @@ async function call(ctx, operations) {
         if (choice.message.role === "assistant" && choice.message.content != null && choice.message.content.length !== 0) {
             closures.push((async () => {
                 const value = createTextHistory({
-                    role: "assistant",
                     text: choice.message.content
                 });
                 ctx.dispatch(createTextEvent({
-                    role: "assistant",
                     get: () => value.text,
                     done: () => true,
                     stream: toAsyncGenerator(value.text),
@@ -1528,7 +1588,7 @@ async function correct(ctx, call, retry, error) {
             content: AgenticaDefaultPrompt.write(ctx.config)
         }, ...ctx.histories.map(decodeHistory).flat(), {
             role: "user",
-            content: ctx.prompt.text
+            content: ctx.prompt.contents
         }, ...ctx.config?.systemPrompt?.execute === null ? [] : [ {
             role: "system",
             content: ctx.config?.systemPrompt?.execute?.(ctx.histories) ?? AgenticaSystemPrompt.EXECUTE
@@ -1759,7 +1819,7 @@ async function step$1(ctx, operations, retry, failures) {
             }))))
         }, ...ctx.histories.map(decodeHistory).flat(), {
             role: "user",
-            content: ctx.prompt.text
+            content: ctx.prompt.contents
         }, {
             role: "system",
             content: ctx.config?.systemPrompt?.cancel?.(ctx.histories) ?? AgenticaSystemPrompt.CANCEL
@@ -3756,7 +3816,7 @@ async function initialize(ctx) {
             content: AgenticaDefaultPrompt.write(ctx.config)
         }, ...ctx.histories.map(decodeHistory).flat(), {
             role: "user",
-            content: ctx.prompt.text
+            content: ctx.prompt.contents
         }, {
             role: "system",
             content: ctx.config?.systemPrompt?.initialize?.(ctx.histories) ?? AgenticaSystemPrompt.INITIALIZE
@@ -3796,7 +3856,6 @@ async function initialize(ctx) {
                 };
                 mpsc.produce(choice.delta.content);
                 ctx.dispatch(createTextEvent({
-                    role: "assistant",
                     stream: streamDefaultReaderToAsyncGenerator(mpsc.consumer.getReader()),
                     done: () => mpsc.done(),
                     get: () => textContext[choice.index].content,
@@ -3821,7 +3880,6 @@ async function initialize(ctx) {
     for (const choice of completion.choices) {
         if (choice.message.role === "assistant" && choice.message.content != null && choice.message.content.length !== 0) {
             prompts.push(createTextHistory({
-                role: "assistant",
                 text: choice.message.content
             }));
         }
@@ -4010,7 +4068,7 @@ async function step(ctx, operations, retry, failures) {
             }))))
         }, ...ctx.histories.map(decodeHistory).flat(), {
             role: "user",
-            content: ctx.prompt.text
+            content: ctx.prompt.contents
         }, {
             role: "system",
             content: ctx.config?.systemPrompt?.select?.(ctx.histories) ?? AgenticaSystemPrompt.SELECT
@@ -4153,12 +4211,10 @@ async function step(ctx, operations, retry, failures) {
         }
         if (choice.message.role === "assistant" && choice.message.content != null && choice.message.content.length !== 0) {
             const text = createTextHistory({
-                role: "assistant",
                 text: choice.message.content
             });
             prompts.push(text);
             ctx.dispatch(createTextEvent({
-                role: "assistant",
                 stream: toAsyncGenerator(text.text),
                 join: async () => Promise.resolve(text.text),
                 done: () => true,
@@ -4194,10 +4250,10 @@ function execute(executor) {
     return async ctx => {
         const histories = [];
         if (ctx.ready() === false) {
-            if (executor?.initialize === null) {
+            if (executor?.initialize !== true && typeof executor?.initialize !== "function") {
                 await ctx.initialize();
             } else {
-                histories.push(...await (executor?.initialize ?? initialize)(ctx));
+                histories.push(...await (typeof executor?.initialize === "function" ? executor.initialize : initialize)(ctx));
                 if (ctx.ready() === false) {
                     return histories;
                 }
@@ -4214,7 +4270,9 @@ function execute(executor) {
             const prompts = await (executor?.call ?? call)(ctx, ctx.stack.map((s => s.operation)));
             histories.push(...prompts);
             const executes = prompts.filter((prompt => prompt.type === "execute"));
-            histories.push(...await (executor?.describe ?? describe)(ctx, executes));
+            if (executor?.describe !== null && executor?.describe !== false) {
+                histories.push(...await (typeof executor?.describe === "function" ? executor.describe : describe)(ctx, executes));
+            }
             if (executes.length === 0 || ctx.stack.length === 0) {
                 break;
             }
@@ -4345,23 +4403,21 @@ class Agentica {
         });
     }
     async conversate(content) {
-        const text = createTextHistory({
-            role: "user",
-            text: content
+        const prompt = createUserInputHistory({
+            contents: Array.isArray(content) ? content : typeof content === "string" ? [ {
+                type: "text",
+                text: content
+            } ] : [ content ]
         });
-        this.dispatch(createTextEvent({
-            role: "user",
-            stream: toAsyncGenerator(content),
-            done: () => true,
-            get: () => content,
-            join: async () => Promise.resolve(content)
+        this.dispatch(createUserInputEvent({
+            contents: prompt.contents
         })).catch((() => {}));
         const newbie = await this.executor_(this.getContext({
-            prompt: text,
+            prompt,
             usage: this.token_usage_
         }));
-        this.histories_.push(text, ...newbie);
-        return [ text, ...newbie ];
+        this.histories_.push(prompt, ...newbie);
+        return [ prompt, ...newbie ];
     }
     getConfig() {
         return this.props.config;
@@ -4470,27 +4526,6 @@ class Agentica {
     }
 }
 
-var index$2 = Object.freeze({
-    __proto__: null,
-    createCallEvent,
-    createCancelEvent,
-    createCancelHistory,
-    createDescribeEvent,
-    createDescribeHistory,
-    createExecuteEvent,
-    createExecuteHistory,
-    createInitializeEvent,
-    createOperationSelection,
-    createRequestEvent,
-    createResponseEvent,
-    createSelectEvent,
-    createSelectHistory,
-    createTextEvent,
-    createTextHistory,
-    createValidateEvent,
-    decodeHistory
-});
-
 function assertHttpLlmApplication(props) {
     return HttpLlm.application({
         model: props.model,
@@ -23187,16 +23222,14 @@ class MicroAgentica {
         });
     }
     async conversate(content) {
-        const talk = createTextHistory({
-            role: "user",
-            text: content
+        const talk = createUserInputHistory({
+            contents: Array.isArray(content) ? content : typeof content === "string" ? [ {
+                type: "text",
+                text: content
+            } ] : [ content ]
         });
-        this.dispatch(createTextEvent({
-            role: "user",
-            stream: toAsyncGenerator(content),
-            done: () => true,
-            get: () => content,
-            join: async () => Promise.resolve(content)
+        this.dispatch(createUserInputEvent({
+            contents: talk.contents
         })).catch((() => {}));
         const ctx = this.getContext({
             prompt: talk,
@@ -23204,7 +23237,7 @@ class MicroAgentica {
         });
         const histories = await call(ctx, this.operations_.array);
         const executes = histories.filter((p => p.type === "execute"));
-        if (executes.length) {
+        if (executes.length && ctx.config?.executor?.describe !== null && ctx.config?.executor?.describe !== false) {
             histories.push(...await describe(ctx, executes));
         }
         this.histories_.push(talk, ...histories);