@shuttl-io/core 0.2.0

package/dist/src/server/http.js

@@ -0,0 +1,654 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdInServer = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const process_1 = require("process");
+const readline_1 = require("readline");
+const agent_1 = require("../agent");
+const types_1 = require("../models/types");
+/**
+ * A server that communicates via STDIN/STDOUT using JSON messages.
+ * Uses newline-delimited JSON (NDJSON) protocol where each message
+ * is a single line of JSON followed by a newline character.
+ *
+ * Host CLI writes requests to the process's STDIN.
+ * This server writes responses to STDOUT.
+ * Debug/log messages go to STDERR to avoid polluting the protocol.
+ */
+class StdInServer {
+    constructor() {
+        this.running = false;
+    }
+    accept(app) {
+        this.app = app;
+    }
+    async start() {
+        if (!this.app) {
+            throw new Error("No app registered. Call accept() before start().");
+        }
+        this.running = true;
+        // Create readline interface for line-by-line processing
+        this.rl = (0, readline_1.createInterface)({
+            input: process_1.stdin,
+            output: undefined, // We write to stdout manually
+            terminal: false,
+        });
+        // Handle each line as a JSON message
+        this.rl.on("line", (line) => {
+            this.handleLine(line);
+        });
+        // Handle stdin close
+        this.rl.on("close", () => {
+            this.running = false;
+        });
+        // Send ready signal
+        this.sendResponse({
+            id: "__ready__",
+            success: true,
+            result: {
+                name: this.app.name,
+                protocol: "ndjson",
+                version: "1.0",
+            },
+        });
+        // Keep the process alive while running
+        while (this.running) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    async stop() {
+        this.running = false;
+        if (this.rl) {
+            this.rl.close();
+        }
+    }
+    /**
+     * Process a single line of input
+     */
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return; // Skip empty lines
+        }
+        let request;
+        try {
+            request = JSON.parse(trimmed);
+        }
+        catch (e) {
+            this.sendResponse({
+                id: "__parse_error__",
+                success: false,
+                errorObj: {
+                    code: "PARSE_ERROR",
+                    message: `Invalid JSON: ${e.message}`,
+                },
+            });
+            return;
+        }
+        // Validate request format
+        if (!request.id || typeof request.id !== "string") {
+            this.sendResponse({
+                id: request.id ?? "__invalid__",
+                success: false,
+                errorObj: {
+                    code: "INVALID_REQUEST",
+                    message: "Request must have a string 'id' field",
+                },
+            });
+            return;
+        }
+        if (!request.method || typeof request.method !== "string") {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INVALID_REQUEST",
+                    message: "Request must have a string 'method' field",
+                },
+            });
+            return;
+        }
+        // Route the request
+        this.handleRequest(request);
+    }
+    /**
+     * Route and handle a validated request
+     */
+    handleRequest(request) {
+        try {
+            switch (request.method) {
+                case "ping":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: { pong: true, timestamp: Date.now(), protocol_version: "1.0" },
+                    });
+                    break;
+                case "getAppInfo":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: {
+                            name: this.app.name,
+                            agentCount: this.app.agents.length,
+                            toolkitCount: this.app.toolkits.size,
+                        },
+                    });
+                    break;
+                case "listAgents":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: this.app.agents.map((agent) => ({
+                            name: agent.name,
+                            systemPrompt: agent.systemPrompt,
+                            model: agent.model,
+                            toolkits: agent.toolkits.map((tk) => tk.name),
+                        })),
+                    });
+                    break;
+                case "listToolkits":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: Array.from(this.app.toolkits).map((toolkit) => ({
+                            name: toolkit.name,
+                            description: toolkit.description,
+                            tools: toolkit.tools.map((tool) => ({
+                                name: tool.name,
+                                description: tool.description,
+                                args: tool.schema?.properties,
+                            })),
+                        })),
+                    });
+                    break;
+                case "listTriggers":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: this.app.agents.flatMap((agent) => agent.triggers.map((trigger) => ({
+                            name: trigger.name,
+                            triggerType: trigger.triggerType,
+                            agentName: agent.name,
+                        }))),
+                    });
+                    break;
+                case "listModels":
+                    // Get unique models from all agents
+                    const modelsMap = new Map();
+                    for (const agent of this.app.agents) {
+                        const model = agent.model;
+                        if (model && model.identifier) {
+                            modelsMap.set(model.identifier, {
+                                identifier: model.identifier,
+                                key: model.key,
+                            });
+                        }
+                    }
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: Array.from(modelsMap.values()),
+                    });
+                    break;
+                case "listPrompts":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: this.app.agents.map((agent) => ({
+                            agentName: agent.name,
+                            systemPrompt: agent.systemPrompt,
+                        })),
+                    });
+                    break;
+                case "listTools":
+                    // Get all tools from all toolkits
+                    const allTools = [];
+                    for (const toolkit of this.app.toolkits) {
+                        for (const tool of toolkit.tools) {
+                            allTools.push({
+                                name: tool.name,
+                                description: tool.description,
+                                args: tool.schema?.properties,
+                                toolkitName: toolkit.name,
+                            });
+                        }
+                    }
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: allTools,
+                    });
+                    break;
+                case "invokeTool":
+                    this.handleInvokeTool(request);
+                    break;
+                case "shutdown":
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: { shutting_down: true },
+                    });
+                    this.stop();
+                    break;
+                case "invokeAgent":
+                    this.handleInvokeAgent(request);
+                    break;
+                case "invokeTrigger":
+                    this.handleInvokeTrigger(request);
+                    break;
+                default:
+                    this.sendResponse({
+                        id: request.id,
+                        success: false,
+                        errorObj: {
+                            code: "UNKNOWN_METHOD",
+                            message: `Unknown method: ${request.method}`,
+                        },
+                    });
+            }
+        }
+        catch (e) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INTERNAL_ERROR",
+                    message: e.message,
+                },
+            });
+        }
+    }
+    async handleInvokeAgent(request) {
+        const params = request.body ?? {};
+        const agentName = params.agent;
+        const prompt = params.prompt ?? "";
+        const threadId = params.threadId ?? undefined;
+        const rawAttachments = params.attachments;
+        // Parse and validate attachments
+        let attachments;
+        if (rawAttachments !== undefined) {
+            if ((0, types_1.isFileAttachmentArray)(rawAttachments)) {
+                attachments = rawAttachments;
+            }
+            else {
+                this.sendResponse({
+                    id: request.id,
+                    success: false,
+                    errorObj: {
+                        code: "INVALID_PARAMS",
+                        message: "attachments must be an array of FileAttachment objects",
+                    },
+                });
+                return;
+            }
+        }
+        if (!agentName) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INVALID_PARAMS",
+                    message: "invokeAgent requires 'agent' param",
+                },
+            });
+            return;
+        }
+        const agent = this.app.agents.find((a) => a.name === agentName);
+        if (!agent) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "NOT_FOUND",
+                    message: `Agent not found: ${agentName}`,
+                },
+            });
+            return;
+        }
+        const streamer = new agent_1.AgentStreamer(agent, request.id);
+        try {
+            const model = await agent.invoke(prompt, threadId, streamer, attachments);
+            this.sendResponse({
+                id: request.id,
+                success: true,
+                result: { threadId: model.threadId, status: "invoked" },
+            });
+        }
+        catch (e) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INTERNAL_ERROR",
+                    message: JSON.stringify({
+                        message: e.message,
+                        stack: e.stack,
+                        name: e.name,
+                        type_of_error: typeof e,
+                        error_name: e instanceof Error ? e.name : undefined,
+                        error_object: e,
+                        error_constructor: e instanceof Error ? e.constructor.name : undefined,
+                    }),
+                },
+            });
+        }
+    }
+    /**
+     * Handle tool invocation request
+     */
+    handleInvokeTool(request) {
+        const params = request.body ?? {};
+        const toolkitName = params.toolkit;
+        const toolName = params.tool;
+        const toolArgs = params.args ?? {};
+        if (!toolkitName || !toolName) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INVALID_PARAMS",
+                    message: "invokeTool requires 'toolkit' and 'tool' params",
+                },
+            });
+            return;
+        }
+        // Find the toolkit
+        const toolkit = Array.from(this.app.toolkits).find((tk) => tk.name === toolkitName);
+        if (!toolkit) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "NOT_FOUND",
+                    message: `Toolkit not found: ${toolkitName}`,
+                },
+            });
+            return;
+        }
+        // Find the tool
+        const tool = toolkit.tools.find((t) => t.name === toolName);
+        if (!tool) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "NOT_FOUND",
+                    message: `Tool not found: ${toolName} in toolkit ${toolkitName}`,
+                },
+            });
+            return;
+        }
+        // Execute the tool
+        try {
+            const result = tool.execute(toolArgs);
+            // Handle async tools
+            if (result instanceof Promise) {
+                result
+                    .then((asyncResult) => {
+                    this.sendResponse({
+                        id: request.id,
+                        success: true,
+                        result: asyncResult,
+                    });
+                })
+                    .catch((e) => {
+                    this.sendResponse({
+                        id: request.id,
+                        success: false,
+                        errorObj: {
+                            code: "TOOL_ERROR",
+                            message: e.message,
+                        },
+                    });
+                });
+            }
+            else {
+                this.sendResponse({
+                    id: request.id,
+                    success: true,
+                    result,
+                });
+            }
+        }
+        catch (e) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "TOOL_ERROR",
+                    message: e.message,
+                },
+            });
+        }
+    }
+    /**
+     * Handle trigger invocation request from the serve command
+     */
+    async handleInvokeTrigger(request) {
+        const params = request.body ?? {};
+        const agentName = params.agentName;
+        const triggerName = params.triggerName;
+        const triggerType = params.triggerType;
+        const threadId = params.threadId;
+        const httpRequest = params.httpRequest;
+        // Validate required parameters
+        if (!agentName) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INVALID_PARAMS",
+                    message: "invokeTrigger requires 'agentName' param",
+                },
+            });
+            return;
+        }
+        if (!triggerName && !triggerType) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "INVALID_PARAMS",
+                    message: "invokeTrigger requires 'triggerName' or 'triggerType' param",
+                },
+            });
+            return;
+        }
+        // Find the agent
+        const agent = this.app.agents.find((a) => a.name === agentName);
+        if (!agent) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "NOT_FOUND",
+                    message: `Agent not found: ${agentName}`,
+                },
+            });
+            return;
+        }
+        // Find the trigger by name first, then by type
+        let trigger = agent.triggers.find((t) => t.name === triggerName);
+        if (!trigger && triggerType) {
+            trigger = agent.triggers.find((t) => t.triggerType === triggerType);
+        }
+        if (!trigger) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "NOT_FOUND",
+                    message: `Trigger not found: ${triggerName || triggerType} on agent ${agentName}`,
+                },
+            });
+            return;
+        }
+        // Validate the trigger arguments if validation is available
+        if (trigger.validate) {
+            try {
+                const validationResult = await trigger.validate(httpRequest);
+                if (validationResult.error) {
+                    this.sendResponse({
+                        id: request.id,
+                        success: false,
+                        errorObj: {
+                            code: "VALIDATION_ERROR",
+                            message: validationResult.error,
+                        },
+                    });
+                    return;
+                }
+            }
+            catch (e) {
+                this.sendResponse({
+                    id: request.id,
+                    success: false,
+                    errorObj: {
+                        code: "VALIDATION_ERROR",
+                        message: e.message,
+                    },
+                });
+                return;
+            }
+        }
+        // Create the trigger invoker with optional thread ID
+        const invoker = new ServerTriggerInvoker(agent, request.id, threadId);
+        try {
+            // Activate the trigger with the HTTP request
+            const triggerFunc = async () => {
+                await trigger.activate(httpRequest, invoker);
+                this.sendResponse({
+                    id: request.id,
+                    success: true,
+                    result: {
+                        agentName: agentName,
+                        triggerName: trigger.name,
+                        triggerType: trigger.triggerType,
+                        threadId: invoker.getThreadId(),
+                        status: "completed",
+                        output: invoker.getOutput(),
+                    },
+                });
+            };
+            triggerFunc();
+            // Send success response with the result
+            this.sendResponse({
+                id: request.id,
+                success: true,
+                result: {
+                    agentName: agentName,
+                    triggerName: trigger.name,
+                    triggerType: trigger.triggerType,
+                    threadId: invoker.getThreadId(),
+                    status: "acknowledged",
+                    output: invoker.getOutput(),
+                },
+            });
+        }
+        catch (e) {
+            this.sendResponse({
+                id: request.id,
+                success: false,
+                errorObj: {
+                    code: "TRIGGER_ERROR",
+                    message: JSON.stringify({
+                        message: e.message,
+                        stack: e.stack,
+                        name: e.name,
+                        type_of_error: typeof e,
+                        error_name: e instanceof Error ? e.name : undefined,
+                        error_object: e,
+                        error_constructor: e instanceof Error ? e.constructor.name : undefined,
+                    }),
+                },
+            });
+        }
+    }
+    /**
+     * Send a JSON response to STDOUT
+     */
+    sendResponse(response) {
+        const json = JSON.stringify(response);
+        process_1.stdout.write(json + "\n");
+    }
+}
+exports.StdInServer = StdInServer;
+_a = JSII_RTTI_SYMBOL_1;
+StdInServer[_a] = { fqn: "@shuttl-io/core.StdInServer", version: "0.1.7-0" };
+class TriggerStreamerWriter {
+    constructor() {
+        this.buffer = [];
+        this.done = false;
+    }
+    write(value) {
+        this.writeObject(JSON.parse(value));
+    }
+    writeObject(value) {
+        if (!this.done) {
+            this.buffer.push(value);
+        }
+        if (value.type === "overall.completed") {
+            this.done = true;
+        }
+    }
+    async next() {
+        if (this.buffer.length > 0) {
+            return { done: false, value: this.buffer.shift() };
+        }
+        if (this.done && this.buffer.length === 0) {
+            return { done: true, value: undefined };
+        }
+        else {
+            return new Promise((resolve) => {
+                setImmediate((() => {
+                    resolve(this.next());
+                }).bind(this));
+            });
+        }
+    }
+}
+/**
+ * Trigger invoker that invokes the agent via the server
+ */
+class ServerTriggerInvoker {
+    constructor(agent, requestId, threadId) {
+        this.agent = agent;
+        this.requestId = requestId;
+        this.threadId = threadId;
+        this.output = null;
+        this.currentThreadId = threadId;
+    }
+    async invoke(prompt) {
+        // Create a streamer for this invocation
+        const writer = new TriggerStreamerWriter();
+        const streamer = new agent_1.AgentStreamer(this.agent, this.requestId, writer);
+        // Build the model content from the input
+        const modelContent = prompt.map((input) => ({
+            role: "user",
+            content: input,
+        }));
+        // Use the agent's invoke method which handles thread management
+        const startStream = async () => {
+            const model = await this.agent.invoke(modelContent, this.threadId, streamer);
+            // Store the thread ID for the response
+            this.currentThreadId = model.threadId;
+        };
+        startStream();
+        // Return a completed response stream since the actual streaming is handled by AgentStreamer
+        return writer;
+    }
+    async defaultOutcome(_stream) {
+        // The default outcome just stores the stream result
+        // The actual streaming has already been handled by AgentStreamer
+        this.output = { completed: true };
+    }
+    getOutput() {
+        return this.output;
+    }
+    getThreadId() {
+        return this.currentThreadId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../src/server/http.ts"],"names":[],"mappings":";;;;;AAEA,qCAAwC;AACxC,uCAAsD;AACtD,oCAAsE;AACtE,2CAAqJ;AAiCrJ;;;;;;;;GAQG;AACH,MAAa,WAAW;IAKpB;QAHQ,YAAO,GAAY,KAAK,CAAC;IAGX,CAAC;IAEhB,MAAM,CAAC,GAAQ;QAClB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACnB,CAAC;IAEM,KAAK,CAAC,KAAK;QACd,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,wDAAwD;QACxD,IAAI,CAAC,EAAE,GAAG,IAAA,0BAAe,EAAC;YACtB,KAAK,EAAE,eAAK;YACZ,MAAM,EAAE,SAAS,EAAE,8BAA8B;YACjD,QAAQ,EAAE,KAAK;SAClB,CAAC,CAAC;QAEH,qCAAqC;QACrC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;YAChC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,qBAAqB;QACrB,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YACrB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACzB,CAAC,CAAC,CAAC;QAEH,oBAAoB;QACpB,IAAI,CAAC,YAAY,CAAC;YACd,EAAE,EAAE,WAAW;YACf,OAAO,EAAE,IAAI;YACb,MAAM,EAAE;gBACJ,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI;gBACnB,QAAQ,EAAE,QAAQ;gBAClB,OAAO,EAAE,KAAK;aACjB;SACJ,CAAC,CAAC;QAEH,uCAAuC;QACvC,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;QAC7D,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,IAAI;QACb,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;YACV,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;QACpB,CAAC;IACL,CAAC;IAED;;OAEG;IACK,UAAU,CAAC,IAAY;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,OAAO,CAAC,mBAAmB;QAC/B,CAAC;QAED,IAAI,OAAmB,CAAC;QAExB,IAAI,CAAC;YACD,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAe,CAAC;QAChD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,iBAAiB;gBACrB,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,aAAa;oBACnB,OAAO,EAAE,iBAAkB,CAAW,CAAC,OAAO,EAAE;iBACnD;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,0BAA0B;QAC1B,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,OAAO,OAAO,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;YAChD,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE,IAAI,aAAa;gBAC/B,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,iBAAiB;oBACvB,OAAO,EAAE,uCAAuC;iBACnD;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YACxD,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,iBAAiB;oBACvB,OAAO,EAAE,2CAA2C;iBACvD;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACK,aAAa,CAAC,OAAmB;QACrC,IAAI,CAAC;YACD,QAAQ,OAAO,CAAC,MAAM,EAAE,CAAC;gBACrB,KAAK,MAAM;oBACP,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE;qBACzE,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,YAAY;oBACb,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE;4BACJ,IAAI,EAAE,IAAI,CAAC,GAAI,CAAC,IAAI;4BACpB,UAAU,EAAE,IAAI,CAAC,GAAI,CAAC,MAAM,CAAC,MAAM;4BACnC,YAAY,EAAE,IAAI,CAAC,GAAI,CAAC,QAAQ,CAAC,IAAI;yBACxC;qBACJ,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,YAAY;oBACb,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,IAAI,CAAC,GAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;4BACrC,IAAI,EAAE,KAAK,CAAC,IAAI;4BAChB,YAAY,EAAE,KAAK,CAAC,YAAY;4BAChC,KAAK,EAAE,KAAK,CAAC,KAAK;4BAClB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;yBAChD,CAAC,CAAC;qBACN,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;4BACrD,IAAI,EAAE,OAAO,CAAC,IAAI;4BAClB,WAAW,EAAE,OAAO,CAAC,WAAW;4BAChC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gCAChC,IAAI,EAAE,IAAI,CAAC,IAAI;gCACf,WAAW,EAAE,IAAI,CAAC,WAAW;gCAC7B,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU;6BAChC,CAAC,CAAC;yBACN,CAAC,CAAC;qBACN,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,IAAI,CAAC,GAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CACvC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;4BAC7B,IAAI,EAAE,OAAO,CAAC,IAAI;4BAClB,WAAW,EAAE,OAAO,CAAC,WAAW;4BAChC,SAAS,EAAE,KAAK,CAAC,IAAI;yBACxB,CAAC,CAAC,CACN;qBACJ,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,YAAY;oBACb,oCAAoC;oBACpC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAyE,CAAC;oBACnG,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,GAAI,CAAC,MAAM,EAAE,CAAC;wBACnC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAY,CAAC;wBACjC,IAAI,KAAK,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;4BAC5B,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,EAAE;gCAC5B,UAAU,EAAE,KAAK,CAAC,UAAU;gCAC5B,GAAG,EAAE,KAAK,CAAC,GAAG;6BACjB,CAAC,CAAC;wBACP,CAAC;oBACL,CAAC;oBACD,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;qBACzC,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,IAAI,CAAC,GAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;4BACrC,SAAS,EAAE,KAAK,CAAC,IAAI;4BACrB,YAAY,EAAE,KAAK,CAAC,YAAY;yBACnC,CAAC,CAAC;qBACN,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,WAAW;oBACZ,kCAAkC;oBAClC,MAAM,QAAQ,GAKT,EAAE,CAAC;oBACR,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,GAAI,CAAC,QAAQ,EAAE,CAAC;wBACvC,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;4BAC/B,QAAQ,CAAC,IAAI,CAAC;gCACV,IAAI,EAAE,IAAI,CAAC,IAAI;gCACf,WAAW,EAAE,IAAI,CAAC,WAAW;gCAC7B,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU;gCAC7B,WAAW,EAAE,OAAO,CAAC,IAAI;6BAC5B,CAAC,CAAC;wBACP,CAAC;oBACL,CAAC;oBACD,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,QAAQ;qBACnB,CAAC,CAAC;oBACH,MAAM;gBAEV,KAAK,YAAY;oBACb,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;oBAC/B,MAAM;gBAEV,KAAK,UAAU;oBACX,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE;qBAClC,CAAC,CAAC;oBACH,IAAI,CAAC,IAAI,EAAE,CAAC;oBACZ,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;oBAChC,MAAM;gBAEV,KAAK,eAAe;oBAChB,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;oBAClC,MAAM;gBAEV;oBACI,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE;4BACN,IAAI,EAAE,gBAAgB;4BACtB,OAAO,EAAE,mBAAmB,OAAO,CAAC,MAAM,EAAE;yBAC/C;qBACJ,CAAC,CAAC;YACX,CAAC;QACL,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAG,CAAW,CAAC,OAAO;iBAChC;aACJ,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAC,OAAmB;QAC/C,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,MAAM,CAAC,KAA2B,CAAC;QACrD,MAAM,MAAM,GAAI,MAAM,CAAC,MAAiB,IAAI,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAA8B,IAAI,SAAS,CAAC;QACpE,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,CAAC;QAE1C,iCAAiC;QACjC,IAAI,WAAyC,CAAC;QAC9C,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,IAAI,IAAA,6BAAqB,EAAC,cAAc,CAAC,EAAE,CAAC;gBACxC,WAAW,GAAG,cAAc,CAAC;YACjC,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,YAAY,CAAC;oBACd,EAAE,EAAE,OAAO,CAAC,EAAE;oBACd,OAAO,EAAE,KAAK;oBACd,QAAQ,EAAE;wBACN,IAAI,EAAE,gBAAgB;wBACtB,OAAO,EAAE,wDAAwD;qBACpE;iBACJ,CAAC,CAAC;gBACH,OAAO;YACX,CAAC;QACL,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;YACb,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,oCAAoC;iBAChD;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;QACjE,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,WAAW;oBACjB,OAAO,EAAE,oBAAoB,SAAS,EAAE;iBAC3C;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,qBAAa,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;YAC1E,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,IAAI;gBACb,MAAM,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE;aAC1D,CAAC,CAAC;QACP,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC;wBACpB,OAAO,EAAG,CAAW,CAAC,OAAO;wBAC7B,KAAK,EAAG,CAAW,CAAC,KAAK;wBACzB,IAAI,EAAG,CAAW,CAAC,IAAI;wBACvB,aAAa,EAAE,OAAO,CAAC;wBACvB,UAAU,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;wBACnD,YAAY,EAAE,CAAC;wBACf,iBAAiB,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;qBACzE,CAAC;iBACL;aACJ,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,OAAmB;QACxC,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,MAAM,CAAC,OAA6B,CAAC;QACzD,MAAM,QAAQ,GAAG,MAAM,CAAC,IAA0B,CAAC;QACnD,MAAM,QAAQ,GAAI,MAAM,CAAC,IAAgC,IAAI,EAAE,CAAC;QAEhE,IAAI,CAAC,WAAW,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC5B,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,iDAAiD;iBAC7D;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,mBAAmB;QACnB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC/C,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,WAAW,CAClC,CAAC;QACF,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,WAAW;oBACjB,OAAO,EAAE,sBAAsB,WAAW,EAAE;iBAC/C;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,gBAAgB;QAChB,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;QAC5D,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,WAAW;oBACjB,OAAO,EAAE,mBAAmB,QAAQ,eAAe,WAAW,EAAE;iBACnE;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,mBAAmB;QACnB,IAAI,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAEtC,qBAAqB;YACrB,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;gBAC5B,MAAM;qBACD,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE;oBAClB,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,WAAW;qBACtB,CAAC,CAAC;gBACP,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;oBACT,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE;4BACN,IAAI,EAAE,YAAY;4BAClB,OAAO,EAAG,CAAW,CAAC,OAAO;yBAChC;qBACJ,CAAC,CAAC;gBACP,CAAC,CAAC,CAAC;YACX,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,YAAY,CAAC;oBACd,EAAE,EAAE,OAAO,CAAC,EAAE;oBACd,OAAO,EAAE,IAAI;oBACb,MAAM;iBACT,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,YAAY;oBAClB,OAAO,EAAG,CAAW,CAAC,OAAO;iBAChC;aACJ,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB,CAAC,OAAmB;QACjD,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,MAAM,CAAC,SAA+B,CAAC;QACzD,MAAM,WAAW,GAAG,MAAM,CAAC,WAAiC,CAAC;QAC7D,MAAM,WAAW,GAAG,MAAM,CAAC,WAAiC,CAAC;QAC7D,MAAM,QAAQ,GAAG,MAAM,CAAC,QAA8B,CAAC;QACvD,MAAM,WAAW,GAAG,MAAM,CAAC,WAAgD,CAAC;QAE5E,+BAA+B;QAC/B,IAAI,CAAC,SAAS,EAAE,CAAC;YACb,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,0CAA0C;iBACtD;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,IAAI,CAAC,WAAW,IAAI,CAAC,WAAW,EAAE,CAAC;YAC/B,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,6DAA6D;iBACzE;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,iBAAiB;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;QACjE,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,WAAW;oBACjB,OAAO,EAAE,oBAAoB,SAAS,EAAE;iBAC3C;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,+CAA+C;QAC/C,IAAI,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC;QACjE,IAAI,CAAC,OAAO,IAAI,WAAW,EAAE,CAAC;YAC1B,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,WAAW;oBACjB,OAAO,EAAE,sBAAsB,WAAW,IAAI,WAAW,aAAa,SAAS,EAAE;iBACpF;aACJ,CAAC,CAAC;YACH,OAAO;QACX,CAAC;QAED,4DAA4D;QAC5D,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC;gBACD,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;gBAC7D,IAAI,gBAAgB,CAAC,KAAK,EAAE,CAAC;oBACzB,IAAI,CAAC,YAAY,CAAC;wBACd,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE;4BACN,IAAI,EAAE,kBAAkB;4BACxB,OAAO,EAAE,gBAAgB,CAAC,KAAe;yBAC5C;qBACJ,CAAC,CAAC;oBACH,OAAO;gBACX,CAAC;YACL,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,IAAI,CAAC,YAAY,CAAC;oBACd,EAAE,EAAE,OAAO,CAAC,EAAE;oBACd,OAAO,EAAE,KAAK;oBACd,QAAQ,EAAE;wBACN,IAAI,EAAE,kBAAkB;wBACxB,OAAO,EAAG,CAAW,CAAC,OAAO;qBAChC;iBACJ,CAAC,CAAC;gBACH,OAAO;YACX,CAAC;QACL,CAAC;QAED,qDAAqD;QACrD,MAAM,OAAO,GAAG,IAAI,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QAEtE,IAAI,CAAC;YACD,6CAA6C;YAC7C,MAAM,WAAW,GAAG,KAAK,IAAI,EAAE;gBAC3B,MAAM,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBAE7C,IAAI,CAAC,YAAY,CAAC;oBACd,EAAE,EAAE,OAAO,CAAC,EAAE;oBACd,OAAO,EAAE,IAAI;oBACb,MAAM,EAAE;wBACJ,SAAS,EAAE,SAAS;wBACpB,WAAW,EAAE,OAAO,CAAC,IAAI;wBACzB,WAAW,EAAE,OAAO,CAAC,WAAW;wBAChC,QAAQ,EAAE,OAAO,CAAC,WAAW,EAAE;wBAC/B,MAAM,EAAE,WAAW;wBACnB,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE;qBAC9B;iBACJ,CAAC,CAAC;YACP,CAAC,CAAA;YACD,WAAW,EAAE,CAAC;YAEd,wCAAwC;YACxC,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,IAAI;gBACb,MAAM,EAAE;oBACJ,SAAS,EAAE,SAAS;oBACpB,WAAW,EAAE,OAAO,CAAC,IAAI;oBACzB,WAAW,EAAE,OAAO,CAAC,WAAW;oBAChC,QAAQ,EAAE,OAAO,CAAC,WAAW,EAAE;oBAC/B,MAAM,EAAE,cAAc;oBACtB,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE;iBAC9B;aACJ,CAAC,CAAC;QACP,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YAET,IAAI,CAAC,YAAY,CAAC;gBACd,EAAE,EAAE,OAAO,CAAC,EAAE;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE;oBACN,IAAI,EAAE,eAAe;oBACrB,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC;wBACpB,OAAO,EAAG,CAAW,CAAC,OAAO;wBAC7B,KAAK,EAAG,CAAW,CAAC,KAAK;wBACzB,IAAI,EAAG,CAAW,CAAC,IAAI;wBACvB,aAAa,EAAE,OAAO,CAAC;wBACvB,UAAU,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;wBACnD,YAAY,EAAE,CAAC;wBACf,iBAAiB,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;qBACzE,CAAC;iBACL;aACJ,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,QAAqB;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACtC,gBAAM,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IAC9B,CAAC;;AAlmBL,kCAomBC;;;AAQD,MAAM,qBAAqB;IAA3B;QACY,WAAM,GAAoB,EAAE,CAAC;QAC7B,SAAI,GAAY,KAAK,CAAC;IA6BlC,CAAC;IA3BG,KAAK,CAAC,KAAa;QACf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACxC,CAAC;IAED,WAAW,CAAC,KAAsB;QAC9B,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;IACL,CAAC;IAED,KAAK,CAAC,IAAI;QACN,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;QACvD,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC5C,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC3B,YAAY,CAAC,CAAC,GAAG,EAAE;oBACf,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;gBACzB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACnB,CAAC,CAAC,CAAC;QACP,CAAC;IACL,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,oBAAoB;IAItB,YACqB,KAAY,EACZ,SAAiB,EACjB,QAAiB;QAFjB,UAAK,GAAL,KAAK,CAAO;QACZ,cAAS,GAAT,SAAS,CAAQ;QACjB,aAAQ,GAAR,QAAQ,CAAS;QAN9B,WAAM,GAAY,IAAI,CAAC;QAQ3B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,MAAsB;QACtC,wCAAwC;QACxC,MAAM,MAAM,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,qBAAa,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAEvE,yCAAyC;QACzC,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACxC,IAAI,EAAE,MAAe;YACrB,OAAO,EAAE,KAAK;SACjB,CAAC,CAAC,CAAC;QAEJ,gEAAgE;QAChE,MAAM,WAAW,GAAG,KAAK,IAAI,EAAE;YAC3B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAE7E,uCAAuC;YACvC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,QAAQ,CAAC;QAE1C,CAAC,CAAA;QAED,WAAW,EAAE,CAAC;QAEd,4FAA4F;QAC5F,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,OAA6B;QACrD,oDAAoD;QACpD,iEAAiE;QACjE,IAAI,CAAC,MAAM,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IACtC,CAAC;IAEM,SAAS;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAEM,WAAW;QACd,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;CACJ","sourcesContent":["import { App } from \"../app\";\nimport { IServer } from \"../Server\";\nimport { stdin, stdout } from \"process\";\nimport { createInterface, Interface } from \"readline\";\nimport { Agent, AgentStreamer, IAgentStreamerWriter } from \"../agent\";\nimport { FileAttachment, InputContent, isFileAttachmentArray, IModelResponseStream, ModelResponse, ModelResponseStreamValue } from \"../models/types\";\nimport { ITriggerInvoker, SerializedHTTPRequest } from \"../trigger/ITrigger\";\n\n/**\n * Request message format from the host CLI\n */\nexport interface IPCRequest {\n    /** Unique request ID for correlation */\n    id: string;\n    /** The method/action to invoke */\n    method: string;\n    /** Optional parameters for the method */\n    body?: Record<string, unknown>;\n}\n\nexport interface IPCResponseError {\n    code: string;\n    message: string;\n}\n/**\n * Response message format sent back to the host CLI\n */\nexport interface IPCResponse {\n    /** Correlates to the request ID */\n    id: string;\n    /** Whether the request was successful */\n    success: boolean;\n    /** The result data (on success) */\n    result?: unknown;\n    /** Error information (on failure) */\n    errorObj?: IPCResponseError;\n}\n\n/**\n * A server that communicates via STDIN/STDOUT using JSON messages.\n * Uses newline-delimited JSON (NDJSON) protocol where each message\n * is a single line of JSON followed by a newline character.\n * \n * Host CLI writes requests to the process's STDIN.\n * This server writes responses to STDOUT.\n * Debug/log messages go to STDERR to avoid polluting the protocol.\n */\nexport class StdInServer implements IServer {\n    private app?: App;\n    private running: boolean = false;\n    private rl?: Interface;\n\n    public constructor() {}\n\n    public accept(app: any): void {\n        this.app = app;\n    }\n\n    public async start(): Promise<void> {\n        if (!this.app) {\n            throw new Error(\"No app registered. Call accept() before start().\");\n        }\n\n        this.running = true;\n\n        // Create readline interface for line-by-line processing\n        this.rl = createInterface({\n            input: stdin,\n            output: undefined, // We write to stdout manually\n            terminal: false,\n        });\n\n        // Handle each line as a JSON message\n        this.rl.on(\"line\", (line: string) => {\n            this.handleLine(line);\n        });\n\n        // Handle stdin close\n        this.rl.on(\"close\", () => {\n            this.running = false;\n        });\n\n        // Send ready signal\n        this.sendResponse({\n            id: \"__ready__\",\n            success: true,\n            result: {\n                name: this.app.name,\n                protocol: \"ndjson\",\n                version: \"1.0\",\n            },\n        });\n\n        // Keep the process alive while running\n        while (this.running) {\n            await new Promise((resolve) => setTimeout(resolve, 100));\n        }\n    }\n\n    public async stop(): Promise<void> {\n        this.running = false;\n        if (this.rl) {\n            this.rl.close();\n        }\n    }\n\n    /**\n     * Process a single line of input\n     */\n    private handleLine(line: string): void {\n        const trimmed = line.trim();\n        if (!trimmed) {\n            return; // Skip empty lines\n        }\n\n        let request: IPCRequest;\n\n        try {\n            request = JSON.parse(trimmed) as IPCRequest;\n        } catch (e) {\n            this.sendResponse({\n                id: \"__parse_error__\",\n                success: false,\n                errorObj: {\n                    code: \"PARSE_ERROR\",\n                    message: `Invalid JSON: ${(e as Error).message}`,\n                },\n            });\n            return;\n        }\n\n        // Validate request format\n        if (!request.id || typeof request.id !== \"string\") {\n            this.sendResponse({\n                id: request.id ?? \"__invalid__\",\n                success: false,\n                errorObj: {\n                    code: \"INVALID_REQUEST\",\n                    message: \"Request must have a string 'id' field\",\n                },\n            });\n            return;\n        }\n\n        if (!request.method || typeof request.method !== \"string\") {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INVALID_REQUEST\",\n                    message: \"Request must have a string 'method' field\",\n                },\n            });\n            return;\n        }\n\n        // Route the request\n        this.handleRequest(request);\n    }\n\n    /**\n     * Route and handle a validated request\n     */\n    private handleRequest(request: IPCRequest): void {\n        try {\n            switch (request.method) {\n                case \"ping\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: { pong: true, timestamp: Date.now(), protocol_version: \"1.0\" },\n                    });\n                    break;\n\n                case \"getAppInfo\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: {\n                            name: this.app!.name,\n                            agentCount: this.app!.agents.length,\n                            toolkitCount: this.app!.toolkits.size,\n                        },\n                    });\n                    break;\n\n                case \"listAgents\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: this.app!.agents.map((agent) => ({\n                            name: agent.name,\n                            systemPrompt: agent.systemPrompt,\n                            model: agent.model,\n                            toolkits: agent.toolkits.map((tk) => tk.name),\n                        })),\n                    });\n                    break;\n\n                case \"listToolkits\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: Array.from(this.app!.toolkits).map((toolkit) => ({\n                            name: toolkit.name,\n                            description: toolkit.description,\n                            tools: toolkit.tools.map((tool) => ({\n                                name: tool.name,\n                                description: tool.description,\n                                args: tool.schema?.properties,\n                            })),\n                        })),\n                    });\n                    break;\n\n                case \"listTriggers\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: this.app!.agents.flatMap((agent) => \n                            agent.triggers.map((trigger) => ({\n                                name: trigger.name,\n                                triggerType: trigger.triggerType,\n                                agentName: agent.name,\n                            }))\n                        ),\n                    });\n                    break;\n\n                case \"listModels\":\n                    // Get unique models from all agents\n                    const modelsMap = new Map<string, { identifier: string; key: { source: string; name: string } }>();\n                    for (const agent of this.app!.agents) {\n                        const model = agent.model as any;\n                        if (model && model.identifier) {\n                            modelsMap.set(model.identifier, {\n                                identifier: model.identifier,\n                                key: model.key,\n                            });\n                        }\n                    }\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: Array.from(modelsMap.values()),\n                    });\n                    break;\n\n                case \"listPrompts\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: this.app!.agents.map((agent) => ({\n                            agentName: agent.name,\n                            systemPrompt: agent.systemPrompt,\n                        })),\n                    });\n                    break;\n\n                case \"listTools\":\n                    // Get all tools from all toolkits\n                    const allTools: Array<{\n                        name: string;\n                        description: string;\n                        args: Record<string, unknown> | undefined;\n                        toolkitName: string;\n                    }> = [];\n                    for (const toolkit of this.app!.toolkits) {\n                        for (const tool of toolkit.tools) {\n                            allTools.push({\n                                name: tool.name,\n                                description: tool.description,\n                                args: tool.schema?.properties,\n                                toolkitName: toolkit.name,\n                            });\n                        }\n                    }\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: allTools,\n                    });\n                    break;\n\n                case \"invokeTool\":\n                    this.handleInvokeTool(request);\n                    break;\n\n                case \"shutdown\":\n                    this.sendResponse({\n                        id: request.id,\n                        success: true,\n                        result: { shutting_down: true },\n                    });\n                    this.stop();\n                    break;\n\n                case \"invokeAgent\":\n                    this.handleInvokeAgent(request);\n                    break;\n\n                case \"invokeTrigger\":\n                    this.handleInvokeTrigger(request);\n                    break;\n\n                default:\n                    this.sendResponse({\n                        id: request.id,\n                        success: false,\n                        errorObj: {\n                            code: \"UNKNOWN_METHOD\",\n                            message: `Unknown method: ${request.method}`,\n                        },\n                    });\n            }\n        } catch (e) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INTERNAL_ERROR\",\n                    message: (e as Error).message,\n                },\n            });\n        }\n    }\n\n    private async handleInvokeAgent(request: IPCRequest): Promise<void> {\n        const params = request.body ?? {};\n        const agentName = params.agent as string | undefined;\n        const prompt = (params.prompt as string) ?? \"\";\n        const threadId = params.threadId as string | undefined ?? undefined;\n        const rawAttachments = params.attachments;\n        \n        // Parse and validate attachments\n        let attachments: FileAttachment[] | undefined;\n        if (rawAttachments !== undefined) {\n            if (isFileAttachmentArray(rawAttachments)) {\n                attachments = rawAttachments;\n            } else {\n                this.sendResponse({\n                    id: request.id,\n                    success: false,\n                    errorObj: {\n                        code: \"INVALID_PARAMS\",\n                        message: \"attachments must be an array of FileAttachment objects\",\n                    },\n                });\n                return;\n            }\n        }\n\n        if (!agentName) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INVALID_PARAMS\",\n                    message: \"invokeAgent requires 'agent' param\",\n                },\n            });\n            return;\n        }\n\n        const agent = this.app!.agents.find((a) => a.name === agentName);\n        if (!agent) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"NOT_FOUND\",\n                    message: `Agent not found: ${agentName}`,\n                },\n            });\n            return;\n        }\n        const streamer = new AgentStreamer(agent, request.id);\n        try {\n            const model = await agent.invoke(prompt, threadId, streamer, attachments);\n            this.sendResponse({\n                id: request.id,\n                success: true,\n                result: { threadId: model.threadId, status: \"invoked\" },\n            });\n        } catch (e) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INTERNAL_ERROR\",\n                    message: JSON.stringify({\n                        message: (e as Error).message,\n                        stack: (e as Error).stack,\n                        name: (e as Error).name,\n                        type_of_error: typeof e,\n                        error_name: e instanceof Error ? e.name : undefined,\n                        error_object: e,\n                        error_constructor: e instanceof Error ? e.constructor.name : undefined,\n                    }),\n                },\n            });\n        }\n    }\n\n    /**\n     * Handle tool invocation request\n     */\n    private handleInvokeTool(request: IPCRequest): void {\n        const params = request.body ?? {};\n        const toolkitName = params.toolkit as string | undefined;\n        const toolName = params.tool as string | undefined;\n        const toolArgs = (params.args as Record<string, unknown>) ?? {};\n\n        if (!toolkitName || !toolName) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INVALID_PARAMS\",\n                    message: \"invokeTool requires 'toolkit' and 'tool' params\",\n                },\n            });\n            return;\n        }\n\n        // Find the toolkit\n        const toolkit = Array.from(this.app!.toolkits).find(\n            (tk) => tk.name === toolkitName\n        );\n        if (!toolkit) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"NOT_FOUND\",\n                    message: `Toolkit not found: ${toolkitName}`,\n                },\n            });\n            return;\n        }\n\n        // Find the tool\n        const tool = toolkit.tools.find((t) => t.name === toolName);\n        if (!tool) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"NOT_FOUND\",\n                    message: `Tool not found: ${toolName} in toolkit ${toolkitName}`,\n                },\n            });\n            return;\n        }\n\n        // Execute the tool\n        try {\n            const result = tool.execute(toolArgs);\n            \n            // Handle async tools\n            if (result instanceof Promise) {\n                result\n                    .then((asyncResult) => {\n                        this.sendResponse({\n                            id: request.id,\n                            success: true,\n                            result: asyncResult,\n                        });\n                    })\n                    .catch((e) => {\n                        this.sendResponse({\n                            id: request.id,\n                            success: false,\n                            errorObj: {\n                                code: \"TOOL_ERROR\",\n                                message: (e as Error).message,\n                            },\n                        });\n                    });\n            } else {\n                this.sendResponse({\n                    id: request.id,\n                    success: true,\n                    result,\n                });\n            }\n        } catch (e) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"TOOL_ERROR\",\n                    message: (e as Error).message,\n                },\n            });\n        }\n    }\n\n    /**\n     * Handle trigger invocation request from the serve command\n     */\n    private async handleInvokeTrigger(request: IPCRequest): Promise<void> {\n        const params = request.body ?? {};\n        const agentName = params.agentName as string | undefined;\n        const triggerName = params.triggerName as string | undefined;\n        const triggerType = params.triggerType as string | undefined;\n        const threadId = params.threadId as string | undefined;\n        const httpRequest = params.httpRequest as SerializedHTTPRequest | undefined;\n\n        // Validate required parameters\n        if (!agentName) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INVALID_PARAMS\",\n                    message: \"invokeTrigger requires 'agentName' param\",\n                },\n            });\n            return;\n        }\n\n        if (!triggerName && !triggerType) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"INVALID_PARAMS\",\n                    message: \"invokeTrigger requires 'triggerName' or 'triggerType' param\",\n                },\n            });\n            return;\n        }\n\n        // Find the agent\n        const agent = this.app!.agents.find((a) => a.name === agentName);\n        if (!agent) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"NOT_FOUND\",\n                    message: `Agent not found: ${agentName}`,\n                },\n            });\n            return;\n        }\n\n        // Find the trigger by name first, then by type\n        let trigger = agent.triggers.find((t) => t.name === triggerName);\n        if (!trigger && triggerType) {\n            trigger = agent.triggers.find((t) => t.triggerType === triggerType);\n        }\n\n        if (!trigger) {\n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"NOT_FOUND\",\n                    message: `Trigger not found: ${triggerName || triggerType} on agent ${agentName}`,\n                },\n            });\n            return;\n        }\n\n        // Validate the trigger arguments if validation is available\n        if (trigger.validate) {\n            try {\n                const validationResult = await trigger.validate(httpRequest);\n                if (validationResult.error) {\n                    this.sendResponse({\n                        id: request.id,\n                        success: false,\n                        errorObj: {\n                            code: \"VALIDATION_ERROR\",\n                            message: validationResult.error as string,\n                        },\n                    });\n                    return;\n                }\n            } catch (e) {\n                this.sendResponse({\n                    id: request.id,\n                    success: false,\n                    errorObj: {\n                        code: \"VALIDATION_ERROR\",\n                        message: (e as Error).message,\n                    },\n                });\n                return;\n            }\n        }\n\n        // Create the trigger invoker with optional thread ID\n        const invoker = new ServerTriggerInvoker(agent, request.id, threadId);\n\n        try {\n            // Activate the trigger with the HTTP request\n            const triggerFunc = async () => {\n                await trigger.activate(httpRequest, invoker);\n\n                this.sendResponse({\n                    id: request.id,\n                    success: true,\n                    result: {\n                        agentName: agentName,\n                        triggerName: trigger.name,\n                        triggerType: trigger.triggerType,\n                        threadId: invoker.getThreadId(),\n                        status: \"completed\",\n                        output: invoker.getOutput(),\n                    },\n                });\n            }\n            triggerFunc();\n\n            // Send success response with the result\n            this.sendResponse({\n                id: request.id,\n                success: true,\n                result: {\n                    agentName: agentName,\n                    triggerName: trigger.name,\n                    triggerType: trigger.triggerType,\n                    threadId: invoker.getThreadId(),\n                    status: \"acknowledged\",\n                    output: invoker.getOutput(),\n                },\n            });\n        } catch (e) {\n            \n            this.sendResponse({\n                id: request.id,\n                success: false,\n                errorObj: {\n                    code: \"TRIGGER_ERROR\",\n                    message: JSON.stringify({\n                        message: (e as Error).message,\n                        stack: (e as Error).stack,\n                        name: (e as Error).name,\n                        type_of_error: typeof e,\n                        error_name: e instanceof Error ? e.name : undefined,\n                        error_object: e,\n                        error_constructor: e instanceof Error ? e.constructor.name : undefined,\n                    }),\n                },\n            });\n        }\n    }\n\n    /**\n     * Send a JSON response to STDOUT\n     */\n    private sendResponse(response: IPCResponse): void {\n        const json = JSON.stringify(response);\n        stdout.write(json + \"\\n\");\n    }\n\n} \n\ninterface TriggerResponse extends ModelResponse {\n    id: string;\n    type: string;\n    success: boolean;\n}\n\nclass TriggerStreamerWriter implements IAgentStreamerWriter, IModelResponseStream {\n    private buffer: ModelResponse[] = [];\n    private done: boolean = false;\n\n    write(value: string): void {\n        this.writeObject(JSON.parse(value));\n    }\n\n    writeObject(value: TriggerResponse): void {\n        if (!this.done) {\n            this.buffer.push(value);\n        }\n        if (value.type === \"overall.completed\") {\n            this.done = true;\n        }\n    }\n\n    async next(): Promise<ModelResponseStreamValue> {\n        if (this.buffer.length > 0) {\n            return { done: false, value: this.buffer.shift() };\n        }\n        if (this.done && this.buffer.length === 0) {\n            return { done: true, value: undefined };\n        } else {\n            return new Promise((resolve) => {\n                setImmediate((() => {\n                    resolve(this.next());\n                }).bind(this));\n            });\n        }\n    }\n}   \n\n/**\n * Trigger invoker that invokes the agent via the server\n */\nclass ServerTriggerInvoker implements ITriggerInvoker {\n    private output: unknown = null;\n    private currentThreadId: string | undefined;\n\n    constructor(\n        private readonly agent: Agent,\n        private readonly requestId: string,\n        private readonly threadId?: string,\n    ) {\n        this.currentThreadId = threadId;\n    }\n\n    public async invoke(prompt: InputContent[]): Promise<IModelResponseStream> {\n        // Create a streamer for this invocation\n        const writer = new TriggerStreamerWriter();\n        const streamer = new AgentStreamer(this.agent, this.requestId, writer);\n        \n        // Build the model content from the input\n        const modelContent = prompt.map((input) => ({\n            role: \"user\" as const,\n            content: input,\n        }));\n\n        // Use the agent's invoke method which handles thread management\n        const startStream = async () => {\n            const model = await this.agent.invoke(modelContent, this.threadId, streamer);\n            \n            // Store the thread ID for the response\n            this.currentThreadId = model.threadId;\n\n        }\n\n        startStream();\n\n        // Return a completed response stream since the actual streaming is handled by AgentStreamer\n        return writer;\n    }\n\n    public async defaultOutcome(_stream: IModelResponseStream): Promise<void> {\n        // The default outcome just stores the stream result\n        // The actual streaming has already been handled by AgentStreamer\n        this.output = { completed: true };\n    }\n\n    public getOutput(): unknown {\n        return this.output;\n    }\n\n    public getThreadId(): string | undefined {\n        return this.currentThreadId;\n    }\n}\n"]}