@aigne/core 1.6.0 → 1.7.0

package/lib/cjs/execution-engine/message-queue.js

@@ -2,20 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageQueue = exports.UserOutputTopic = exports.UserInputTopic = void 0;
 const node_events_1 = require("node:events");
+const zod_1 = require("zod");
 const type_utils_js_1 = require("../utils/type-utils.js");
 exports.UserInputTopic = "UserInputTopic";
 exports.UserOutputTopic = "UserOutputTopic";
 class MessageQueue {
     events = new node_events_1.EventEmitter();
-    publish(topic, message) {
+    publish(topic, payload) {
+        (0, type_utils_js_1.checkArguments)("MessageQueue.publish", publishArgsSchema, {
+            topic,
+            payload,
+        });
         for (const t of (0, type_utils_js_1.orArrayToArray)(topic)) {
-            this.events.emit(t, message);
+            this.events.emit(t, payload);
         }
     }
     error(error) {
         this.events.emit("error", error);
     }
     subscribe(topic, listener) {
+        (0, type_utils_js_1.checkArguments)("MessageQueue.subscribe", subscribeArgsSchema, {
+            topic,
+            listener,
+        });
         if (!listener) {
             return new Promise((resolve, reject) => {
                 const unsubscribe1 = once(this.events, topic, (message) => {
@@ -31,6 +40,10 @@ class MessageQueue {
         return on(this.events, topic, listener);
     }
     unsubscribe(topic, listener) {
+        (0, type_utils_js_1.checkArguments)("MessageQueue.unsubscribe", unsubscribeArgsSchema, {
+            topic,
+            listener,
+        });
         this.events.off(topic, listener);
     }
 }
@@ -43,3 +56,20 @@ function once(events, event, listener) {
     events.once(event, listener);
     return () => events.off(event, listener);
 }
+const subscribeArgsSchema = zod_1.z.object({
+    topic: zod_1.z.string(),
+    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()).optional(),
+});
+const unsubscribeArgsSchema = zod_1.z.object({
+    topic: zod_1.z.string(),
+    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()),
+});
+const publishArgsSchema = zod_1.z.object({
+    topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
+    payload: zod_1.z.object({
+        role: zod_1.z.union([zod_1.z.literal("user"), zod_1.z.literal("agent")]),
+        source: zod_1.z.string().optional(),
+        message: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.unknown())]),
+        context: zod_1.z.any(),
+    }),
+});

package/lib/cjs/execution-engine/usage.d.ts

@@ -0,0 +1,11 @@
+export interface ContextUsage {
+    inputTokens: number;
+    outputTokens: number;
+    agentCalls: number;
+}
+export declare function newEmptyContextUsage(): ContextUsage;
+export interface ContextLimits {
+    maxTokens?: number;
+    maxAgentCalls?: number;
+    timeout?: number;
+}

package/lib/cjs/execution-engine/usage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newEmptyContextUsage = newEmptyContextUsage;
+function newEmptyContextUsage() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        agentCalls: 0,
+    };
+}

package/lib/cjs/loader/index.js

@@ -120,7 +120,7 @@ async function getAIGNEFilePath(path) {
     if (s.isDirectory()) {
         for (const file of AIGNE_FILE_NAME) {
             const filePath = (0, node_path_1.join)(path, file);
-            if (await (0, promises_1.exists)(filePath))
+            if ((await (0, promises_1.stat)(filePath)).isFile())
                 return filePath;
         }
     }

package/lib/cjs/models/chat-model.d.ts

@@ -75,6 +75,7 @@ export interface ChatModelOutput extends Message {
     json?: object;
     toolCalls?: ChatModelOutputToolCall[];
     usage?: ChatModelOutputUsage;
+    model?: string;
 }
 export interface ChatModelOutputToolCall {
     id: string;
@@ -85,6 +86,6 @@ export interface ChatModelOutputToolCall {
     };
 }
 export interface ChatModelOutputUsage {
-    promptTokens: number;
-    completionTokens: number;
+    inputTokens: number;
+    outputTokens: number;
 }

package/lib/cjs/models/chat-model.js

@@ -13,7 +13,7 @@ class ChatModel extends agent_js_1.Agent {
     preprocess(input, context) {
         super.preprocess(input, context);
         const { limits, usage } = context;
-        const usedTokens = usage.completionTokens + usage.promptTokens;
+        const usedTokens = usage.outputTokens + usage.inputTokens;
         if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
             throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
         }
@@ -22,8 +22,8 @@ class ChatModel extends agent_js_1.Agent {
         super.postprocess(input, output, context);
         const { usage } = output;
         if (usage) {
-            context.usage.completionTokens += usage.completionTokens;
-            context.usage.promptTokens += usage.promptTokens;
+            context.usage.outputTokens += usage.outputTokens;
+            context.usage.inputTokens += usage.inputTokens;
         }
     }
 }
@@ -102,12 +102,13 @@ const chatModelOutputToolCallSchema = zod_1.z.object({
     }),
 });
 const chatModelOutputUsageSchema = zod_1.z.object({
-    promptTokens: zod_1.z.number(),
-    completionTokens: zod_1.z.number(),
+    inputTokens: zod_1.z.number(),
+    outputTokens: zod_1.z.number(),
 });
 const chatModelOutputSchema = zod_1.z.object({
     text: zod_1.z.string().optional(),
     json: zod_1.z.record(zod_1.z.unknown()).optional(),
     toolCalls: zod_1.z.array(chatModelOutputToolCallSchema).optional(),
     usage: chatModelOutputUsageSchema.optional(),
+    model: zod_1.z.string().optional(),
 });

package/lib/cjs/models/claude-chat-model.js

@@ -81,16 +81,18 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             let text = "";
             const toolCalls = [];
             let usage;
+            let model;
             for await (const chunk of stream) {
                 if (chunk.type === "message_start") {
+                    model ??= chunk.message.model;
                     const { input_tokens, output_tokens } = chunk.message.usage;
                     usage = {
-                        promptTokens: input_tokens,
-                        completionTokens: output_tokens,
+                        inputTokens: input_tokens,
+                        outputTokens: output_tokens,
                     };
                 }
                 if (chunk.type === "message_delta" && usage) {
-                    usage.completionTokens = chunk.usage.output_tokens;
+                    usage.outputTokens = chunk.usage.output_tokens;
                 }
                 logs.push(JSON.stringify(chunk));
                 // handle streaming text
@@ -115,7 +117,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
                     call.args += chunk.delta.partial_json;
                 }
             }
-            const result = { usage, text };
+            const result = { usage, model, text };
             if (toolCalls.length) {
                 result.toolCalls = toolCalls
                     .map(({ args, ...c }) => ({
@@ -131,7 +133,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             return result;
         }
         catch (error) {
-            logger_js_1.logger.debug("Failed to process Claude stream", { error, logs });
+            logger_js_1.logger.core("Failed to process Claude stream", { error, logs });
             throw error;
         }
     }
@@ -160,9 +162,10 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             throw new Error("Json tool not found");
         return {
             json: jsonTool.input,
+            model: result.model,
             usage: {
-                promptTokens: result.usage.input_tokens,
-                completionTokens: result.usage.output_tokens,
+                inputTokens: result.usage.input_tokens,
+                outputTokens: result.usage.output_tokens,
             },
         };
     }

package/lib/cjs/models/openai-chat-model.js

@@ -78,8 +78,10 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
         let text = "";
         const toolCalls = [];
         let usage;
+        let model;
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
+            model ??= chunk.model;
             if (choice?.delta.tool_calls?.length) {
                 for (const call of choice.delta.tool_calls) {
                     toolCalls[call.index] ??= {
@@ -101,13 +103,14 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
                 text += choice.delta.content;
             if (chunk.usage) {
                 usage = {
-                    promptTokens: chunk.usage.prompt_tokens,
-                    completionTokens: chunk.usage.completion_tokens,
+                    inputTokens: chunk.usage.prompt_tokens,
+                    outputTokens: chunk.usage.completion_tokens,
                 };
             }
         }
         const result = {
             usage,
+            model,
         };
         if (input.responseFormat?.type === "json_schema" && text) {
             result.json = (0, json_schema_js_1.parseJSON)(text);

package/lib/cjs/prompt/prompt-builder.d.ts

@@ -7,7 +7,7 @@ import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
 export declare const DEFAULT_MAX_HISTORY_MESSAGES = 10;
-export declare function createMessage(message: string | object): Message;
+export declare function createMessage<I extends Message>(message: string | I): I;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;

package/lib/cjs/prompt/prompt-builder.js

@@ -12,7 +12,9 @@ const template_js_1 = require("./template.js");
 exports.MESSAGE_KEY = "$message";
 exports.DEFAULT_MAX_HISTORY_MESSAGES = 10;
 function createMessage(message) {
-    return { [exports.MESSAGE_KEY]: message };
+    return typeof message === "string"
+        ? { [exports.MESSAGE_KEY]: message }
+        : { ...message };
 }
 function getMessage(input) {
     const userInputMessage = input[exports.MESSAGE_KEY];

package/lib/cjs/utils/json-schema.js

@@ -28,8 +28,8 @@ function parseJSON(json) {
         return JSON.parse(json);
     }
     catch (error) {
-        logger_js_1.logger.debug("Failed to parse JSON", { json, error });
-        throw new Error(`Failed to parse JSON ${error.message}`);
+        logger_js_1.logger.core("Failed to parse JSON", { json, error });
+        throw error;
     }
 }
 /**

package/lib/cjs/utils/logger.d.ts

@@ -1,20 +1,8 @@
-import debug, { type Debugger } from "debug";
-import type { Ora } from "ora";
-interface DebugWithSpinner extends Debugger {
-    spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void, options?: {
-        disabled?: boolean;
-    }): Promise<T>;
-    extend: (namespace: string) => DebugWithSpinner;
-}
-declare function spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void): Promise<T>;
+import debug from "debug";
 export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: Ora | undefined;
-    base: DebugWithSpinner;
-    debug: DebugWithSpinner;
-    spinner: typeof spinner;
-    setSpinner: (spinner: Ora) => void;
+    core: debug.Debugger;
+    mcp: debug.Debugger;
 };
-export {};

package/lib/cjs/utils/logger.js

@@ -5,82 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const debug_1 = __importDefault(require("debug"));
-debug_1.default.log = (...args) => {
-    const { isSpinning } = globalSpinner ?? {};
-    if (isSpinning)
-        globalSpinner?.stop();
-    console.log(...args);
-    if (isSpinning)
-        globalSpinner?.start();
-};
-function createDebugger(namespace) {
-    const i = (0, debug_1.default)(namespace);
-    function overrideExtend(debug) {
-        const originalExtend = debug.extend;
-        debug.extend = (namespace) => {
-            const extended = originalExtend.call(debug, namespace);
-            overrideExtend(extended);
-            extended.spinner = async (promise, message, callback, options) => {
-                if (!extended.enabled || options?.disabled)
-                    return promise;
-                return spinner(promise, message, callback);
-            };
-            return extended;
-        };
-    }
-    overrideExtend(i);
-    return i;
-}
-let globalSpinner;
-const globalSpinnerTasks = [];
-async function spinner(promise, message, callback) {
-    const task = { promise, message, callback };
-    globalSpinnerTasks.push(task);
-    globalSpinner?.start(message || " ");
-    await promise
-        .then((result) => {
-        task.result = result;
-        task.status = "succeed";
-    })
-        .catch(() => {
-        task.status = "fail";
-    });
-    // Once the promise resolves or rejects, it updates the spinner status and processes
-    // all completed tasks in a Last-In-First-Out (LIFO) order.
-    for (;;) {
-        const task = globalSpinnerTasks.at(-1);
-        if (!task)
-            break;
-        // Recover spinner state for last running task
-        if (!task.status) {
-            globalSpinner?.start(task.message || " ");
-            break;
-        }
-        globalSpinnerTasks.pop();
-        if (task.message) {
-            if (task.status === "fail")
-                globalSpinner?.fail(task.message);
-            else
-                globalSpinner?.succeed(task.message);
-        }
-        else {
-            globalSpinner?.stop();
-        }
-        // NOTE: This is a workaround to make sure the spinner stops spinning before the next tick
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        if (task.status === "succeed")
-            task.callback?.(task.result);
-    }
-    return promise;
-}
-const base = createDebugger("aigne");
+const base = (0, debug_1.default)("aigne");
 exports.logger = Object.assign(debug_1.default, {
-    globalSpinner,
-    base,
-    debug: base.extend("core"),
-    spinner,
-    setSpinner: (spinner) => {
-        globalSpinner = spinner;
-        exports.logger.globalSpinner = spinner;
-    },
+    core: base.extend("core"),
+    mcp: base.extend("mcp"),
 });

package/lib/cjs/utils/mcp-utils.js

@@ -33,11 +33,7 @@ function promptFromMCPPrompt(prompt, options) {
 }
 function resourceFromMCPResource(resource, options) {
     const [uri, variables] = isResourceTemplate(resource)
-        ? [
-            resource.uriTemplate,
-            // TODO: use template.variableNames when it's available https://github.com/modelcontextprotocol/typescript-sdk/pull/188
-            new uriTemplate_js_1.UriTemplate(resource.uriTemplate).parts.flatMap((i) => (typeof i === "object" ? i.names : [])),
-        ]
+        ? [resource.uriTemplate, new uriTemplate_js_1.UriTemplate(resource.uriTemplate).variableNames]
         : [resource.uri, []];
     return new mcp_agent_js_1.MCPResource({
         ...options,

package/lib/cjs/utils/model-utils.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeUsage = mergeUsage;
 function mergeUsage(...usages) {
     return {
-        promptTokens: usages.reduce((acc, usage) => (usage ? acc + usage.promptTokens : acc), 0),
-        completionTokens: usages.reduce((acc, usage) => (usage ? acc + usage.completionTokens : acc), 0),
+        inputTokens: usages.reduce((acc, usage) => (usage ? acc + usage.inputTokens : acc), 0),
+        outputTokens: usages.reduce((acc, usage) => (usage ? acc + usage.outputTokens : acc), 0),
     };
 }

package/lib/cjs/utils/type-utils.d.ts

@@ -1,6 +1,7 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined;
+export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
 export declare function isNil(value: unknown): value is null | undefined;
 export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;

package/lib/cjs/utils/typed-event-emtter.d.ts

@@ -0,0 +1,10 @@
+type EventMap<T> = Record<keyof T, unknown[]>;
+export type Args<K, T> = K extends keyof T ? T[K] : never;
+export type Listener<K, T> = K extends keyof T ? T[K] extends unknown[] ? (...args: T[K]) => void : never : never;
+export interface TypedEventEmitter<T extends EventMap<T>, E extends EventMap<E> = T> {
+    emit<K extends keyof E>(eventName: K, ...args: Args<K, E>): boolean;
+    on<K extends keyof T>(eventName: K, listener: Listener<K, T>): this;
+    once<K extends keyof T>(eventName: K, listener: Listener<K, T>): this;
+    off<K extends keyof T>(eventName: K, listener: Listener<K, T>): this;
+}
+export {};

package/lib/cjs/utils/typed-event-emtter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dts/agents/agent.d.ts

@@ -1,3 +1,4 @@
+import { inspect } from "node:util";
 import { type ZodType } from "zod";
 import type { Context } from "../execution-engine/context.js";
 import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
@@ -15,7 +16,7 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     outputSchema?: AgentInputOutputSchema<O>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
-    disableLogging?: boolean;
+    disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
@@ -37,7 +38,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     readonly tools: Agent<Message, Message>[] & {
         [key: string]: Agent<Message, Message>;
     };
-    private disableLogging?;
+    private disableEvents?;
     /**
      * Attach agent to context:
      * - subscribe to topic and call process method when message received
@@ -50,10 +51,12 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     private checkContextStatus;
     private newDefaultContext;
     call(input: I | string, context?: Context): Promise<O>;
+    protected checkUsageAgentCalls(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
     abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
+    [inspect.custom](): string;
 }
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {

package/lib/dts/agents/ai-agent.d.ts

@@ -28,6 +28,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
     description?: string | undefined;
+    memory?: any;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
@@ -36,13 +40,13 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }, {
     description?: string | undefined;
+    memory?: any;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
@@ -51,11 +55,7 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }>;
 export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;

package/lib/dts/agents/mcp-agent.d.ts

@@ -1,4 +1,5 @@
 import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
+import { type SSEClientTransportOptions } from "@modelcontextprotocol/sdk/client/sse.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
 import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
@@ -15,6 +16,15 @@ export interface MCPAgentOptions extends AgentOptions {
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
     url: string;
+    /**
+     * Additional options to pass to the SSEClientTransport.
+     */
+    opts?: SSEClientTransportOptions;
+    /**
+     * The timeout for requests to the server, in milliseconds.
+     * @default 10000
+     */
+    timeout?: number;
     /**
      * Whether to automatically reconnect to the server if the connection is lost.
      * @default 10 set to 0 to disable automatic reconnection
@@ -44,6 +54,7 @@ export declare class MCPAgent extends Agent {
 }
 export interface ClientWithReconnectOptions {
     transportCreator?: () => PromiseOrValue<Transport>;
+    timeout?: number;
     maxReconnects?: number;
     shouldReconnect?: (error: Error) => boolean;
 }

package/lib/dts/agents/user-agent.d.ts

@@ -1,26 +1,26 @@
 import { ReadableStream } from "node:stream/web";
-import type { Context } from "../execution-engine/context.js";
-import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execution-engine/message-queue.js";
+import { type Context, type Runnable } from "../execution-engine/context.js";
+import type { MessagePayload } from "../execution-engine/message-queue.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     context: Context;
     process?: (input: I, context: Context) => PromiseOrValue<O>;
+    activeAgent?: Runnable;
 }
 export declare class UserAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: UserAgentOptions<I, O>): UserAgent<I, O>;
     constructor(options: UserAgentOptions<I, O>);
-    readonly context: Context;
-    private get ctx();
+    context: Context;
     private _process?;
+    private activeAgent?;
     call(input: string | I, context?: Context): Promise<O>;
     process(input: I, context: Context): Promise<O>;
-    publish(topic: string | string[], message: Message | string): void;
-    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
-    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
-    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    unsubscribe(topic: string, listener: MessageQueueListener): void;
+    publish: Context["publish"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
     get stream(): ReadableStream<MessagePayload & {
         topic: string;
     }>;
+    protected checkUsageAgentCalls(_context: Context): void;
 }