@aigne/core 1.72.0 → 1.74.0-beta

package/lib/cjs/aigne/context.d.ts

@@ -1,220 +0,0 @@
-import type { AIGNEObserver } from "@aigne/observability-api";
-import type { Span } from "@opentelemetry/api";
-import { Emitter } from "strict-event-emitter";
-import { type Agent, type AgentHooks, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
-import type { ChatModel } from "../agents/chat-model.js";
-import type { ImageModel } from "../agents/image-model.js";
-import { UserAgent } from "../agents/user-agent.js";
-import type { Memory } from "../memory/memory.js";
-import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
-import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emitter.js";
-import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
-import type { AIGNEMetadata } from "./type.js";
-import { type ContextLimits, type ContextUsage } from "./usage.js";
-/**
- * @hidden
- */
-export interface AgentEvent {
-    parentContextId?: string;
-    contextId: string;
-    timestamp: number;
-    agent: Agent;
-}
-/**
- * @hidden
- */
-export interface ContextEventMap {
-    agentStarted: [AgentEvent & {
-        input: Message;
-        taskTitle?: string;
-    }];
-    agentSucceed: [AgentEvent & {
-        output: Message;
-    }];
-    agentFailed: [AgentEvent & {
-        error: Error;
-    }];
-}
-/**
- * @hidden
- */
-export type ContextEmitEventMap = {
-    [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
-};
-/**
- * @hidden
- */
-export interface InvokeOptions<U extends UserContext = UserContext> extends Partial<Omit<AgentInvokeOptions<U>, "context">> {
-    returnActiveAgent?: boolean;
-    returnProgressChunks?: boolean;
-    returnMetadata?: boolean;
-    disableTransfer?: boolean;
-    sourceAgent?: Agent;
-    /**
-     * Whether to create a new context for this invocation.
-     * If false, the invocation will use the current context.
-     *
-     * @default true
-     */
-    newContext?: boolean;
-    userContext?: U;
-    memories?: Pick<Memory, "content">[];
-}
-/**
- * @hidden
- */
-export interface UserContext extends Record<string, unknown> {
-    userId?: string;
-    sessionId?: string;
-}
-/**
- * @hidden
- */
-export interface Context<U extends UserContext = UserContext> extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
-    id: string;
-    parentId?: string;
-    rootId: string;
-    model?: ChatModel;
-    imageModel?: ImageModel;
-    skills?: Agent[];
-    agents: Agent[];
-    observer?: AIGNEObserver;
-    metadata?: AIGNEMetadata;
-    span?: Span;
-    usage: ContextUsage;
-    limits?: ContextLimits;
-    status?: "normal" | "timeout";
-    userContext: U;
-    hooks?: AgentHooks[];
-    memories: Pick<Memory, "content">[];
-    /**
-     * Create a user agent to consistently invoke an agent
-     * @param agent Agent to invoke
-     * @returns User agent
-     */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>): UserAgent<I, O>;
-    /**
-     * Invoke an agent with a message and return the output and the active agent
-     * @param agent Agent to invoke
-     * @param message Message to pass to the agent
-     * @param options.returnActiveAgent return the active agent
-     * @param options.streaming return a stream of the output
-     * @returns the output of the agent and the final active agent
-     */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I & Message, options: InvokeOptions & {
-        returnActiveAgent: true;
-        streaming?: false;
-    }): Promise<[O, Agent]>;
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I & Message, options: InvokeOptions & {
-        returnActiveAgent: true;
-        streaming: true;
-    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
-    /**
-     * Invoke an agent with a message
-     * @param agent Agent to invoke
-     * @param message Message to pass to the agent
-     * @returns the output of the agent
-     */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I & Message, options?: InvokeOptions & {
-        streaming?: false;
-    }): Promise<O>;
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I & Message, options: InvokeOptions & {
-        streaming: true;
-    }): Promise<AgentResponseStream<O>>;
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I & Message, options?: InvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
-    /**
-     * Publish a message to a topic, the aigne will invoke the listeners of the topic
-     * @param topic topic name, or an array of topic names
-     * @param payload message to publish
-     */
-    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message, options?: InvokeOptions): void;
-    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
-    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
-    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
-    /**
-     * Create a child context with the same configuration as the parent context.
-     * If `reset` is true, the child context will have a new state (such as: usage).
-     *
-     * @param options
-     * @param options.reset create a new context with initial state (such as: usage)
-     * @returns new context
-     */
-    newContext(options?: {
-        reset?: boolean;
-    }): Context;
-}
-/**
- * @hidden
- */
-export declare class AIGNEContext implements Context {
-    constructor(parent?: ConstructorParameters<typeof AIGNEContextShared>[0], { reset }?: {
-        reset?: boolean;
-    });
-    id: string;
-    parentId?: string;
-    rootId: string;
-    span?: Span;
-    readonly internal: AIGNEContextShared;
-    get messageQueue(): MessageQueue;
-    get model(): ChatModel | undefined;
-    get imageModel(): ImageModel<import("../agents/image-model.js").ImageModelInput, import("../agents/image-model.js").ImageModelOutput> | undefined;
-    get skills(): Agent<any, any>[] | undefined;
-    get agents(): Agent<any, any>[];
-    get observer(): AIGNEObserver | undefined;
-    get limits(): ContextLimits | undefined;
-    get status(): "normal" | "timeout";
-    get usage(): ContextUsage;
-    get userContext(): Context["userContext"];
-    set userContext(userContext: Context["userContext"]);
-    get memories(): Context["memories"];
-    set memories(memories: Context["memories"]);
-    get hooks(): AgentHooks[];
-    set hooks(hooks: AgentHooks[]);
-    newContext({ reset }?: {
-        reset?: boolean;
-    }): AIGNEContext;
-    invoke: Context["invoke"];
-    private onInvocationResult;
-    private processOptions;
-    publish: Context["publish"];
-    subscribe: Context["subscribe"];
-    unsubscribe: Context["unsubscribe"];
-    emit<K extends keyof ContextEmitEventMap>(eventName: K, ...args: Args<K, ContextEmitEventMap>): boolean;
-    private trace;
-    on<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
-    once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
-    off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
-}
-declare class AIGNEContextShared {
-    private readonly parent?;
-    constructor(parent?: (Pick<Context, "model" | "imageModel" | "agents" | "skills" | "limits" | "observer" | "metadata"> & {
-        messageQueue?: MessageQueue;
-        events?: Emitter<any>;
-        contextIds?: Set<string>;
-    }) | undefined);
-    readonly messageQueue: MessageQueue;
-    readonly events: Emitter<any>;
-    get model(): ChatModel | undefined;
-    get imageModel(): ImageModel<import("../agents/image-model.js").ImageModelInput, import("../agents/image-model.js").ImageModelOutput> | undefined;
-    get skills(): Agent<any, any>[] | undefined;
-    get agents(): Agent<any, any>[];
-    get observer(): AIGNEObserver | undefined;
-    get metadata(): AIGNEMetadata | undefined;
-    get limits(): ContextLimits | undefined;
-    usage: ContextUsage;
-    contextIds: Set<string>;
-    userContext: Context["userContext"];
-    memories: Context["memories"];
-    hooks: AgentHooks[];
-    private abortController;
-    private timer?;
-    private initTimeout;
-    get status(): "normal" | "timeout";
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, input: I & Message, context: Context, options?: InvokeOptions): AgentProcessAsyncGenerator<O & {
-        __activeAgent__: Agent;
-    }>;
-    private invokeAgent;
-}
-export {};

package/lib/cjs/aigne/context.js

@@ -1,423 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIGNEContext = void 0;
-const uuid_1 = require("@aigne/uuid");
-const api_1 = require("@opentelemetry/api");
-const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const strict_event_emitter_1 = require("strict-event-emitter");
-const zod_1 = require("zod");
-const agent_js_1 = require("../agents/agent.js");
-const types_js_1 = require("../agents/types.js");
-const user_agent_js_1 = require("../agents/user-agent.js");
-const event_stream_js_1 = require("../utils/event-stream.js");
-const logger_js_1 = require("../utils/logger.js");
-const promise_js_1 = require("../utils/promise.js");
-const stream_utils_js_1 = require("../utils/stream-utils.js");
-const type_utils_js_1 = require("../utils/type-utils.js");
-const message_queue_js_1 = require("./message-queue.js");
-const usage_js_1 = require("./usage.js");
-/**
- * @hidden
- */
-class AIGNEContext {
-    constructor(parent, { reset } = {}) {
-        const tracer = parent?.observer?.tracer;
-        if (parent instanceof AIGNEContext && !reset) {
-            this.internal = parent.internal;
-            this.parentId = parent.id;
-            this.rootId = parent.rootId;
-            if (parent.span) {
-                const parentContext = api_1.trace.setSpan(api_1.context.active(), parent.span);
-                this.span = tracer?.startSpan("childAIGNEContext", undefined, parentContext);
-            }
-            else {
-                if (parent.observer && !process.env.AIGNE_OBSERVABILITY_DISABLED) {
-                    throw new Error("parent span is not set");
-                }
-            }
-        }
-        else {
-            this.span = tracer?.startSpan("AIGNEContext");
-            this.internal = new AIGNEContextShared(parent instanceof AIGNEContext ? parent.internal : parent);
-            // 修改了 rootId 是否会之前的有影响？，之前为 this.id
-            this.rootId = this.span?.spanContext?.().traceId ?? (0, uuid_1.v7)();
-        }
-        this.id = this.span?.spanContext()?.spanId ?? (0, uuid_1.v7)();
-        this.internal.contextIds.add(this.id);
-    }
-    id;
-    parentId;
-    rootId;
-    span;
-    internal;
-    get messageQueue() {
-        return this.internal.messageQueue;
-    }
-    get model() {
-        return this.internal.model;
-    }
-    get imageModel() {
-        return this.internal.imageModel;
-    }
-    get skills() {
-        return this.internal.skills;
-    }
-    get agents() {
-        return this.internal.agents;
-    }
-    get observer() {
-        return this.internal.observer;
-    }
-    get limits() {
-        return this.internal.limits;
-    }
-    get status() {
-        return this.internal.status;
-    }
-    get usage() {
-        return this.internal.usage;
-    }
-    get userContext() {
-        return this.internal.userContext;
-    }
-    set userContext(userContext) {
-        this.internal.userContext = userContext;
-    }
-    get memories() {
-        return this.internal.memories;
-    }
-    set memories(memories) {
-        this.internal.memories = memories;
-    }
-    get hooks() {
-        return this.internal.hooks;
-    }
-    set hooks(hooks) {
-        this.internal.hooks = hooks;
-    }
-    newContext({ reset } = {}) {
-        return new AIGNEContext(this, { reset });
-    }
-    invoke = ((agent, message, options) => {
-        (0, type_utils_js_1.checkArguments)("AIGNEContext.invoke", aigneContextInvokeArgsSchema, {
-            agent,
-            message,
-            options,
-        });
-        this.processOptions(options);
-        if ((0, type_utils_js_1.isNil)(message)) {
-            return user_agent_js_1.UserAgent.from({
-                context: this,
-                activeAgent: agent,
-            });
-        }
-        const newContext = options?.newContext === false ? this : this.newContext();
-        return Promise.resolve(newContext.internal.invoke(agent, message, newContext, options)).then(async (response) => {
-            if (!options?.streaming) {
-                let { __activeAgent__: activeAgent, ...output } = await (0, stream_utils_js_1.agentResponseStreamToObject)(response);
-                output = await this.onInvocationResult(output, options);
-                if (options?.returnActiveAgent) {
-                    return [output, activeAgent];
-                }
-                return output;
-            }
-            const activeAgentPromise = (0, promise_js_1.promiseWithResolvers)();
-            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), {
-                onChunk(chunk) {
-                    if ((0, agent_js_1.isAgentResponseDelta)(chunk) && chunk.delta.json) {
-                        return {
-                            ...chunk,
-                            delta: {
-                                ...chunk.delta,
-                                json: (0, type_utils_js_1.omit)(chunk.delta.json, "__activeAgent__"),
-                            },
-                        };
-                    }
-                },
-                onResult: async (output) => {
-                    activeAgentPromise.resolve(output.__activeAgent__);
-                    return await this.onInvocationResult(output, options);
-                },
-            });
-            const finalStream = !options.returnProgressChunks
-                ? stream
-                : (0, stream_utils_js_1.mergeReadableStreams)(stream, new event_stream_js_1.AgentResponseProgressStream(newContext));
-            if (options.returnActiveAgent) {
-                return [finalStream, activeAgentPromise.promise];
-            }
-            return finalStream;
-        });
-    });
-    async onInvocationResult(output, options) {
-        if (!options?.returnMetadata) {
-            return output;
-        }
-        return {
-            ...output,
-            $meta: {
-                ...output.$meta,
-                usage: this.usage,
-            },
-        };
-    }
-    processOptions(options) {
-        if (options?.userContext) {
-            Object.assign(this.userContext, options.userContext);
-            options.userContext = undefined;
-        }
-        if (options?.memories?.length) {
-            this.memories.push(...options.memories);
-            options.memories = undefined;
-        }
-        if (options?.hooks) {
-            this.hooks.push(...(0, type_utils_js_1.flat)(options.hooks));
-            options.hooks = undefined;
-        }
-    }
-    publish = ((topic, payload, options) => {
-        this.processOptions(options);
-        const newContext = options?.newContext === false ? this : this.newContext();
-        return this.internal.messageQueue.publish(topic, {
-            ...(0, message_queue_js_1.toMessagePayload)(payload),
-            context: newContext,
-        });
-    });
-    subscribe = ((...args) => {
-        return this.internal.messageQueue.subscribe(...args);
-    });
-    unsubscribe = ((...args) => {
-        return this.internal.messageQueue.unsubscribe(...args);
-    });
-    emit(eventName, ...args) {
-        const b = {
-            ...args[0],
-            contextId: this.id,
-            parentContextId: this.parentId,
-            timestamp: Date.now(),
-        };
-        const newArgs = [b, ...args.slice(1)];
-        this.trace(eventName, args, b);
-        return this.internal.events.emit(eventName, ...newArgs);
-    }
-    async trace(eventName, args, b) {
-        if (process.env.AIGNE_OBSERVABILITY_DISABLED)
-            return;
-        const span = this.span;
-        if (!span)
-            return;
-        try {
-            switch (eventName) {
-                case "agentStarted": {
-                    const { agent, input, taskTitle } = args[0];
-                    span.updateName(agent.name);
-                    span.setAttribute("custom.trace_id", this.rootId);
-                    span.setAttribute("custom.span_id", this.id);
-                    if (this.parentId) {
-                        span.setAttribute("custom.parent_id", this.parentId);
-                    }
-                    span.setAttribute("metadata", JSON.stringify(this.internal.metadata ?? {}));
-                    span.setAttribute("custom.started_at", b.timestamp);
-                    span.setAttribute("agentTag", agent.tag ?? "UnknownAgent");
-                    if (taskTitle) {
-                        span.setAttribute("taskTitle", taskTitle);
-                    }
-                    await this.observer?.flush(span);
-                    await this.observer?.update(this.id, {
-                        input,
-                        memories: this.memories,
-                        userContext: this.userContext,
-                    });
-                    break;
-                }
-                case "agentSucceed": {
-                    const { output } = args[0];
-                    await this.observer?.update(this.id, { output });
-                    span.setStatus({ code: api_1.SpanStatusCode.OK });
-                    span.end();
-                    this.internal.contextIds.delete(this.id);
-                    break;
-                }
-                case "agentFailed": {
-                    const { error } = args[0];
-                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
-                    span.end();
-                    this.internal.contextIds.delete(this.id);
-                    break;
-                }
-            }
-        }
-        catch (err) {
-            logger_js_1.logger.error("AIGNEContext.trace observer error", { eventName, error: err });
-        }
-    }
-    on(eventName, listener) {
-        this.internal.events.on(eventName, listener);
-        return this;
-    }
-    once(eventName, listener) {
-        this.internal.events.once(eventName, listener);
-        return this;
-    }
-    off(eventName, listener) {
-        this.internal.events.off(eventName, listener);
-        return this;
-    }
-}
-exports.AIGNEContext = AIGNEContext;
-class AIGNEContextShared {
-    parent;
-    constructor(parent) {
-        this.parent = parent;
-        this.messageQueue = this.parent?.messageQueue ?? new message_queue_js_1.MessageQueue();
-        this.events = this.parent?.events ?? new strict_event_emitter_1.Emitter();
-        this.contextIds = this.parent?.contextIds ?? new Set();
-    }
-    messageQueue;
-    events;
-    get model() {
-        return this.parent?.model;
-    }
-    get imageModel() {
-        return this.parent?.imageModel;
-    }
-    get skills() {
-        return this.parent?.skills;
-    }
-    get agents() {
-        return this.parent?.agents ?? [];
-    }
-    get observer() {
-        return this.parent?.observer;
-    }
-    get metadata() {
-        return this.parent?.metadata;
-    }
-    get limits() {
-        return this.parent?.limits;
-    }
-    usage = (0, usage_js_1.newEmptyContextUsage)();
-    contextIds;
-    userContext = {};
-    memories = [];
-    hooks = [];
-    abortController = new AbortController();
-    timer;
-    initTimeout() {
-        if (this.timer)
-            return;
-        const timeout = this.limits?.timeout;
-        if (timeout) {
-            this.timer = setTimeout(() => {
-                this.abortController.abort();
-            }, timeout);
-        }
-    }
-    get status() {
-        return this.abortController.signal.aborted ? "timeout" : "normal";
-    }
-    invoke(agent, input, context, options) {
-        this.initTimeout();
-        return withAbortSignal(this.abortController.signal, new Error("AIGNEContext is timeout"), () => this.invokeAgent(agent, input, context, options));
-    }
-    async *invokeAgent(agent, input, context, options = {}) {
-        const startedAt = Date.now();
-        try {
-            let activeAgent = agent;
-            for (;;) {
-                const result = {};
-                if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
-                    for (const { onHandoff } of (0, type_utils_js_1.flat)(options.hooks, options.sourceAgent.hooks)) {
-                        if (!onHandoff)
-                            continue;
-                        await (typeof onHandoff === "function"
-                            ? onHandoff({
-                                context,
-                                source: options.sourceAgent,
-                                target: activeAgent,
-                                input,
-                            })
-                            : context.invoke(onHandoff, {
-                                source: options.sourceAgent,
-                                target: activeAgent,
-                                input,
-                            }));
-                    }
-                }
-                const stream = await activeAgent.invoke(input, {
-                    ...(0, type_utils_js_1.pick)(options, "hooks", "model", "imageModel", "caller"),
-                    context,
-                    streaming: true,
-                });
-                for await (const value of stream) {
-                    if ((0, agent_js_1.isAgentResponseDelta)(value)) {
-                        if (value.delta.json) {
-                            value.delta.json = omitExistsProperties(result, value.delta.json);
-                            Object.assign(result, value.delta.json);
-                        }
-                        delete value.delta.json?.[types_js_1.transferAgentOutputKey];
-                    }
-                    if ((0, agent_js_1.isEmptyChunk)(value))
-                        continue;
-                    yield value;
-                }
-                if (!options?.disableTransfer) {
-                    const transferToAgent = (0, types_js_1.isTransferAgentOutput)(result)
-                        ? result[types_js_1.transferAgentOutputKey].agent
-                        : undefined;
-                    if (transferToAgent) {
-                        activeAgent = transferToAgent;
-                        continue;
-                    }
-                }
-                break;
-            }
-            yield {
-                delta: {
-                    json: { __activeAgent__: activeAgent },
-                },
-            };
-        }
-        finally {
-            const endedAt = Date.now();
-            const duration = endedAt - startedAt;
-            this.usage.duration += duration;
-        }
-    }
-}
-function omitExistsProperties(result, { ...delta }) {
-    for (const [key, val] of Object.entries(delta)) {
-        if ((0, fast_deep_equal_1.default)(result[key], val))
-            delete delta[key];
-    }
-    return (0, type_utils_js_1.isEmpty)(delta) ? undefined : delta;
-}
-async function* withAbortSignal(signal, error, fn) {
-    const iterator = fn();
-    const timeoutPromise = (0, promise_js_1.promiseWithResolvers)();
-    const listener = () => {
-        timeoutPromise.reject(error);
-    };
-    signal.addEventListener("abort", listener);
-    try {
-        for (;;) {
-            const next = await Promise.race([iterator.next(), timeoutPromise.promise]);
-            if (next.done)
-                break;
-            yield next.value;
-        }
-    }
-    finally {
-        signal.removeEventListener("abort", listener);
-    }
-}
-const aigneContextInvokeArgsSchema = zod_1.z.object({
-    agent: zod_1.z.union([
-        zod_1.z.function(),
-        zod_1.z.custom((agent) => !!agent && typeof agent.invoke === "function"),
-    ]),
-    message: zod_1.z.union([zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()), zod_1.z.string()]).optional(),
-    options: zod_1.z.object({ returnActiveAgent: zod_1.z.boolean().optional() }).optional(),
-});

package/lib/cjs/aigne/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./aigne.js";
-export * from "./context.js";
-export * from "./message-queue.js";
-export * from "./usage.js";

package/lib/cjs/aigne/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./aigne.js"), exports);
-__exportStar(require("./context.js"), exports);
-__exportStar(require("./message-queue.js"), exports);
-__exportStar(require("./usage.js"), exports);