@agentscope-ai/agentscope 0.0.2

package/src/agent/index.ts

@@ -0,0 +1,2 @@
+export { Agent, AgentOptions, CompressionConfig } from './agent';
+export { ReplyOptions, ActingOptions, ReasoningOptions } from './interfaces';

package/src/agent/interfaces.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+
+import { ExternalExecutionResultEvent, UserConfirmResultEvent } from '../event';
+import { Msg, ToolCallBlock } from '../message';
+import { ToolChoice } from '../type';
+
+export interface ReplyOptions {
+    msgs?: Msg | Msg[];
+    event?: UserConfirmResultEvent | ExternalExecutionResultEvent;
+    structuredModel?: z.ZodObject;
+}
+
+export interface ReasoningOptions {
+    toolChoice?: ToolChoice;
+}
+
+export interface ActingOptions {
+    toolCall: ToolCallBlock;
+}
+
+export interface ObserveOptions {
+    msg?: Msg | Msg[];
+}

package/src/agent/test-compression.ts

@@ -0,0 +1,72 @@
+import * as readline from 'readline';
+
+import { Agent } from './agent';
+import { createMsg } from '../message';
+import { DashScopeChatModel } from '../model';
+import { Bash, Glob, Grep, Toolkit } from '../tool';
+
+// Enable debug logging
+process.env.DEBUG = '*';
+console.debug('Debug logging enabled');
+
+const agent = new Agent({
+    name: 'Friday',
+    sysPrompt: 'You are a helpful assistant named Friday.',
+    model: new DashScopeChatModel({
+        modelName: 'qwen3-max',
+        apiKey: process.env.DASHSCOPE_API_KEY || '',
+    }),
+    toolkit: new Toolkit({
+        tools: [Bash(), Glob(), Grep()],
+    }),
+    compressionConfig: {
+        enabled: true,
+        triggerThreshold: 2100,
+    },
+});
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+const getUserInput = (): Promise<string> => {
+    return new Promise(resolve => {
+        rl.question('User: ', answer => {
+            resolve(answer);
+        });
+    });
+};
+
+/**
+ *
+ */
+async function main() {
+    console.log('Compression test started. Type "exit" to quit.\n');
+
+    while (true) {
+        const userInput = await getUserInput();
+        if (userInput.toLowerCase() === 'exit') {
+            rl.close();
+            break;
+        } else if (userInput.toLowerCase() === '/context') {
+            console.log(JSON.stringify(agent.context, null, 2));
+            continue;
+        }
+
+        const res = agent.replyStream({
+            msgs: createMsg({
+                name: 'user',
+                content: [{ id: crypto.randomUUID(), type: 'text', text: userInput }],
+                role: 'user',
+            }),
+        });
+
+        for await (const event of res) {
+            console.log(event);
+        }
+        console.log('\n');
+    }
+}
+
+main().catch(console.error);

package/src/event/index.ts

@@ -0,0 +1,250 @@
+import { ToolCallBlock, ToolResultBlock } from '../message';
+
+export enum EventType {
+    RUN_STARTED = 'RUN_STARTED',
+    RUN_FINISHED = 'RUN_FINISHED',
+
+    MODEL_CALL_STARTED = 'MODEL_CALL_STARTED',
+    MODEL_CALL_ENDED = 'MODEL_CALL_ENDED',
+
+    TEXT_BLOCK_START = 'TEXT_BLOCK_START',
+    TEXT_BLOCK_DELTA = 'TEXT_BLOCK_DELTA',
+    TEXT_BLOCK_END = 'TEXT_BLOCK_END',
+
+    BINARY_BLOCK_START = 'BINARY_BLOCK_START',
+    BINARY_BLOCK_DELTA = 'BINARY_BLOCK_DELTA',
+    BINARY_BLOCK_END = 'BINARY_BLOCK_END',
+
+    THINKING_BLOCK_START = 'THINKING_BLOCK_START',
+    THINKING_BLOCK_DELTA = 'THINKING_BLOCK_DELTA',
+    THINKING_BLOCK_END = 'THINKING_BLOCK_END',
+
+    TOOL_CALL_START = 'TOOL_CALL_START',
+    TOOL_CALL_DELTA = 'TOOL_CALL_DELTA',
+    TOOL_CALL_END = 'TOOL_CALL_END',
+
+    TOOL_RESULT_START = 'TOOL_RESULT_START',
+    TOOL_RESULT_TEXT_DELTA = 'TOOL_RESULT_TEXT_DELTA',
+    TOOL_RESULT_BINARY_DELTA = 'TOOL_RESULT_BINARY_DELTA',
+    TOOL_RESULT_END = 'TOOL_RESULT_END',
+
+    EXCEED_MAX_ITERS = 'EXCEED_MAX_ITERS',
+
+    REQUIRE_USER_CONFIRM = 'REQUIRE_USER_CONFIRM',
+    REQUIRE_EXTERNAL_EXECUTION = 'REQUIRE_EXTERNAL_EXECUTION',
+
+    USER_CONFIRM_RESULT = 'USER_CONFIRM_RESULT',
+    EXTERNAL_EXECUTION_RESULT = 'EXTERNAL_EXECUTION_RESULT',
+}
+
+export interface EventBase {
+    id: string;
+    createdAt: string;
+}
+
+export interface RunStartedEvent extends EventBase {
+    type: EventType.RUN_STARTED;
+    sessionId: string;
+    replyId: string;
+
+    // Extra fields for AG-UI protocol
+    name: string;
+    role: 'user' | 'assistant' | 'system';
+}
+
+export interface RunFinishedEvent extends EventBase {
+    type: EventType.RUN_FINISHED;
+    sessionId: string;
+    replyId: string;
+}
+
+export interface ModelCallStartedEvent extends EventBase {
+    type: EventType.MODEL_CALL_STARTED;
+    replyId: string;
+    modelName: string;
+}
+
+export interface ModelCallEndedEvent extends EventBase {
+    type: EventType.MODEL_CALL_ENDED;
+    replyId: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+
+export interface TextBlockStartEvent extends EventBase {
+    type: EventType.TEXT_BLOCK_START;
+    blockId: string;
+    replyId: string;
+}
+
+export interface TextBlockDeltaEvent extends EventBase {
+    type: EventType.TEXT_BLOCK_DELTA;
+    replyId: string;
+    blockId: string;
+    delta: string;
+}
+
+export interface TextBlockEndEvent extends EventBase {
+    type: EventType.TEXT_BLOCK_END;
+    replyId: string;
+    blockId: string;
+}
+
+export interface BinaryBlockStartEvent extends EventBase {
+    type: EventType.BINARY_BLOCK_START;
+    replyId: string;
+    blockId: string;
+    mediaType: string;
+}
+
+export interface BinaryBlockDeltaEvent extends EventBase {
+    type: EventType.BINARY_BLOCK_DELTA;
+    replyId: string;
+    blockId: string;
+    data: string;
+    mediaType: string;
+}
+
+export interface BinaryBlockEndEvent extends EventBase {
+    type: EventType.BINARY_BLOCK_END;
+    replyId: string;
+    blockId: string;
+}
+
+export interface ThinkingBlockStartEvent extends EventBase {
+    type: EventType.THINKING_BLOCK_START;
+    replyId: string;
+    blockId: string;
+}
+
+export interface ThinkingBlockDeltaEvent extends EventBase {
+    type: EventType.THINKING_BLOCK_DELTA;
+    replyId: string;
+    blockId: string;
+    delta: string;
+}
+
+export interface ThinkingBlockEndEvent extends EventBase {
+    type: EventType.THINKING_BLOCK_END;
+    replyId: string;
+    blockId: string;
+}
+
+export interface ToolCallStartEvent extends EventBase {
+    type: EventType.TOOL_CALL_START;
+    replyId: string;
+    toolCallId: string;
+    toolCallName: string;
+}
+
+export interface ToolCallDeltaEvent extends EventBase {
+    type: EventType.TOOL_CALL_DELTA;
+    replyId: string;
+    toolCallId: string;
+    delta: string;
+}
+
+export interface ToolCallEndEvent extends EventBase {
+    type: EventType.TOOL_CALL_END;
+    replyId: string;
+    toolCallId: string;
+}
+
+export interface ToolResultStartEvent extends EventBase {
+    type: EventType.TOOL_RESULT_START;
+    replyId: string;
+    toolCallId: string;
+    toolCallName: string;
+}
+
+export interface ToolResultTextDeltaEvent extends EventBase {
+    type: EventType.TOOL_RESULT_TEXT_DELTA;
+    replyId: string;
+    toolCallId: string;
+    delta: string;
+}
+
+export interface ToolResultBinaryDeltaEvent extends EventBase {
+    type: EventType.TOOL_RESULT_BINARY_DELTA;
+    replyId: string;
+    toolCallId: string;
+    mediaType: string;
+    data?: string;
+    url?: string;
+}
+
+export interface ToolResultEndEvent extends EventBase {
+    type: EventType.TOOL_RESULT_END;
+    replyId: string;
+    toolCallId: string;
+    state: ToolResultBlock['state'];
+}
+
+export interface ExceedMaxItersEvent extends EventBase {
+    type: EventType.EXCEED_MAX_ITERS;
+
+    replyId: string;
+    agentId: string;
+    name: string;
+}
+
+export interface RequireUserConfirmEvent extends EventBase {
+    type: EventType.REQUIRE_USER_CONFIRM;
+
+    replyId: string;
+    toolCalls: ToolCallBlock[];
+}
+
+export interface RequireExternalExecutionEvent extends EventBase {
+    type: EventType.REQUIRE_EXTERNAL_EXECUTION;
+
+    replyId: string;
+    toolCalls: ToolCallBlock[];
+}
+
+export interface UserConfirmResultEvent extends EventBase {
+    type: EventType.USER_CONFIRM_RESULT;
+
+    replyId: string;
+    confirmResults: {
+        confirmed: boolean;
+        toolCall: ToolCallBlock;
+    }[];
+}
+
+export interface ExternalExecutionResultEvent extends EventBase {
+    type: EventType.EXTERNAL_EXECUTION_RESULT;
+
+    replyId: string;
+    executionResults: ToolResultBlock[];
+}
+
+export type AgentEvent =
+    // The control events for the whole run
+    | RunStartedEvent
+    | RunFinishedEvent
+    | ExceedMaxItersEvent
+    | RequireUserConfirmEvent
+    | RequireExternalExecutionEvent
+    | ModelCallStartedEvent
+    | ModelCallEndedEvent
+    // The data events for different block types
+    | TextBlockStartEvent
+    | TextBlockDeltaEvent
+    | TextBlockEndEvent
+    | BinaryBlockStartEvent
+    | BinaryBlockDeltaEvent
+    | BinaryBlockEndEvent
+    | ThinkingBlockStartEvent
+    | ThinkingBlockDeltaEvent
+    | ThinkingBlockEndEvent
+    | ToolCallStartEvent
+    | ToolCallDeltaEvent
+    | ToolCallEndEvent
+    | ToolResultStartEvent
+    | ToolResultTextDeltaEvent
+    | ToolResultBinaryDeltaEvent
+    | ToolResultEndEvent
+    // The events from the external execution or user confirmation
+    | UserConfirmResultEvent
+    | ExternalExecutionResultEvent;

package/src/formatter/base.ts

@@ -0,0 +1,133 @@
+import { Msg, TextBlock, DataBlock, createMsg } from '../message';
+
+/**
+ * Base class for message formatters.
+ */
+export abstract class FormatterBase {
+    /**
+     * Format the input message objects into the required format by the API.
+     *
+     * @param root0
+     * @param root0.msgs - An array of message objects to be formatted.
+     * @returns A promise that resolves to an array of formatted message objects.
+     */
+    abstract format({ msgs }: { msgs: Array<Msg> }): Promise<Record<string, unknown>[]>;
+
+    /**
+     * Convert the tool output to string format for the LLM APIs that only accept text input. If
+     * `promoteMultimodalToolResult` is true, the multimodal content will be promoted to be a user message with
+     * "<system-info></system-info>" tags. Otherwise, the multimodal content will be saved to a storage and a URL link
+     * will be provided in the text output.
+     *
+     * @param output - The tool output, which can be a string or an array of content blocks.
+     * @param promoteMultimodalToolResult - Whether to promote the multimodal content to the prompt messages.
+     * @returns An object containing the text output and an optional promoted message.
+     */
+    convertToolOutputToString(
+        output: string | (TextBlock | DataBlock)[],
+        promoteMultimodalToolResult: boolean | { image?: boolean; audio?: boolean; video?: boolean }
+    ) {
+        if (typeof output === 'string') return { text: output, promotedMsg: null };
+
+        let textualOutput = [];
+
+        const promotedData: { id: string; block: DataBlock }[] = [];
+
+        for (const block of output) {
+            switch (block.type) {
+                case 'text':
+                    textualOutput.push(block.text);
+                    break;
+                default:
+                    const type = block.source.mediaType.split('/')[0];
+                    if (type !== 'image' && type !== 'audio' && type !== 'video') {
+                        console.log(
+                            `Unsupported media type '${block.source.mediaType}' in tool output. Only image, audio and video are supported.`
+                        );
+                        break;
+                    }
+                    if (block.source.type === 'url') {
+                        textualOutput.push(
+                            `<system-info>One returned ${type} can be found at: ${block.source.url}</system-info>`
+                        );
+                    } else {
+                        // If we should promote the multimodal content to the prompt messages
+                        const shouldPromote =
+                            promoteMultimodalToolResult === true ||
+                            (typeof promoteMultimodalToolResult === 'object' &&
+                                promoteMultimodalToolResult[type]);
+
+                        if (shouldPromote) {
+                            // Create an ID for the multimodal content first, which should less than 10 characters
+                            const dataID = Math.random().toString(36).substring(2, 10);
+                            textualOutput.push(
+                                `<system-info>One returned ${type} is embedded with ID '${dataID}' and will be attached within '<system-info></system-info>' tags later.</system-info>`
+                            );
+
+                            // Record the promoted data
+                            promotedData.push({ id: dataID, block });
+                        } else {
+                            // TODO: save locally
+
+                            // Save to storage and provide URL link
+                            textualOutput.push(`The returned ${block.type} is stored locally.`);
+                        }
+                    }
+            }
+        }
+
+        // Attach prefix and suffix system-info tags if there are promoted blocks
+        const promotedBlocks: (TextBlock | DataBlock)[] = [];
+        promotedData.forEach(({ id, block }) => {
+            const type = block.source.mediaType.split('/')[0];
+            promotedBlocks.push({
+                id: crypto.randomUUID(),
+                type: 'text',
+                text: `<${type}_data id='${id}'>`,
+            });
+            promotedBlocks.push(block);
+            promotedBlocks.push({
+                id: crypto.randomUUID(),
+                type: 'text',
+                text: `</${type}_data>\n`,
+            });
+        });
+
+        if (promotedBlocks.length > 0) {
+            // The prefix
+            const prefix =
+                '<system-info>The multimodal contents returned from the tool call are as follows:\n';
+
+            if (promotedBlocks[0].type === 'text') {
+                promotedBlocks[0].text = `${prefix}${promotedBlocks[0].text}`;
+            } else {
+                promotedBlocks.unshift({
+                    id: crypto.randomUUID(),
+                    type: 'text',
+                    text: `${prefix}`,
+                });
+            }
+
+            // The suffix
+            const lastBlock = promotedBlocks[promotedBlocks.length - 1];
+            if (lastBlock.type === 'text') {
+                promotedBlocks[promotedBlocks.length - 1] = {
+                    id: crypto.randomUUID(),
+                    type: 'text',
+                    text: `${lastBlock.text}</system-info>`,
+                };
+            } else {
+                promotedBlocks.push({
+                    id: crypto.randomUUID(),
+                    type: 'text',
+                    text: `</system-info>`,
+                });
+            }
+        }
+
+        return {
+            text: textualOutput.join('\n'),
+            promotedMsg: createMsg({ name: 'user', content: promotedBlocks, role: 'user' }),
+        };
+    }
+}