@looopy-ai/core 1.2.1 → 2.0.0

package/dist/tools/agent-tool-provider.js

@@ -0,0 +1,156 @@
+import { consumeSSEStream } from '@geee-be/sse-stream-parser';
+import { Observable } from 'rxjs';
+import z from 'zod';
+import { getLogger } from '../core';
+import { toolErrorEvent } from './tool-result-events';
+const cardSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    url: z.url(),
+    icon: z.string().optional(),
+    skills: z
+        .array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+    }))
+        .optional(),
+    auth: z
+        .object({
+        issuer: z.string(),
+        audience: z.string(),
+        scopes: z.array(z.string()),
+    })
+        .optional(),
+});
+const safeName = (name) => name.replace(/[^a-zA-Z0-9-]+/g, '-').toLowerCase();
+export class AgentToolProvider {
+    card;
+    getHeaders;
+    static fromUrl = (cardUrl, getHeaders) => {
+        return fetch(cardUrl)
+            .then((response) => response.json())
+            .then((card) => {
+            return AgentToolProvider.from(card, getHeaders);
+        });
+    };
+    static from = (card, getHeaders) => {
+        const parsed = cardSchema.parse(card);
+        return new AgentToolProvider(parsed, getHeaders);
+    };
+    agentName;
+    name;
+    tools;
+    logger;
+    constructor(card, getHeaders) {
+        this.card = card;
+        this.getHeaders = getHeaders;
+        this.agentName = safeName(card.name);
+        this.name = `agent__${this.agentName}`;
+        this.logger = getLogger({ component: 'agent-tool-provider', agentName: this.agentName });
+        this.tools = [
+            {
+                name: `${this.name}__invoke`,
+                description: `Invoke the ${card.name} agent.\n\n${card.description}` ||
+                    `Invoke the ${card.name} agent`,
+                icon: card.icon,
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'The prompt to send to the agent. This will call or invoke the agent sending this prompt as the input. This will start or continue a conversation "turn" with this agent. Example: "What is the weather today?"',
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+        ];
+    }
+    getTool(toolName) {
+        const tool = this.tools.find((t) => t.name === toolName);
+        return Promise.resolve(tool);
+    }
+    getTools() {
+        return Promise.resolve(this.tools);
+    }
+    execute(toolCall, context) {
+        this.logger.debug({ toolCallId: toolCall.id, toolName: toolCall.function.name }, 'Executing agent tool call');
+        return new Observable((subscriber) => {
+            const abortController = new AbortController();
+            const run = async () => {
+                const tool = await this.getTool(toolCall.function.name);
+                if (!tool) {
+                    this.logger.error({ toolName: toolCall.function.name }, 'Tool not found');
+                    subscriber.next(toolErrorEvent(context, toolCall, `Tool not found: ${toolCall.function.name}`));
+                    subscriber.complete();
+                    return;
+                }
+                const prompt = toolCall.function.arguments.prompt;
+                if (!prompt || typeof prompt !== 'string') {
+                    this.logger.error('Invalid tool call arguments');
+                    subscriber.next(toolErrorEvent(context, toolCall, 'Tool argument must include "prompt" and it must be a string'));
+                    subscriber.complete();
+                    return;
+                }
+                const res = await fetch(`${this.card.url}/invocations?qualifier=DEFAULT`, {
+                    method: 'POST',
+                    headers: {
+                        Accept: 'text/event-stream',
+                        'X-Amzn-Bedrock-AgentCore-Runtime-Session-Id': context.contextId,
+                        ...(await this.getHeaders?.(context)),
+                    },
+                    body: JSON.stringify({ prompt }),
+                    signal: abortController.signal,
+                });
+                if (!res.ok) {
+                    this.logger.error({ status: res.status, statusText: res.statusText }, 'Agent call failed');
+                    subscriber.next(toolErrorEvent(context, toolCall, `Agent endpoint responded with ${res.status} ${res.statusText}`));
+                    subscriber.complete();
+                    return;
+                }
+                const body = res.body;
+                if (!body) {
+                    this.logger.error('Agent response has no body');
+                    subscriber.next(toolErrorEvent(context, toolCall, 'Agent returned no response body'));
+                    subscriber.complete();
+                    return;
+                }
+                await consumeSSEStream(body, (e) => {
+                    if (subscriber.closed)
+                        return;
+                    subscriber.next({
+                        kind: e.event,
+                        parentTaskId: context.taskId,
+                        ...JSON.parse(e.data),
+                    });
+                    this.logger.debug({ event: e.event }, 'Received SSE event');
+                }, () => {
+                    if (!subscriber.closed) {
+                        const toolCompleteEvent = {
+                            kind: 'tool-complete',
+                            contextId: context.contextId,
+                            taskId: context.taskId,
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.function.name,
+                            success: true,
+                            result: 'Complete',
+                            timestamp: new Date().toISOString(),
+                        };
+                        subscriber.next(toolCompleteEvent);
+                        subscriber.complete();
+                        this.logger.debug('Tool execution complete');
+                    }
+                });
+            };
+            run().catch((err) => {
+                this.logger.error({ err }, 'Tool execution error');
+                if (!subscriber.closed) {
+                    subscriber.error(err);
+                }
+            });
+            return () => {
+                abortController.abort();
+            };
+        });
+    }
+}

package/dist/tools/client-tool-provider.d.ts

@@ -11,7 +11,7 @@ export declare class ClientToolProvider implements ToolProvider {
     private readonly onInputRequired;
     constructor(config: ClientToolConfig);
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
+    execute(toolCall: ToolCall, context: ExecutionContext): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
     getTool(name: string): Promise<ToolDefinition | undefined>;
     validateToolArguments(toolCall: ToolCall): Promise<{
         valid: boolean;

package/dist/tools/client-tool-provider.js

@@ -1,4 +1,6 @@
+import { catchError, defer, mergeMap, of } from 'rxjs';
 import { validateToolDefinitions, } from '../types/tools';
+import { toolErrorEvent, toolResultToEvents } from './tool-result-events';
 export class ClientToolProvider {
     name = 'client-tool-provider';
     tools;
@@ -25,39 +27,42 @@ export class ClientToolProvider {
     async getTools() {
         return [...this.tools];
     }
-    async execute(toolCall, context) {
-        const tool = await this.getTool(toolCall.function.name);
-        if (!tool) {
-            return {
-                toolCallId: toolCall.id,
-                toolName: toolCall.function.name,
-                success: false,
-                result: null,
-                error: `Tool ${toolCall.function.name} not found in client tools`,
-            };
-        }
-        try {
-            if (typeof toolCall.function.arguments !== 'object' || toolCall.function.arguments === null) {
+    execute(toolCall, context) {
+        return defer(async () => {
+            const tool = await this.getTool(toolCall.function.name);
+            if (!tool) {
                 return {
                     toolCallId: toolCall.id,
                     toolName: toolCall.function.name,
                     success: false,
                     result: null,
-                    error: `Invalid tool arguments: must be an object.`,
+                    error: `Tool ${toolCall.function.name} not found in client tools`,
                 };
             }
-            const result = await this.onInputRequired(toolCall, context);
-            return result;
-        }
-        catch (error) {
-            return {
-                toolCallId: toolCall.id,
-                toolName: toolCall.function.name,
-                success: false,
-                result: null,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
+            try {
+                if (typeof toolCall.function.arguments !== 'object' ||
+                    toolCall.function.arguments === null) {
+                    return {
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.function.name,
+                        success: false,
+                        result: null,
+                        error: `Invalid tool arguments: must be an object.`,
+                    };
+                }
+                const result = await this.onInputRequired(toolCall, context);
+                return result;
+            }
+            catch (error) {
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.function.name,
+                    success: false,
+                    result: null,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error)))));
     }
     async getTool(name) {
         return this.tools.find((t) => t.name === name);

package/dist/tools/index.d.ts

@@ -1,4 +1,6 @@
+export * from './agent-tool-provider';
 export * from './artifact-tools';
 export * from './client-tool-provider';
 export * from './local-tools';
 export * from './mcp-tool-provider';
+export * from './tool-result-events';

package/dist/tools/index.js

@@ -1,4 +1,6 @@
+export * from './agent-tool-provider';
 export * from './artifact-tools';
 export * from './client-tool-provider';
 export * from './local-tools';
 export * from './mcp-tool-provider';
+export * from './tool-result-events';

package/dist/tools/local-tools.js

@@ -1,4 +1,6 @@
+import { catchError, defer, mergeMap, of } from 'rxjs';
 import { z } from 'zod';
+import { toolErrorEvent, toolResultToEvents } from './tool-result-events';
 export function tool(definition) {
     return { ...definition };
 }
@@ -38,7 +40,7 @@ export function localTools(tools) {
                 parameters: zodToJsonSchema(toolDef.schema),
             };
         },
-        execute: async (toolCall, context) => {
+        execute: (toolCall, context) => defer(async () => {
             const toolDef = toolMap.get(toolCall.function.name);
             if (!toolDef) {
                 return {
@@ -80,6 +82,6 @@ export function localTools(tools) {
                     error: err.message,
                 };
             }
-        },
+        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error))))),
     };
 }

package/dist/tools/mcp-tool-provider.d.ts

@@ -1,5 +1,5 @@
 import type { AuthContext, ExecutionContext } from '../types/context';
-import type { ToolCall, ToolDefinition, ToolProvider, ToolResult } from '../types/tools';
+import type { ToolCall, ToolDefinition, ToolProvider } from '../types/tools';
 export interface MCPProviderConfig {
     serverId: string;
     serverUrl: string;
@@ -17,8 +17,7 @@ export declare class McpToolProvider implements ToolProvider {
     private ongoingRequest;
     constructor(config: MCPProviderConfig);
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
-    executeBatch(toolCalls: ToolCall[], context: ExecutionContext): Promise<ToolResult[]>;
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
+    execute(toolCall: ToolCall, context: ExecutionContext): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
     private convertMCPTool;
 }

package/dist/tools/mcp-tool-provider.js

@@ -1,4 +1,6 @@
+import { catchError, defer, mergeMap, of } from 'rxjs';
 import { MCPClient } from './mcp-client';
+import { toolErrorEvent, toolResultToEvents } from './tool-result-events';
 export const mcp = (config) => {
     return new McpToolProvider(config);
 };
@@ -22,9 +24,6 @@ export class McpToolProvider {
         const tools = await this.getTools();
         return tools.find((tool) => tool.name === toolName);
     }
-    async executeBatch(toolCalls, context) {
-        return Promise.all(toolCalls.map((call) => this.execute(call, context)));
-    }
     async getTools() {
         if (this.toolCache.size > 0 && this.cacheExpiry && Date.now() < this.cacheExpiry) {
             return Array.from(this.toolCache.values());
@@ -48,38 +47,40 @@ export class McpToolProvider {
         });
         return this.ongoingRequest;
     }
-    async execute(toolCall, context) {
-        const { name, arguments: args } = toolCall.function;
-        if (typeof args !== 'object' || args === null) {
-            return {
-                toolCallId: toolCall.id,
-                toolName: name,
-                success: false,
-                error: 'Tool arguments must be an object',
-                result: null,
-            };
-        }
-        try {
-            const response = await this.client.callTool({
-                name,
-                arguments: args,
-            }, context.authContext);
-            return {
-                toolCallId: toolCall.id,
-                toolName: name,
-                success: true,
-                result: response.result,
-            };
-        }
-        catch (error) {
-            return {
-                toolCallId: toolCall.id,
-                toolName: name,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                result: null,
-            };
-        }
+    execute(toolCall, context) {
+        return defer(async () => {
+            const { name, arguments: args } = toolCall.function;
+            if (typeof args !== 'object' || args === null) {
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    success: false,
+                    error: 'Tool arguments must be an object',
+                    result: null,
+                };
+            }
+            try {
+                const response = await this.client.callTool({
+                    name,
+                    arguments: args,
+                }, context.authContext);
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    success: true,
+                    result: response.result,
+                };
+            }
+            catch (error) {
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    result: null,
+                };
+            }
+        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error)))));
     }
     convertMCPTool = (mcpTool) => {
         return {

package/dist/tools/tool-result-events.d.ts

@@ -0,0 +1,6 @@
+import { type Observable } from 'rxjs';
+import type { ExecutionContext } from '../types/context';
+import type { ContextAnyEvent, ContextEvent, ToolCompleteEvent } from '../types/event';
+import type { ToolCall, ToolResult } from '../types/tools';
+export declare const toolErrorEvent: (context: ExecutionContext, toolCall: ToolCall, errorMessage: string) => ContextEvent<ToolCompleteEvent>;
+export declare const toolResultToEvents: (context: ExecutionContext, _toolCall: ToolCall, result: ToolResult) => Observable<ContextAnyEvent>;

package/dist/tools/tool-result-events.js

@@ -0,0 +1,33 @@
+import { concat, EMPTY, from, of } from 'rxjs';
+export const toolErrorEvent = (context, toolCall, errorMessage) => ({
+    kind: 'tool-complete',
+    contextId: context.contextId,
+    taskId: context.taskId,
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name,
+    success: false,
+    result: null,
+    error: errorMessage,
+    timestamp: new Date().toISOString(),
+});
+export const toolResultToEvents = (context, _toolCall, result) => {
+    const toolCompleteEvent = {
+        kind: 'tool-complete',
+        contextId: context.contextId,
+        taskId: context.taskId,
+        toolCallId: result.toolCallId,
+        toolName: result.toolName,
+        success: result.success,
+        result: result.result,
+        error: result.error,
+        timestamp: new Date().toISOString(),
+    };
+    const messageEvents = result.messages?.map((message) => ({
+        kind: 'internal:tool-message',
+        contextId: context.contextId,
+        taskId: context.taskId,
+        message,
+        timestamp: new Date().toISOString(),
+    })) ?? [];
+    return concat(of(toolCompleteEvent), messageEvents.length > 0 ? from(messageEvents) : EMPTY);
+};

package/dist/types/event.d.ts

@@ -17,8 +17,6 @@ export interface JSONSchema {
 }
 export interface TaskCreatedEvent {
     kind: 'task-created';
-    contextId: string;
-    taskId: string;
     parentTaskId?: string;
     initiator: TaskInitiator;
     timestamp: string;
@@ -30,8 +28,6 @@ export interface TaskCreatedEvent {
 }
 export interface TaskStatusEvent {
     kind: 'task-status';
-    contextId: string;
-    taskId: string;
     status: TaskStatus;
     message?: string;
     timestamp: string;
@@ -43,8 +39,6 @@ export interface TaskStatusEvent {
 }
 export interface TaskCompleteEvent {
     kind: 'task-complete';
-    contextId: string;
-    taskId: string;
     content?: string;
     artifacts?: string[];
     timestamp: string;
@@ -58,8 +52,6 @@ export interface TaskCompleteEvent {
 export type TaskLifecycleEvent = TaskCreatedEvent | TaskStatusEvent | TaskCompleteEvent;
 export interface ContentDeltaEvent {
     kind: 'content-delta';
-    contextId: string;
-    taskId: string;
     delta: string;
     index: number;
     timestamp: string;
@@ -67,8 +59,6 @@ export interface ContentDeltaEvent {
 export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter';
 export interface ContentCompleteEvent {
     kind: 'content-complete';
-    contextId: string;
-    taskId: string;
     content: string;
     finishReason: FinishReason;
     toolCalls?: Array<{
@@ -84,8 +74,6 @@ export interface ContentCompleteEvent {
 export type ContentStreamingEvent = ContentDeltaEvent | ContentCompleteEvent;
 export interface ToolCallEvent {
     kind: 'tool-call';
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     toolName: string;
     arguments: Record<string, unknown>;
@@ -96,8 +84,6 @@ export interface ToolCallEvent {
 }
 export interface ToolStartEvent {
     kind: 'tool-start';
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     icon?: string;
     toolName: string;
@@ -111,8 +97,6 @@ export interface ToolStartEvent {
 }
 export interface ToolProgressEvent {
     kind: 'tool-progress';
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     icon?: string;
     progress: number;
@@ -127,8 +111,6 @@ export interface ToolProgressEvent {
 }
 export interface ToolCompleteEvent {
     kind: 'tool-complete';
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     icon?: string;
     toolName: string;
@@ -146,8 +128,6 @@ export interface ToolCompleteEvent {
 export type ToolExecutionEvent = ToolCallEvent | ToolStartEvent | ToolProgressEvent | ToolCompleteEvent;
 export interface InputRequiredEvent {
     kind: 'input-required';
-    contextId: string;
-    taskId: string;
     inputId: string;
     requireUser?: boolean;
     inputType: InputType;
@@ -164,8 +144,6 @@ export interface InputRequiredEvent {
 }
 export interface InputReceivedEvent {
     kind: 'input-received';
-    contextId: string;
-    taskId: string;
     inputId: string;
     providedBy: InputProvider;
     userId?: string;
@@ -179,8 +157,6 @@ export interface InputReceivedEvent {
 export type InputRequestEvent = InputRequiredEvent | InputReceivedEvent;
 export interface AuthRequiredEvent {
     kind: 'auth-required';
-    contextId: string;
-    taskId: string;
     authId: string;
     authType: AuthType;
     provider?: string;
@@ -195,8 +171,6 @@ export interface AuthRequiredEvent {
 }
 export interface AuthCompletedEvent {
     kind: 'auth-completed';
-    contextId: string;
-    taskId: string;
     authId: string;
     userId: string;
     timestamp: string;
@@ -208,8 +182,6 @@ export interface AuthCompletedEvent {
 export type AuthenticationEvent = AuthRequiredEvent | AuthCompletedEvent;
 export interface FileWriteEvent {
     kind: 'file-write';
-    contextId: string;
-    taskId: string;
     artifactId: string;
     data: string;
     index: number;
@@ -227,8 +199,6 @@ export interface FileWriteEvent {
 }
 export interface DataWriteEvent {
     kind: 'data-write';
-    contextId: string;
-    taskId: string;
     artifactId: string;
     name?: string;
     description?: string;
@@ -242,8 +212,6 @@ export interface DataWriteEvent {
 }
 export interface DatasetWriteEvent {
     kind: 'dataset-write';
-    contextId: string;
-    taskId: string;
     artifactId: string;
     rows: Record<string, unknown>[];
     index: number;
@@ -262,8 +230,6 @@ export interface DatasetWriteEvent {
 export type ArtifactEvent = FileWriteEvent | DataWriteEvent | DatasetWriteEvent;
 export interface SubtaskCreatedEvent {
     kind: 'subtask-created';
-    contextId: string;
-    taskId: string;
     subtaskId: string;
     agentId?: string;
     prompt: string;
@@ -272,8 +238,6 @@ export interface SubtaskCreatedEvent {
 export type SubAgentEvent = SubtaskCreatedEvent;
 export interface ThoughtStreamEvent {
     kind: 'thought-stream';
-    contextId: string;
-    taskId: string;
     thoughtId: string;
     thoughtType: ThoughtType;
     verbosity: ThoughtVerbosity;
@@ -290,8 +254,6 @@ export interface ThoughtStreamEvent {
 }
 export interface InternalThoughtProcessEvent {
     kind: 'internal:thought-process';
-    contextId: string;
-    taskId: string;
     iteration: number;
     stage: 'pre-llm' | 'post-llm' | 'pre-tool' | 'post-tool';
     reasoning: string;
@@ -300,8 +262,6 @@ export interface InternalThoughtProcessEvent {
 }
 export interface InternalLLMCallEvent {
     kind: 'internal:llm-call';
-    contextId: string;
-    taskId: string;
     iteration: number;
     messageCount: number;
     toolCount: number;
@@ -309,30 +269,22 @@ export interface InternalLLMCallEvent {
 }
 export interface InternalToolMessageEvent {
     kind: 'internal:tool-message';
-    contextId: string;
-    taskId: string;
     message: SystemMessage;
     timestamp: string;
 }
 export interface InternalCheckpointEvent {
     kind: 'internal:checkpoint';
-    contextId: string;
-    taskId: string;
     iteration: number;
     timestamp: string;
 }
 export interface InternalToolStartEvent {
     kind: 'internal:tool-start';
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     toolName: string;
     timestamp: string;
 }
 export interface InternalToolCompleteEvent {
     kind: 'internal:tool-complete';
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     toolName: string;
     success: boolean;
@@ -342,8 +294,6 @@ export interface InternalToolCompleteEvent {
 export type InternalDebugEvent = InternalLLMCallEvent | InternalToolMessageEvent | InternalCheckpointEvent | InternalToolStartEvent | InternalToolCompleteEvent | InternalThoughtProcessEvent;
 export interface LLMUsageEvent {
     kind: 'llm-usage';
-    contextId: string;
-    taskId: string;
     model: string;
     prompt_tokens?: number;
     completion_tokens?: number;
@@ -357,13 +307,15 @@ export interface LLMUsageEvent {
 export type UsageEvent = LLMUsageEvent;
 export interface MessageEvent {
     kind: 'message';
-    contextId: string;
-    taskId: string;
     message: Message;
     timestamp: string;
 }
 export type AnyEvent = TaskLifecycleEvent | ContentStreamingEvent | ToolExecutionEvent | InputRequestEvent | AuthenticationEvent | ArtifactEvent | SubAgentEvent | ThoughtStreamEvent | InternalDebugEvent | UsageEvent | MessageEvent;
-export type LLMEvent<T> = Omit<T, 'contextId' | 'taskId'>;
+export type ContextEvent<T> = T & {
+    contextId: string;
+    taskId: string;
+};
+export type ContextAnyEvent = ContextEvent<AnyEvent>;
 export type ExternalEvent = Exclude<AnyEvent, InternalDebugEvent>;
 export type DebugEvent = InternalDebugEvent;
 export declare function isExternalEvent(event: AnyEvent): event is ExternalEvent;

package/dist/types/llm.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
-import type { AnyEvent, LLMEvent } from './event';
+import type { AnyEvent } from './event';
 import type { Message } from './message';
 import type { ToolCall, ToolDefinition } from './tools';
 export interface LLMProvider {
@@ -8,7 +8,7 @@ export interface LLMProvider {
         tools?: ToolDefinition[];
         stream?: boolean;
         sessionId?: string;
-    }): Observable<LLMEvent<AnyEvent>>;
+    }): Observable<AnyEvent>;
 }
 export interface LLMResponse {
     message: Message;