@genui-a3/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,569 @@
+import * as zod_v4_core from 'zod/v4/core';
+import * as zod from 'zod';
+import { z, ZodType } from 'zod';
+import { Message as Message$1, ConverseStreamOutput, ToolInputSchema } from '@aws-sdk/client-bedrock-runtime';
+
+declare enum WidgetType {
+    WIDGET_1 = "widget1"
+}
+interface BaseWidget {
+    type: string;
+    displayText?: string;
+}
+interface Widget1 extends BaseWidget {
+    type: WidgetType.WIDGET_1;
+}
+type Widget = Widget1;
+
+declare enum ToolName {
+    Tool1 = "tool1"
+}
+type MessageMetadata = {
+    source: MessageSender;
+    timestamp?: number;
+    widget?: Widget;
+    redirectTo?: string;
+};
+type AgUIEvent = {
+    component: string;
+    data?: Record<string, unknown>;
+};
+type Message = {
+    text: string;
+    metadata?: MessageMetadata;
+    agUIEvents?: AgUIEvent[];
+    isStreaming?: boolean;
+    isError?: boolean;
+    executingTools?: ToolName[];
+    messageId?: string;
+    widgets?: object;
+};
+declare enum MessageSender {
+    ASSISTANT = "assistant",
+    USER = "user"
+}
+type Conversation = Message[];
+type ToolResult<T> = {
+    content: T;
+    status: 'success' | 'error';
+};
+
+/**
+ * Interface for session persistence.
+ * Implement this to use Redis, DynamoDB, Postgres, etc.
+ *
+ * @example
+ * ```typescript
+ * class RedisSessionStore<TState extends BaseState, TContext extends BaseChatContext>
+ *   implements SessionStore<TState, TContext> {
+ *   constructor(private redis: RedisClient) {}
+ *
+ *   async load(sessionId: string): Promise<SessionData<TState, TContext> | null> {
+ *     const data = await this.redis.get(`session:${sessionId}`)
+ *     return data ? JSON.parse(data) : null
+ *   }
+ *
+ *   async save(sessionId: string, data: SessionData<TState, TContext>): Promise<void> {
+ *     await this.redis.set(`session:${sessionId}`, JSON.stringify(data))
+ *   }
+ *
+ *   async delete(sessionId: string): Promise<void> {
+ *     await this.redis.del(`session:${sessionId}`)
+ *   }
+ * }
+ * ```
+ */
+interface SessionStore<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> {
+    /** Load session data, returns null if not found */
+    load(sessionId: string): Promise<SessionData<TState, TContext> | null>;
+    /** Save session data */
+    save(sessionId: string, data: SessionData<TState, TContext>): Promise<void>;
+    /** Delete a session (optional) */
+    delete?(sessionId: string): Promise<void>;
+}
+
+/**
+ * BaseState defines the minimum required fields for state.
+ * Consumers extend this interface with their own properties.
+ *
+ * Note: State is GLOBAL across all agents in a session. All agents
+ * share the same state object, enabling cross-agent data flow.
+ */
+interface BaseState {
+    [key: string]: unknown;
+}
+/**
+ * BaseChatContext defines the minimum required fields for chat context.
+ * Consumers extend this interface with their own properties
+ */
+interface BaseChatContext {
+    [key: string]: unknown;
+}
+interface SessionData<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> {
+    sessionId: string;
+    messages: Conversation;
+    conversationHistory?: Conversation;
+    activeAgentId: AgentId | null;
+    state: TState;
+    chatContext: TContext;
+}
+/**
+ * Response from ChatSession.send()
+ */
+interface ChatResponse<TState extends BaseState = BaseState> {
+    responseMessage: string;
+    messageMetadata?: MessageMetadata;
+    activeAgentId: AgentId | null;
+    nextAgentId: AgentId | null;
+    state: TState;
+    goalAchieved: boolean;
+    sessionId: string;
+    widgets?: object;
+}
+/**
+ * Configuration for creating a ChatSession
+ */
+interface ChatSessionConfig<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> {
+    /** Unique session identifier */
+    sessionId: string;
+    /** Storage adapter for session persistence */
+    store?: SessionStore<TState, TContext>;
+    /** Initial agent to start the conversation */
+    initialAgentId: AgentId;
+    /** Initial state (used when creating new sessions) */
+    initialState?: TState;
+    /** Initial chat context (used when creating new sessions) */
+    initialChatContext?: TContext;
+    initialMessages?: Message[];
+}
+
+type StreamEvent<TState extends BaseState = BaseState> = {
+    type: 'RunStarted';
+    runId?: string;
+    threadId?: string;
+    input?: unknown;
+} | {
+    type: 'TextMessageStart';
+    messageId: string;
+    role?: string;
+} | {
+    type: 'TextMessageContent';
+    delta: string;
+    agentId: AgentId;
+    messageId?: string;
+} | {
+    type: 'TextMessageEnd';
+    messageId: string;
+} | {
+    type: 'ToolCallStart';
+    toolCallId: string;
+    toolCallName: string;
+    parentMessageId?: string;
+} | {
+    type: 'ToolCallArgs';
+    toolCallId: string;
+    delta: string;
+} | {
+    type: 'ToolCallEnd';
+    toolCallId: string;
+} | {
+    type: 'ToolCallResult';
+    data: Record<string, unknown>;
+    agentId: AgentId;
+    toolCallId?: string;
+} | {
+    type: 'AgentTransition';
+    fromAgentId: AgentId;
+    toAgentId: AgentId;
+} | {
+    type: 'RunFinished';
+    response: ChatResponse<TState>;
+} | {
+    type: 'RunError';
+    error: Error;
+    agentId: AgentId;
+};
+
+/**
+ * Agent IDs are string-based to support dynamic registration.
+ * Consumers can define their own agent IDs without modifying the core library.
+ */
+type AgentId = string;
+interface FlowInput<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> {
+    agent: Agent<TState, TContext>;
+    sessionData: SessionData<TState, TContext>;
+    lastAgentUnsentMessage?: string;
+}
+type AgentResponseResult<TState extends BaseState = BaseState> = {
+    newState: TState;
+    chatbotMessage: string;
+    messageMetadata?: MessageMetadata;
+    goalAchieved: boolean;
+    nextAgentId: AgentId | null;
+    redirectToAgent?: AgentId | null;
+    widgets?: object;
+};
+type GenerateAgentResponseSpecification<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> = (input: FlowInput<TState, TContext>) => Promise<AgentResponseResult<TState>>;
+type GenerateAgentResponseStreamSpecification<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> = (input: FlowInput<TState, TContext>) => AsyncGenerator<StreamEvent<TState>, AgentResponseResult<TState>>;
+/**
+ * Output schema for an agent.
+ * Base fields (chatbotMessage, goalAchieved, redirectToAgent) are added automatically.
+ */
+type AgentOutputSchema<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> = z.ZodObject<{
+    [key: string]: z.ZodTypeAny;
+}> | ((sessionData: SessionData<TState, TContext>) => z.ZodObject<{
+    [key: string]: z.ZodTypeAny;
+}>);
+type Agent<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> = {
+    id: AgentId;
+    /** Description of the agent's purpose, used for agent pool discovery */
+    description: string;
+    modelId?: string;
+    name: string;
+    promptGenerator: (params: FlowInput<TState, TContext>) => Promise<string>;
+    outputSchema: AgentOutputSchema<TState, TContext>;
+    generateAgentResponse: GenerateAgentResponseSpecification<TState, TContext>;
+    /** Optional streaming response generator. Falls back to simpleAgentResponseStream. */
+    generateAgentResponseStream?: GenerateAgentResponseStreamSpecification<TState, TContext>;
+    fitDataInGeneralFormat: (data: any, state: TState) => TState;
+    nextAgentSelector?: (state: TState, agentGoalAchieved: boolean) => AgentId;
+    /** Agent IDs this agent can transition to. Used to constrain redirectToAgent in the schema. */
+    transitionsTo?: AgentId[];
+    filterHistoryStrategy?: (messages: Conversation) => Conversation;
+    /** Zod schemas defining the usage of widgets available to the agent */
+    widgets?: Record<string, z.ZodObject<any>> | ((sessionData: SessionData<TState, TContext>) => Record<string, z.ZodObject<any>>);
+};
+
+declare const prepareAgentRequest: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ agent, sessionData, lastAgentUnsentMessage, }: FlowInput<TState, TContext>) => Promise<{
+    systemPrompt: string;
+    fullOutputSchema: zod.ZodObject<{
+        chatbotMessage: zod.ZodString;
+        goalAchieved: zod.ZodBoolean;
+        redirectToAgent: zod.ZodNullable<zod.ZodString> | zod.ZodNullable<zod.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        conversationPayload: zod.ZodObject<{
+            [key: string]: zod.ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>;
+        }, zod_v4_core.$strip>;
+        widgets: zod.ZodOptional<zod.ZodPipe<zod.ZodTransform<unknown, unknown>, zod.ZodUnion<readonly [zod.ZodObject<{}, zod_v4_core.$strip>, zod.ZodLiteral<"">, zod.ZodNull]> | zod.ZodUnion<readonly [zod.ZodObject<{}, zod_v4_core.$strip>, zod.ZodUnion<readonly [zod.ZodObject<{}, zod_v4_core.$strip>, zod.ZodLiteral<"">, zod.ZodNull]>]>>>;
+    }, zod_v4_core.$strip>;
+}>;
+declare const getAgentResponse: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ agent, sessionData, lastAgentUnsentMessage, }: FlowInput<TState, TContext>) => Promise<{
+    chatbotMessage: string;
+    goalAchieved: boolean;
+    redirectToAgent: string | null;
+    conversationPayload: Record<string, unknown>;
+    widgets?: "" | Record<string, never> | null | undefined;
+}>;
+declare const processAgentResponseData: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>(agent: Agent<TState, TContext>, sessionData: SessionData<TState, TContext>, data: Record<string, unknown>) => {
+    newState: TState;
+    chatbotMessage: string;
+    goalAchieved: boolean;
+    nextAgentId: string;
+    widgets: object | undefined;
+};
+declare const simpleAgentResponse: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ agent, sessionData, lastAgentUnsentMessage, }: FlowInput<TState, TContext>) => Promise<Awaited<ReturnType<GenerateAgentResponseSpecification<TState, TContext>>>>;
+declare function getAgentResponseStream<TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ agent, sessionData, lastAgentUnsentMessage }: FlowInput<TState, TContext>): AsyncGenerator<StreamEvent<TState>>;
+declare function simpleAgentResponseStream<TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ agent, sessionData, lastAgentUnsentMessage, }: FlowInput<TState, TContext>): AsyncGenerator<StreamEvent<TState>, AgentResponseResult<TState>>;
+
+/**
+ * AgentRegistry - A centralized singleton registry for managing agents.
+ *
+ * This allows consumers of the library to dynamically register their own agents
+ * at runtime, enabling modular and extensible agent architectures.
+ *
+ * The registry is generic over TState - all agents share the same state type.
+ *
+ * @example
+ * ```typescript
+ * import { AgentRegistry } from '@genui-a3/core'
+ *
+ * interface State extends BaseState {
+ *   userName?: string
+ * }
+ *
+ * // Get a typed registry instance
+ * const registry = AgentRegistry.getInstance<State>()
+ *
+ * // Register a single agent
+ * registry.register(myAgent)
+ *
+ * // Register multiple agents at once
+ * registry.register([agent1, agent2, agent3])
+ *
+ * const agent = registry.get('my-agent-id')
+ * ```
+ */
+declare class AgentRegistry<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> {
+    private static instance;
+    private agents;
+    private constructor();
+    static getInstance<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext>(): AgentRegistry<TState, TContext>;
+    /**
+     * Resets the singleton instance. Primarily useful for testing.
+     */
+    static resetInstance(): void;
+    /**
+     * Registers one or more agents with the registry.
+     *
+     * @param agents - A single agent or array of agents to register
+     * @throws Error if any agent ID is already registered
+     */
+    register(agents: Agent<TState, TContext> | Agent<TState, TContext>[]): void;
+    /**
+     * Retrieves an agent by its ID.
+     *
+     * @param id - The agent ID to look up
+     * @returns The agent if found, undefined otherwise
+     */
+    get(id: AgentId): Agent<TState, TContext> | undefined;
+    /**
+     * Returns all registered agents.
+     *
+     * @returns Array of all registered agents
+     */
+    getAll(): Agent<TState, TContext>[];
+    /**
+     * Checks if an agent with the given ID is registered.
+     *
+     * @param id - The agent ID to check
+     * @returns true if the agent is registered, false otherwise
+     */
+    has(id: AgentId): boolean;
+    /**
+     * Unregisters an agent by its ID.
+     *
+     * @param id - The agent ID to unregister
+     * @returns true if the agent was found and removed, false otherwise
+     */
+    unregister(id: AgentId): boolean;
+    /**
+     * Returns a record of all agent IDs to their descriptions.
+     * Useful for generating agent pool documentation.
+     *
+     * @returns Record mapping agent IDs to descriptions
+     */
+    getDescriptions(): Record<AgentId, string>;
+    /**
+     * Returns the count of registered agents.
+     *
+     * @returns Number of registered agents
+     */
+    get count(): number;
+    /**
+     * Clears all registered agents from the registry.
+     * Primarily useful for testing.
+     */
+    clear(): void;
+}
+
+declare const manageFlow: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ sessionData, lastAgentUnsentMessage, _depth, }: FlowInput<TState, TContext> & {
+    _depth?: number;
+}) => Promise<ChatResponse<TState>>;
+declare function manageFlowStream<TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>({ sessionData, lastAgentUnsentMessage, _depth, }: FlowInput<TState, TContext> & {
+    _depth?: number;
+}): AsyncGenerator<StreamEvent<TState>>;
+
+declare const baseResponseSchema: z.ZodObject<{
+    chatbotMessage: z.ZodString;
+    goalAchieved: z.ZodBoolean;
+    redirectToAgent: z.ZodNullable<z.ZodString>;
+    conversationPayload: z.ZodAny;
+    widgets: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strip>, z.ZodLiteral<"">, z.ZodNull]>>;
+}, z.core.$strip>;
+type BaseResponse = z.infer<typeof baseResponseSchema>;
+/**
+ * Creates a full output schema by merging base fields with the agent's outputSchema.
+ * If transitionsTo is provided, redirectToAgent is constrained to those values.
+ */
+declare function createFullOutputSchema<T extends z.ZodObject<{
+    [key: string]: z.ZodTypeAny;
+}>>(outputSchema: T, transitionsTo?: AgentId[], widgets?: Record<string, z.ZodObject>): z.ZodObject<{
+    chatbotMessage: z.ZodString;
+    goalAchieved: z.ZodBoolean;
+    redirectToAgent: z.ZodNullable<z.ZodString> | z.ZodNullable<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+    conversationPayload: T;
+    widgets: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strip>, z.ZodLiteral<"">, z.ZodNull]> | z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strip>, z.ZodLiteral<"">, z.ZodNull]>]>>>;
+}, z.core.$strip>;
+
+/**
+ * ChatSession encapsulates the complete message lifecycle.
+ *
+ * @example
+ * ```typescript
+ * const session = new ChatSession({
+ *   sessionId: 'user-123',
+ *   store: new RedisSessionStore(redis),
+ *   initialAgentId: 'greeting',
+ * })
+ *
+ * const result = await session.send('Hello!')
+ * ```
+ */
+declare class ChatSession<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> {
+    private readonly sessionId;
+    private readonly store;
+    private readonly initialAgentId;
+    private readonly initialState;
+    private readonly initialChatContext;
+    private readonly initialMessages?;
+    constructor(config: ChatSessionConfig<TState, TContext>);
+    /**
+     * Send a message and get a response.
+     *
+     * Flow:
+     * 1. Load existing session or create new
+     * 2. Append user message to history
+     * 3. Run manageFlow with current agent
+     * 4. Append assistant response to history
+     * 5. Save updated session
+     * 6. Return response
+     */
+    send(message: string): Promise<ChatResponse<TState>>;
+    /**
+     * Send a message and stream the response as an async generator of StreamEvents.
+     *
+     * Text deltas are yielded immediately for real-time rendering.
+     * Session state is persisted after the stream is fully consumed.
+     */
+    sendStream(message: string): AsyncGenerator<StreamEvent<TState>>;
+    /**
+     * Prepares the session data for sending a message.
+     * Loads or creates the session, appends the user message, and returns the active agent.
+     */
+    private beforeProcessMessage;
+    /**
+     * Executes the agent flow to generate a completely buffered response.
+     */
+    private processMessage;
+    /**
+     * Streams the agent flow execution event by event.
+     */
+    private processMessageStream;
+    /**
+     * Finalizes the response by appending the assistant message, updating state,
+     * refreshing chat context, and persisting the session.
+     */
+    private afterProcessMessage;
+    /**
+     * Gets or initializes session if it doesn't exist.
+     */
+    getOrCreateSessionData(): Promise<SessionData<TState, TContext>>;
+    /**
+     * Get current session data without sending a message.
+     */
+    getSessionData(): Promise<SessionData<TState, TContext> | null>;
+    upsertSessionData(updates: Partial<SessionData<TState, TContext>>): Promise<void>;
+    /**
+     * Get conversation history.
+     */
+    getHistory(): Promise<Message[]>;
+    /**
+     * Clear/delete the session.
+     */
+    clear(): Promise<void>;
+    private createInitialSession;
+}
+
+/**
+ * In-memory session store for development and testing.
+ * Sessions are lost on process restart.
+ *
+ * @example
+ * ```typescript
+ * const store = new MemorySessionStore<MyState, MyContext>()
+ * const session = new ChatSession({
+ *   sessionId: 'test-123',
+ *   store,
+ *   initialAgentId: 'greeting',
+ * })
+ * ```
+ */
+declare class MemorySessionStore<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> implements SessionStore<TState, TContext> {
+    private sessions;
+    load(sessionId: string): Promise<SessionData<TState, TContext> | null>;
+    save(sessionId: string, data: SessionData<TState, TContext>): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    /** Clear all sessions (useful for testing) */
+    clear(): void;
+    /** Get number of active sessions */
+    get size(): number;
+}
+
+declare class AgentCoreMemoryStore<TState extends BaseState = BaseState, TContext extends BaseChatContext = BaseChatContext> implements SessionStore<TState, TContext> {
+    private client;
+    private memoryId;
+    constructor(config: {
+        region: string;
+        memoryId: string;
+    });
+    load(sessionId: string): Promise<SessionData<TState, TContext> | null>;
+    save(sessionId: string, data: SessionData<TState, TContext>): Promise<void>;
+}
+
+declare function mergeSequentialMessages(conversation: Conversation): Message$1[];
+
+type SendWithModelParams = {
+    modelArn: string;
+    modelName: string;
+    systemPrompt: string;
+    mergedMessages: ReturnType<typeof mergeSequentialMessages>;
+    inputSchema: ToolInputSchema | undefined;
+};
+declare function sendWithModel(params: SendWithModelParams): Promise<string>;
+declare function sendStreamWithModel(params: SendWithModelParams): Promise<AsyncIterable<ConverseStreamOutput>>;
+type SendChatRequestParams<TState extends BaseState, TContext extends BaseChatContext = BaseChatContext> = {
+    agent: Agent<TState, TContext>;
+    systemPrompt: string;
+    basePrompt: string;
+    conversation: Conversation;
+    responseFormat: ZodType;
+};
+declare const sendChatRequest: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>(params: SendChatRequestParams<TState, TContext>) => Promise<string>;
+declare const sendChatRequestStream: <TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>(params: SendChatRequestParams<TState, TContext>) => Promise<AsyncIterable<ConverseStreamOutput>>;
+
+declare const EXAMPLE_CONSTANT = "";
+
+/**
+ * Generates a formatted string listing the agents based on the provided agent IDs.
+ * The format matches the one used in basePrompt.ts:
+ * - 'agentId': Description of the agent
+ *
+ * @param agentIds - Array of AgentId values representing the agents to include
+ * @returns A formatted string listing the agents and their descriptions
+ *
+ * @example
+ * ```typescript
+ * // Create a formatted string with consent and basic patient info agents
+ * const agentsList = generateAgentPool([AgentId.CONSENT, AgentId.BASIC_PATIENT_INFO]);
+ * // Result will be:
+ * // - 'consent': Collects the user's consent to be assisted by the agent
+ * // - 'basicPatientInfo': Collects basic patient information (e.g., user name, user DOB, reason for visit)
+ * ```
+ */
+declare function generateAgentPool<TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>(agents: Agent<TState, TContext>[], agentIds: AgentId[]): string;
+/**
+ * Generates a formatted string for a single agent item
+ *
+ * @param agentId - The ID of the agent to format
+ * @returns A formatted string for the agent
+ * @throws Error if the agent ID is invalid or has no description
+ */
+declare function generateAgentPoolItem(agentId: AgentId): string;
+/**
+ * Gets the agent IDs that should be included in the agent pool for a given agent.
+ * Returns the current agent's ID plus any agents it can transition to.
+ *
+ * @param agent - The agent to get the pool IDs for
+ * @returns An array of AgentId values
+ */
+declare function getAgentPoolIds<TState extends BaseState, TContext extends BaseChatContext = BaseChatContext>(agent: Agent<TState, TContext>): AgentId[];
+
+/**
+ * These instructions help prevent the agent from being overly helpful and making up information
+ */
+declare const getAntiHallucinationPrompt: (subject: string, wrapUpAgentId?: AgentId) => string;
+
+export { type AgUIEvent, type Agent, AgentCoreMemoryStore, type AgentId, type AgentOutputSchema, AgentRegistry, type AgentResponseResult, type BaseChatContext, type BaseResponse, type BaseState, type BaseWidget, type ChatResponse, ChatSession, type ChatSessionConfig, type Conversation, EXAMPLE_CONSTANT, type FlowInput, type GenerateAgentResponseSpecification, type GenerateAgentResponseStreamSpecification, MemorySessionStore, type Message, type MessageMetadata, MessageSender, type SendChatRequestParams, type SessionData, type SessionStore, type StreamEvent, ToolName, type ToolResult, type Widget, type Widget1, WidgetType, createFullOutputSchema, generateAgentPool, generateAgentPoolItem, getAgentPoolIds, getAgentResponse, getAgentResponseStream, getAntiHallucinationPrompt, manageFlow, manageFlowStream, mergeSequentialMessages, prepareAgentRequest, processAgentResponseData, sendChatRequest, sendChatRequestStream, sendStreamWithModel, sendWithModel, simpleAgentResponse, simpleAgentResponseStream };