@norskvideo/norsk-studio-alpha 1.27.0-2025-10-09-e06493b0 → 1.27.0-2025-10-12-efe33298

package/lib/util.agent/runtime.js

@@ -0,0 +1,1241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_nodes_1 = require("@norskvideo/norsk-studio/lib/extension/base-nodes");
+const api_1 = require("@norskvideo/norsk-studio/lib/server/api");
+const path_1 = __importDefault(require("path"));
+const runtime_types_1 = require("@norskvideo/norsk-studio/lib/extension/runtime-types");
+const logging_1 = require("@norskvideo/norsk-studio/lib/server/logging");
+class AgentDefinition {
+    async schemas() {
+        return (0, runtime_types_1.schemaFromTypes)(path_1.default.join(__dirname, 'types.yaml'), {
+            config: 'AgentSettings',
+            state: 'AgentState'
+        });
+    }
+    async instanceRoutes() {
+        return (0, api_1.defineApi)(path_1.default.join(__dirname, 'types.yaml'), {
+            '/memory/working': {
+                get: ({ node }) => (async (_req, res) => {
+                    const result = await node.handleHttpRequest('/memory/working', 'GET');
+                    res.json(result);
+                })
+            },
+            '/memory/persistent': {
+                get: ({ node }) => (async (_req, res) => {
+                    const result = await node.handleHttpRequest('/memory/persistent', 'GET');
+                    res.json(result);
+                })
+            },
+            '/memory/summary': {
+                get: ({ node }) => (async (_req, res) => {
+                    const result = await node.handleHttpRequest('/memory/summary', 'GET');
+                    res.json(result);
+                })
+            },
+            '/status/detailed': {
+                get: ({ node }) => (async (_req, res) => {
+                    const result = await node.handleHttpRequest('/status/detailed', 'GET');
+                    res.json(result);
+                })
+            }
+        });
+    }
+    async create(_norsk, cfg, cb, runtime) {
+        const node = new Agent(cfg, runtime);
+        cb(node);
+    }
+    handleCommand(node, command) {
+        const commandType = command.type;
+        switch (commandType) {
+            case "start_agent": {
+                void node.start();
+                break;
+            }
+            case "stop_agent": {
+                node.stop();
+                break;
+            }
+            case "pause_agent": {
+                node.pause();
+                break;
+            }
+            case "resume_agent": {
+                node.resume();
+                break;
+            }
+            case "assign_task": {
+                break;
+            }
+            case "cancel_task": {
+                break;
+            }
+            case "update_goal": {
+                break;
+            }
+            default: {
+                const _exhaustive = commandType;
+                throw new Error(`Unhandled command type: ${_exhaustive}`);
+            }
+        }
+    }
+}
+exports.default = AgentDefinition;
+class Agent extends base_nodes_1.CustomAutoDuplexNode {
+    config;
+    runtime;
+    isRunning = false;
+    isPaused = false;
+    cycleResetTimer;
+    cyclesThisMinute = 0;
+    totalCycles = 0;
+    memory;
+    initialized = false;
+    timerQueue = [];
+    initializationHistory = [];
+    isExecutingCycle = false;
+    activeTimers = new Map();
+    immediateSubscriptions = new Map();
+    aggregatedSubscriptions = new Map();
+    getAvailableTools() {
+        return [
+            {
+                name: 'studio_agent_setTimer',
+                description: 'Set a timer that triggers after specified seconds',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        timerId: { type: 'string', description: 'Unique ID for this timer' },
+                        delaySeconds: { type: 'number', description: 'How many seconds until timer fires' },
+                        cyclePrompt: { type: 'string', description: 'The detailed prompt for the LLM when this timer fires' },
+                        recurring: { type: 'boolean', description: 'If true, timer repeats every delaySeconds' }
+                    },
+                    required: ['timerId', 'delaySeconds', 'cyclePrompt']
+                },
+                execute: async (args) => {
+                    return await this.handleAgentTool('studio_agent_setTimer', args);
+                }
+            },
+            {
+                name: 'studio_agent_cancelTimer',
+                description: 'Cancel an active timer',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        timerId: { type: 'string', description: 'ID of timer to cancel' }
+                    },
+                    required: ['timerId']
+                },
+                execute: async (args) => {
+                    return await this.handleAgentTool('studio_agent_cancelTimer', args);
+                }
+            },
+            {
+                name: 'studio_agent_subscribeImmediate',
+                description: 'Subscribe to events that need immediate action',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        componentId: { type: 'string', description: 'ID of component to subscribe to' },
+                        eventType: { type: 'string', description: 'Type of event from listEvents' },
+                        cyclePrompt: { type: 'string', description: 'The detailed prompt for the LLM when this event occurs' }
+                    },
+                    required: ['componentId', 'eventType', 'cyclePrompt']
+                },
+                execute: async (args) => {
+                    return await this.handleAgentTool('studio_agent_subscribeImmediate', args);
+                }
+            },
+            {
+                name: 'studio_agent_subscribeAggregated',
+                description: 'Subscribe to high-frequency events for batch analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        subscriptionId: { type: 'string', description: 'Unique ID for this subscription group' },
+                        sources: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    componentId: { type: 'string' },
+                                    eventType: { type: 'string' },
+                                    fieldPath: { type: 'string', description: 'Optional dot notation path to extract specific field (e.g., "levels.rms" for audio levels)' }
+                                },
+                                required: ['componentId', 'eventType']
+                            },
+                            description: 'Events to aggregate, with optional field extraction to reduce context bloat'
+                        },
+                        windowSeconds: { type: 'number', description: 'How often to analyze, e.g., 10' },
+                        retentionSeconds: { type: 'number', description: 'How much history to keep, defaults to window' },
+                        cyclePrompt: { type: 'string', description: 'The detailed prompt for the LLM when analyzing aggregated data' }
+                    },
+                    required: ['subscriptionId', 'sources', 'windowSeconds', 'cyclePrompt']
+                },
+                execute: async (args) => {
+                    return await this.handleAgentTool('studio_agent_subscribeAggregated', args);
+                }
+            },
+            {
+                name: 'studio_agent_unsubscribe',
+                description: 'Remove an event subscription',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        subscriptionId: { type: 'string', description: 'ID to unsubscribe' }
+                    },
+                    required: ['subscriptionId']
+                },
+                execute: async (args) => {
+                    return await this.handleAgentTool('studio_agent_unsubscribe', args);
+                }
+            },
+            {
+                name: 'studio_agent_listSubscriptions',
+                description: 'List all active subscriptions and timers',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                },
+                execute: async (args) => {
+                    return await this.handleAgentTool('studio_agent_listSubscriptions', args);
+                }
+            }
+        ];
+    }
+    constructor(config, runtime) {
+        super(config.id);
+        console.log("AGENT CONSTRUCTOR called - id:", config.id, "goal:", config.goal);
+        this.config = config;
+        this.runtime = runtime;
+        this.cycleResetTimer = setInterval(() => {
+            if (this.cyclesThisMinute == 0)
+                return;
+            this.cyclesThisMinute = 0;
+            this.runtime.updates.raiseEvent({
+                type: 'action_taken',
+                action: {
+                    id: `cycle-reset-${Date.now()}`,
+                    type: 'analysis',
+                    timestamp: new Date().toISOString(),
+                    description: 'Reset cycle counter',
+                    parameters: {
+                        cyclesThisMinute: this.cyclesThisMinute,
+                        totalCycles: this.cyclesThisMinute,
+                        actionType: 'cycle_reset'
+                    },
+                    success: true
+                }
+            });
+        }, 60000);
+        setTimeout(() => {
+            void this.start();
+        }, 1000);
+    }
+    async start() {
+        console.log("AGENT START called - isRunning:", this.isRunning);
+        if (this.isRunning) {
+            console.log("AGENT already running, returning early");
+            return;
+        }
+        console.log("AGENT starting up...");
+        this.isRunning = true;
+        this.isPaused = false;
+        this.isExecutingCycle = true;
+        console.log("AGENT calling initialize()");
+        await this.initialize();
+        console.log("AGENT initialize() completed, initialized =", this.initialized);
+        this.isExecutingCycle = false;
+        console.log("AGENT set isExecutingCycle = false, checking timer queue");
+        if (this.timerQueue.length > 0) {
+            console.log("AGENT has", this.timerQueue.length, "timers in queue, processing...");
+            void this.processTimerQueue();
+        }
+        else {
+            console.log("AGENT timer queue is empty");
+        }
+        this.runtime.updates.raiseEvent({
+            type: 'agent_started',
+            timestamp: new Date().toISOString()
+        });
+    }
+    async initialize() {
+        console.log("AGENT INITIALIZING - componentId:", this.config.id, "goal:", this.config.goal);
+        (0, logging_1.debuglog)("Agent initialization starting", {
+            componentId: this.config.id,
+            goal: this.config.goal,
+            systemPrompt: this.config.systemPrompt.substring(0, 100) + '...',
+            maxCyclesPerMinute: this.config.maxCyclesPerMinute
+        });
+        this.runtime.updates.raiseEvent({
+            type: 'action_taken',
+            action: {
+                id: `init-cycle-${Date.now()}`,
+                type: 'analysis',
+                timestamp: new Date().toISOString(),
+                description: `Initialization cycle ${this.cyclesThisMinute}`,
+                parameters: {
+                    cyclesThisMinute: this.cyclesThisMinute,
+                    totalCycles: this.cyclesThisMinute,
+                    actionType: 'init_cycle'
+                },
+                success: true
+            }
+        });
+        if (!this.runtime.llm?.isAvailable()) {
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: 'LLM is not configured. Please configure OpenAI or Anthropic in settings.'
+            });
+            return;
+        }
+        try {
+            this.memory = await this.runtime.llm.createMemory('component', this.config.id);
+            const now = Math.floor(Date.now() / 1000);
+            await this.memory.store('initialization-time-seconds', now);
+            await this.memory.addToWorking('current-time-seconds', now);
+            const initializationPrompt = `CRITICALLY IMPORTANT: I am an autonomous agent with the following goal: ${this.config.goal}
+
+This is my INITIALIZATION CYCLE. 
+
+My initialization cycle will take place in steps with the user providing one instruction at a time, I will perform only that instruction to completion and then await further input.
+
+I NEED to discover the current workflow and establish my schedule and actions in order to achieve the stated goal.
+
+My capabilities:
+- I can discover components in the workflow using tools
+- I can query component state and execute commands/routes using tools
+- I can monitor events from components
+- I have persistent memory to learn and remember across cycles, this works through the response format and the field 'memory_updates'
+
+${RESPONSE_FORMAT}
+${TOOL_DISCOVERY}
+${TOOL_USAGE}
+
+The End Result of the initialization cycle MUST be:
+
+- I will have decided on a schedule for my actions
+- I will have called the Tools necessary to set the Schedule Callbacks up
+- I will have created Prompts for each of the Schedule Callbacks detailing what steps are necessary
+- I will have stored *all* necessary Tools, Parameters, and Schemas in memory_updates, in order for the Schedule Callbacks to operate without having to perform discovery
+
+  Tool Discovery:
+      I MUST store all the necessary information required to execute the tools necessary for all of the Schedule Callback Prompts in my memory, the Cycle LLM will not have the ability to discover these
+      They should be stored in a JSON array of objects in memory_updates.tools
+      This following fields *must* be present for each type of tool
+        {componentId}_cmd_executeCommand:
+            - toolName: The exact abbreviated tool name (e.g., "osc_gfx_cmd_executeCommand")
+            - originalComponentId: The full component ID (e.g., "on_screen_graphic")
+            - description: The tool's description from discovery
+            - commandName: The command to be invoked
+            - schema: The schema for the 'parameters' of the command that needs to be sent
+            - context: If the discovery has yielded fixed values for parts of the command, I can detail them here
+            - help: A brief decription of *how* to use this tool, including what property the schema belongs to
+        {componentId}_executeRoute:
+            - toolName: The exact abbreviated tool name (e.g., "osc_gfx_active_gfx_POST")
+            - originalComponentId: The full component ID (e.g., "on_screen_graphic")
+            - description: The tool's description from discovery
+            - url: The url to execute
+            - method: The method to use
+            - schema: The schema for the body of POSTs
+            - context: If the discovery has yielded fixed values for parts of the request, I can detail them here
+            - help: A brief decription of *how* to use this tool, including what property the schema belongs to
+
+  Schedule callback:
+      I can either set up timers that will fire every set period of seconds, or I can subscribe to events using tools.
+      A detailed explanation of these will be provided by further prompts, but the result of calling these tools is that
+        - a 'cycle' will start when the callback is invoked, which involves starting a conversation with an LLM - the Cycle LLM
+        - memory will be provided to the Cycle LLM as specified in the field 'memory_updates'
+        - the cycle will loop until the LLM is satisfied it has completed the task specified by I for that schedule callback
+
+  Prompt:
+      I MUST write a prompt for each of the schedule callbacks detailing
+        - What decisions need to be made
+        - What tools need to be used to discover information necessary for that decision
+        - What tools need to be invoked with what parameters in order to execute the result of that decision
+          - The tool name MUST be provided
+          - The commandName/url/method MUST be provided when relevant
+          - The LLM MUST be urged to use the schema provided in memory
+
+I will now WAIT to be prompted STEP BY STEP in order to achieve my initialization. Initialization is not complete until the final prompt, which means the final decision of each step should simply be 'wait'`;
+            console.log("AGENT INIT PHASE 1: Starting initial setup");
+            await this.executeWithToolLooping(initializationPrompt, `init-${Date.now()}`, 'initialization');
+            console.log("AGENT INIT PHASE 1 COMPLETED");
+            const discovery = `First you must discover all of the components, commands, routes, and events that are possibly related to the stated goal
+
+              Discover the components with
+                - workflow_listComponents
+
+              Discover the tools and events for all related components using
+                - {componentId}_cmd_listCommands
+                - {componentId}_listRoutes
+                - {componentId}_evt_listEvents
+
+            Fetch the schemas for commands / routes / events that are related to the stated goal with
+                - {componentId}_cmd_getCommandSchema
+                - {componentId}_cmd_getRouteSchema
+                - {componentId}_evt_getEventSchema
+
+            IMPORTANT: As you discover tools, record in working memory:
+            - Original component ID (e.g., "on_screen_graphic")
+            - Abbreviated tool names (e.g., "osc_gfx_active_gfx_POST")
+            - Tool descriptions (contain full functionality details)
+            - Component types and capabilities
+
+            Tool names are now abbreviated for efficiency. Use descriptions to understand functionality.
+
+        When you are satisfied you have discovered enough information to achieve the stated goal, you can WAIT for further instructions`;
+            console.log("AGENT INIT PHASE 2: Starting discovery");
+            await this.executeWithToolLooping(discovery, `init-${Date.now()}`, 'initialization');
+            console.log("AGENT INIT PHASE 2 COMPLETED");
+            const schedule = `${initializationPrompt} 
+        Using the components, commands, routes, and events that you have already discovered, define a schedule for an LLM to be invoked in order to reach the stated goal
+
+        Help:
+          - Does the goal need to be performed as a reponse to specific event having taken place? Use subscribeImmediate
+          - Does the goal need to measure data from events? Use subscribeAggregated, IMPORTANT: be sure to group all related events into a single subscribe call 
+          - Is the goal purely time based with no event analyis required? Use a timer: IMPORTANT: Timers are set up by calling the appropriate tool, it is *recommended* you store timerids in memory, but not required
+
+        Be very careful not to set up multiple Schedule Callbacks for the same subtask
+          - a classic mis-step is accidentally creating a subscribeAggregated call for 30s of analysis *and* a timer every 30s, that is completely unnecessary.
+          - Another classic mistake is to create multiple subscribeAggregated calls for the same task, ideally only one aggregated subscribe will exist for all related analysis
+
+        For subscribeAggregated calls, be careful to, if possible, use field extraction to only take the values that are needed in order for analysis to take place. In this case, the prompt MUST  
+        specify what it is the LLM is to expect, and *how* to perform analysis on it
+
+        If you end up creating obsolete subscriptions, be sure to remove them with
+          - studio_agent_unsubscribe 
+
+        For any schedule defined, CRITICAL: write a Prompt for the LLM that will be invoked as part of that schedule
+          - remembering to detail the decisions/outcome of the callback
+          - tools that must be used
+          - *how* to use the tools that must be used, including how to use the properties/schema to generate a correct request
+
+      Call the appropriate tools to set up the Schedule Callbacks, CRITICAL: Provide the Prompts that have been defined for each callback.
+
+      Once this is done, you can WAIT for further instructions`;
+            console.log("AGENT INIT PHASE 3: Starting schedule setup");
+            await this.executeWithToolLooping(schedule, `init-${Date.now()}`, 'initialization');
+            console.log("AGENT INIT PHASE 3 COMPLETED");
+            const memory = `Using the components, commands, routes, and events that you have already discovered, and schedule you have defined
+
+          - Verify that you have indeed set up the Schedule Callbacks with the Prompts that were defined for each callback
+          - Store in memory_updates
+            - components: The components you have discovered that are relevant to this task
+            - tools: The tools that are needed for each Schedule Callback, along with their parameters + schemas as initially outlined
+
+        Be sure not to store more tools than are needed, two ways of doing the same thing (IE a Command or HTTP request) is unnecessary. Prefer commands over HTTP in these cases.
+        Be sure not to store events that aren't needed
+        If a subscribeAggregate is set up for analysis, and routes are in memory that contain similar information, ensure to add to the Schedule Callback Prompt a directive to ignore the route data for disambiguation
+
+        If you've already set these properties, then perform a memory_update with the tools/components again but with the duplicate/obsolete items removed.
+      `;
+            console.log("AGENT INIT PHASE 4: Starting memory optimization");
+            await this.executeWithToolLooping(memory, `init-${Date.now()}`, 'initialization');
+            console.log("AGENT INIT PHASE 4 COMPLETED");
+            const verify = `This is the final step of initialization, you MUST verify that
+          - You have set up the necessary Schedule Callbacks with the Prompts that were defined for each callback
+          - You have stored the necessary components in memory_updates
+          - You have stored the tools in memory_updates along with their parameters + schemas
+
+        If all of things have been done already, you can stop immediately.
+
+        Once this step is complete, it will be down to the Cycle LLM to perform the stated goal and they will only have access to the memory you have created and the prompts in the Scheduled Callbacks
+      `;
+            console.log("AGENT INIT PHASE 5: Starting verification");
+            await this.executeWithToolLooping(verify, `init-${Date.now()}`, 'initialization');
+            console.log("AGENT INIT PHASE 5 COMPLETED - INITIALIZATION FINISHED");
+            this.initialized = true;
+            console.log("AGENT initialization complete, setting initialized =", this.initialized);
+            (0, logging_1.debuglog)("Agent initialization completed", {
+                componentId: this.config.id,
+                persistent_memory: await this.memory.summarizePersistent(),
+                working_memory: await this.memory.summarizeWorking(),
+                active_timers: this.activeTimers.size,
+                timer_queue: this.timerQueue.length,
+                goal: this.config.goal
+            });
+        }
+        catch (error) {
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: error instanceof Error ? error.message : 'Failed to initialize agent'
+            });
+        }
+    }
+    stop() {
+        if (!this.isRunning)
+            return;
+        this.isRunning = false;
+        this.isPaused = false;
+        for (const [timerId] of this.activeTimers) {
+            this.cancelTimer(timerId);
+        }
+        this.timerQueue = [];
+        this.initializationHistory = [];
+        this.initialized = false;
+        for (const [subscriptionId] of this.immediateSubscriptions) {
+            this.unsubscribeEvent(subscriptionId);
+        }
+        for (const [subscriptionId] of this.aggregatedSubscriptions) {
+            this.unsubscribeEvent(subscriptionId);
+        }
+        this.runtime.updates.raiseEvent({
+            type: 'agent_stopped',
+            timestamp: new Date().toISOString()
+        });
+    }
+    pause() {
+        this.isPaused = true;
+    }
+    resume() {
+        this.isPaused = false;
+    }
+    async handleHttpRequest(url, method) {
+        if (!this.memory) {
+            return { error: 'Agent memory not initialized' };
+        }
+        try {
+            switch (`${method.toUpperCase()} ${url}`) {
+                case 'GET /memory/working': {
+                    const working = await this.memory.getWorking();
+                    return {
+                        type: 'working_memory',
+                        data: working,
+                        timestamp: new Date().toISOString()
+                    };
+                }
+                case 'GET /memory/persistent': {
+                    const persistent = await this.memory.getPersistent();
+                    return {
+                        type: 'persistent_memory',
+                        data: persistent,
+                        timestamp: new Date().toISOString()
+                    };
+                }
+                case 'GET /memory/summary': {
+                    const working = await this.memory.getWorking();
+                    const persistent = await this.memory.getPersistent();
+                    return {
+                        type: 'memory_summary',
+                        working_memory: working,
+                        persistent_memory: persistent,
+                        timestamp: new Date().toISOString()
+                    };
+                }
+                case 'GET /status/detailed': {
+                    const working = await this.memory.getWorking();
+                    const persistent = await this.memory.getPersistent();
+                    return {
+                        type: 'detailed_status',
+                        agent_status: {
+                            is_running: this.isRunning,
+                            is_paused: this.isPaused,
+                            initialized: this.initialized,
+                            cycles_this_minute: this.cyclesThisMinute,
+                            total_cycles: this.totalCycles,
+                        },
+                        goal: this.config.goal,
+                        system_prompt: this.config.systemPrompt,
+                        memory: {
+                            working: working,
+                            persistent: persistent
+                        },
+                        timestamp: new Date().toISOString()
+                    };
+                }
+                default:
+                    return { error: `Unknown endpoint: ${method} ${url}` };
+            }
+        }
+        catch (error) {
+            return {
+                error: `Failed to handle request: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    async makeDecision(cyclePrompt, additionalMemoryValues) {
+        console.log("AGENT makeDecision called - cyclePrompt:", cyclePrompt.substring(0, 100));
+        (0, logging_1.debuglog)("=== MAKE DECISION CALLED ===", {
+            cyclePrompt: cyclePrompt.substring(0, 100),
+            additionalMemoryValues: Object.keys(additionalMemoryValues || {}),
+            currentCycles: this.cyclesThisMinute,
+            totalCycles: this.totalCycles,
+            isExecutingCycle: this.isExecutingCycle
+        });
+        this.cyclesThisMinute++;
+        this.totalCycles++;
+        if (this.cyclesThisMinute > (this.config.maxCyclesPerMinute ?? 6)) {
+            (0, logging_1.warninglog)("Too many cycles in one minute, skipping work", {
+                cyclesThisMinute: this.cyclesThisMinute,
+                maxCyclesPerMinute: this.config.maxCyclesPerMinute
+            });
+            return;
+        }
+        if (!this.memory) {
+            (0, logging_1.debuglog)("No memory available, aborting decision");
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: 'Agent memory not initialized'
+            });
+            return;
+        }
+        if (this.isExecutingCycle) {
+            (0, logging_1.debuglog)("Already executing cycle, returning early");
+            return;
+        }
+        (0, logging_1.debuglog)("Setting isExecutingCycle = true, starting decision");
+        this.isExecutingCycle = true;
+        try {
+            const now = Math.floor(Date.now() / 1000);
+            await this.memory.addToWorking('current-time-seconds', now);
+            await this.memory.addToWorking('total-cycles', this.totalCycles);
+            await this.memory.addToWorking('cycles-this-minute', this.cyclesThisMinute);
+            if (additionalMemoryValues) {
+                for (const [key, value] of Object.entries(additionalMemoryValues)) {
+                    if (key !== 'timer_events' && key !== 'immediate_events') {
+                        await this.memory.addToWorking(key, value);
+                    }
+                }
+            }
+            let prompt = `CONTEXT:
+CRITICALLY IMPORTANT: Overall Goal: ${this.config.goal}
+
+The current time is in memory, with the key 'current-time-seconds'.`;
+            prompt += `
+
+🎯 SPECIFIC TASK FOR THIS CYCLE:
+${cyclePrompt}
+
+CRITICAL: This cycle prompt above is your PRIMARY DIRECTIVE. Focus exclusively on this specific task. All tool usage must align with completing this specific task.`;
+            prompt += `
+
+DECISION CRITERIA:
+- Handle any timer_events that have fired - these represent scheduled actions
+- Handle any immediate_events from components - these need quick response
+- Process any aggregated event data that's ready for analysis
+- If nothing needs to be done right now, that's fine - just document your decision
+- CRITICAL: Your 'decision' field must accurately reflect what you're actually doing
+
+TOOL EXECUTION: You must use only the tools you already know about in your persistent memory. DO NOT USE any other tools.
+
+  ${TOOL_USAGE}
+
+🔍 SCHEMA ADHERENCE IS MANDATORY:
+- Use the schemas provided in the your persistent memory for request body / command parameters
+  - Every parameter must match the schema type and requirements EXACTLY  
+  - Do NOT guess parameter values - use the schema as your authoritative guide
+  - If a schema specifies required fields, ALL required fields MUST be provided
+
+If you end up having to perform discovery, you MUST store any relevant findings in memory_updates.findings for future cycles
+
+  ${RESPONSE_FORMAT}
+  `;
+            (0, logging_1.debuglog)("About to call executeWithToolLooping for decision");
+            await this.executeWithToolLooping(prompt, `decision-${Date.now()}`, 'decision');
+            (0, logging_1.debuglog)("executeWithToolLooping completed for decision");
+        }
+        catch (error) {
+            (0, logging_1.debuglog)("Error in makeDecision", { error: error instanceof Error ? error.message : error });
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: error instanceof Error ? error.message : 'Unknown error during decision making'
+            });
+        }
+        finally {
+            (0, logging_1.debuglog)("=== MAKE DECISION COMPLETED, setting isExecutingCycle = false ===");
+            this.isExecutingCycle = false;
+        }
+    }
+    async parseStructuredResponse(content) {
+        try {
+            const jsonMatch = content.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    setTimer(timerId, delaySeconds, cyclePrompt, recurring = false) {
+        this.cancelTimer(timerId);
+        const fireTimer = () => {
+            this.timerQueue.push({
+                timerId,
+                cyclePrompt,
+                firedAt: new Date().toISOString(),
+                recurring,
+                delaySeconds
+            });
+            if (!this.isExecutingCycle) {
+                void this.processTimerQueue();
+            }
+        };
+        const timeout = setTimeout(fireTimer, delaySeconds * 1000);
+        this.activeTimers.set(timerId, { timeout, recurring, delaySeconds, cyclePrompt });
+    }
+    cancelTimer(timerId) {
+        const timer = this.activeTimers.get(timerId);
+        if (timer) {
+            clearTimeout(timer.timeout);
+            this.activeTimers.delete(timerId);
+        }
+    }
+    async subscribeImmediate(componentId, eventType, cyclePrompt) {
+        const subscriptionId = `immediate_${componentId}_${eventType}`;
+        this.unsubscribeEvent(subscriptionId);
+        const callback = async (event) => {
+            if (event && event.type === eventType) {
+                if (!this.isExecutingCycle) {
+                    void this.processImmediateEvent(componentId, eventType, cyclePrompt, event);
+                }
+                else {
+                    void this.processImmediateEvent(componentId, eventType, cyclePrompt, event);
+                }
+            }
+        };
+        this.runtime.shared.subscribeToComponentEvents(componentId, callback);
+        this.immediateSubscriptions.set(subscriptionId, {
+            componentId,
+            eventType,
+            cyclePrompt,
+            callback
+        });
+    }
+    async processImmediateEvent(componentId, eventType, cyclePrompt, event) {
+        if (!this.memory)
+            return;
+        const additionalMemoryValues = {};
+        const immediateEvents = [{ componentId, eventType, cyclePrompt, payload: event, timestamp: new Date().toISOString() }];
+        additionalMemoryValues.immediate_events = immediateEvents;
+        if (!this.isExecutingCycle) {
+            (0, logging_1.debuglog)("processImmediateEvent triggering makeDecision", {
+                componentId,
+                eventType,
+                cyclePrompt: cyclePrompt.substring(0, 50)
+            });
+            await this.makeDecision(cyclePrompt, additionalMemoryValues);
+        }
+        else {
+            (0, logging_1.debuglog)("processImmediateEvent skipped - already executing cycle", {
+                componentId,
+                eventType
+            });
+        }
+    }
+    extractFieldFromPayload(payload, fieldPath) {
+        if (!fieldPath || !payload || typeof payload !== 'object') {
+            return payload;
+        }
+        const parts = fieldPath.split('.');
+        let current = payload;
+        for (const part of parts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                return payload;
+            }
+        }
+        return current;
+    }
+    subscribeAggregated(subscriptionId, sources, windowSeconds, retentionSeconds, cyclePrompt) {
+        this.unsubscribeEvent(subscriptionId);
+        const eventBuffer = new Map();
+        const callbacks = [];
+        const componentSources = new Map();
+        for (const source of sources) {
+            if (!componentSources.has(source.componentId)) {
+                componentSources.set(source.componentId, []);
+            }
+            componentSources.get(source.componentId).push({ eventType: source.eventType, fieldPath: source.fieldPath });
+            const sourceKey = `${source.componentId}_${source.eventType}`;
+            eventBuffer.set(sourceKey, []);
+        }
+        for (const [componentId, eventTypesWithPaths] of componentSources) {
+            const callback = async (event) => {
+                if (event) {
+                    const eventType = event.type;
+                    const matchingSource = eventTypesWithPaths.find(s => s.eventType === eventType);
+                    if (matchingSource) {
+                        const sourceKey = `${componentId}_${eventType}`;
+                        const now = Date.now();
+                        const buffer = eventBuffer.get(sourceKey) || [];
+                        const extractedPayload = this.extractFieldFromPayload(event, matchingSource.fieldPath);
+                        buffer.push({ payload: extractedPayload, timestamp: now });
+                        const cutoffTime = now - (retentionSeconds * 1000);
+                        const filteredBuffer = buffer.filter(e => e.timestamp > cutoffTime);
+                        eventBuffer.set(sourceKey, filteredBuffer);
+                    }
+                }
+            };
+            this.runtime.shared.subscribeToComponentEvents(componentId, callback);
+            callbacks.push({ componentId, callback });
+        }
+        this.aggregatedSubscriptions.set(subscriptionId, {
+            sources,
+            windowSeconds,
+            retentionSeconds,
+            cyclePrompt,
+            lastProcessedAt: Date.now(),
+            eventBuffer,
+            callbacks
+        });
+        this.setTimer(`aggregated_${subscriptionId}`, windowSeconds, `Process aggregated data for ${subscriptionId}`, true);
+    }
+    unsubscribeEvent(subscriptionId) {
+        if (subscriptionId.startsWith('immediate_')) {
+            const subscription = this.immediateSubscriptions.get(subscriptionId);
+            if (subscription) {
+                this.runtime.shared.unsubscribeToComponentEvents(subscription.componentId, subscription.callback);
+                this.immediateSubscriptions.delete(subscriptionId);
+            }
+        }
+        const aggregatedSub = this.aggregatedSubscriptions.get(subscriptionId);
+        if (aggregatedSub) {
+            for (const { componentId, callback } of aggregatedSub.callbacks) {
+                this.runtime.shared.unsubscribeToComponentEvents(componentId, callback);
+            }
+            this.cancelTimer(`aggregated_${subscriptionId}`);
+            this.aggregatedSubscriptions.delete(subscriptionId);
+        }
+    }
+    async processTimerQueue() {
+        (0, logging_1.debuglog)("processTimerQueue called", {
+            isExecutingCycle: this.isExecutingCycle,
+            queueLength: this.timerQueue.length,
+            queueTimers: this.timerQueue.map(t => ({ id: t.timerId, prompt: t.cyclePrompt.substring(0, 30) }))
+        });
+        if (this.isExecutingCycle || this.timerQueue.length === 0) {
+            (0, logging_1.debuglog)("processTimerQueue early return", {
+                isExecutingCycle: this.isExecutingCycle,
+                queueLength: this.timerQueue.length
+            });
+            return;
+        }
+        (0, logging_1.debuglog)("processTimerQueue setting isExecutingCycle = true");
+        this.isExecutingCycle = true;
+        try {
+            const timer = this.timerQueue.shift();
+            const additionalMemoryValues = {};
+            if (this.memory) {
+                const timerEvents = [{
+                        timerId: timer.timerId,
+                        cyclePrompt: timer.cyclePrompt,
+                        firedAt: timer.firedAt
+                    }];
+                additionalMemoryValues.timer_events = timerEvents;
+                if (timer.timerId.startsWith('aggregated_')) {
+                    const subscriptionId = timer.timerId.replace('aggregated_', '');
+                    const subscription = this.aggregatedSubscriptions.get(subscriptionId);
+                    if (subscription) {
+                        const aggregatedData = {};
+                        for (const [sourceKey, buffer] of subscription.eventBuffer) {
+                            aggregatedData[sourceKey] = [...buffer];
+                        }
+                        await this.memory.store(subscriptionId, aggregatedData);
+                        subscription.lastProcessedAt = Date.now();
+                    }
+                }
+            }
+            (0, logging_1.debuglog)("processTimerQueue triggering makeDecision", {
+                timerId: timer.timerId,
+                cyclePrompt: timer.cyclePrompt.substring(0, 50),
+                recurring: timer.recurring,
+                delaySeconds: timer.delaySeconds
+            });
+            await this.makeDecision(timer.cyclePrompt, additionalMemoryValues);
+            if (timer.recurring && timer.delaySeconds) {
+                const fireTimer = () => {
+                    this.timerQueue.push({
+                        timerId: timer.timerId,
+                        cyclePrompt: timer.cyclePrompt,
+                        firedAt: new Date().toISOString(),
+                        recurring: timer.recurring,
+                        delaySeconds: timer.delaySeconds
+                    });
+                    if (!this.isExecutingCycle) {
+                        void this.processTimerQueue();
+                    }
+                };
+                const timeout = setTimeout(fireTimer, timer.delaySeconds * 1000);
+                this.activeTimers.set(timer.timerId, {
+                    timeout,
+                    recurring: timer.recurring,
+                    delaySeconds: timer.delaySeconds,
+                    cyclePrompt: timer.cyclePrompt
+                });
+            }
+        }
+        catch (error) {
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: error instanceof Error ? error.message : 'Timer processing error'
+            });
+        }
+        finally {
+            (0, logging_1.debuglog)("processTimerQueue finally block - setting isExecutingCycle = false", {
+                remainingQueueLength: this.timerQueue.length
+            });
+            this.isExecutingCycle = false;
+            if (this.timerQueue.length > 0) {
+                (0, logging_1.debuglog)("processTimerQueue scheduling next timer processing");
+                void this.processTimerQueue();
+            }
+            else {
+                (0, logging_1.debuglog)("processTimerQueue no more timers to process");
+            }
+        }
+    }
+    async executeTool(name, args) {
+        return this.handleAgentTool(name, args);
+    }
+    async handleAgentTool(toolName, args) {
+        switch (toolName) {
+            case 'studio_agent_subscribeImmediate': {
+                const { componentId, eventType, cyclePrompt } = args;
+                if (!componentId || !eventType || !cyclePrompt) {
+                    throw new Error('Missing required fields: componentId, eventType, cyclePrompt');
+                }
+                await this.subscribeImmediate(componentId, eventType, cyclePrompt);
+                return {
+                    success: true,
+                    message: `Subscribed to immediate events: ${eventType} from ${componentId}`,
+                    subscriptionId: `immediate_${componentId}_${eventType}`
+                };
+            }
+            case 'studio_agent_subscribeAggregated': {
+                const { subscriptionId, sources, windowSeconds, retentionSeconds, cyclePrompt } = args;
+                if (!subscriptionId || !sources || !windowSeconds || !cyclePrompt) {
+                    throw new Error('Missing required fields: subscriptionId, sources, windowSeconds, cyclePrompt');
+                }
+                const retention = retentionSeconds || windowSeconds;
+                this.subscribeAggregated(subscriptionId, sources, windowSeconds, retention, cyclePrompt);
+                return {
+                    success: true,
+                    message: `Created aggregated subscription: ${subscriptionId}`,
+                    subscriptionId,
+                    sourcesCount: sources.length
+                };
+            }
+            case 'studio_agent_unsubscribe': {
+                const { subscriptionId } = args;
+                if (!subscriptionId) {
+                    throw new Error('Missing required field: subscriptionId');
+                }
+                this.unsubscribeEvent(subscriptionId);
+                return {
+                    success: true,
+                    message: `Unsubscribed from: ${subscriptionId}`
+                };
+            }
+            case 'studio_agent_setTimer': {
+                const { timerId, delaySeconds, cyclePrompt, recurring } = args;
+                if (!timerId || !delaySeconds || !cyclePrompt) {
+                    throw new Error('Missing required fields: timerId, delaySeconds, cyclePrompt');
+                }
+                this.setTimer(timerId, delaySeconds, cyclePrompt, recurring || false);
+                return {
+                    success: true,
+                    message: `Timer set: ${timerId} will fire in ${delaySeconds}s`,
+                    timerId,
+                    delaySeconds,
+                    recurring: recurring || false
+                };
+            }
+            case 'studio_agent_cancelTimer': {
+                const { timerId } = args;
+                if (!timerId) {
+                    throw new Error('Missing required field: timerId');
+                }
+                this.cancelTimer(timerId);
+                return {
+                    success: true,
+                    message: `Timer cancelled: ${timerId}`
+                };
+            }
+            case 'studio_agent_listSubscriptions': {
+                const timers = Array.from(this.activeTimers.entries()).map(([id, timer]) => ({
+                    timerId: id,
+                    recurring: timer.recurring,
+                    delaySeconds: timer.delaySeconds,
+                    cyclePrompt: timer.cyclePrompt
+                }));
+                const immediate = Array.from(this.immediateSubscriptions.entries()).map(([id, sub]) => ({
+                    subscriptionId: id,
+                    componentId: sub.componentId,
+                    eventType: sub.eventType,
+                    cyclePrompt: sub.cyclePrompt
+                }));
+                const aggregated = Array.from(this.aggregatedSubscriptions.entries()).map(([id, sub]) => ({
+                    subscriptionId: id,
+                    sources: sub.sources,
+                    windowSeconds: sub.windowSeconds,
+                    retentionSeconds: sub.retentionSeconds,
+                    cyclePrompt: sub.cyclePrompt
+                }));
+                const totalCount = timers.length + immediate.length + aggregated.length;
+                return {
+                    immediate,
+                    aggregated,
+                    timers,
+                    message: totalCount > 0 ? `${totalCount} active subscription(s) and timer(s)` : 'No active subscriptions or timers'
+                };
+            }
+            default:
+                throw new Error(`Unknown agent tool: ${toolName}`);
+        }
+    }
+    async executeWithToolLooping(initialPrompt, actionId, cycleType) {
+        console.log("AGENT executeWithToolLooping called - cycleType:", cycleType, "prompt:", initialPrompt.substring(0, 100));
+        console.log("AGENT executeWithToolLooping - ENTRY POINT");
+        if (!this.memory) {
+            console.log("AGENT no memory available!");
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: 'Agent memory not initialized'
+            });
+            return;
+        }
+        try {
+            let systemPrompt = this.config.systemPrompt;
+            let messages = [];
+            if (cycleType === 'initialization') {
+                this.initializationHistory.push({
+                    role: 'user',
+                    content: initialPrompt
+                });
+                messages = [...this.initializationHistory];
+            }
+            else {
+                const persistentMemory = await this.memory.summarizePersistent();
+                if (persistentMemory) {
+                    systemPrompt += `\n\nPersistent Memory (tools and components discovered during initialization):\n${persistentMemory}`;
+                }
+                messages = [
+                    {
+                        role: 'user',
+                        content: initialPrompt
+                    }
+                ];
+            }
+            const workflowOptions = {
+                systemPrompt,
+                temperature: 0.3,
+                maxTokens: 2000,
+                toolProviders: [this],
+                messages,
+                onToolExecution: (toolName, args) => {
+                    console.log(`AGENT TOOL EXECUTION: ${toolName}`, args);
+                }
+            };
+            console.log("AGENT DEBUG - executeWorkflowRequest being called with:");
+            console.log("- cycleType:", cycleType);
+            console.log("- systemPrompt length:", systemPrompt.length);
+            console.log("- messages count:", messages.length);
+            console.log("- toolProviders count:", workflowOptions.toolProviders.length);
+            console.log("- messages:", JSON.stringify(messages, null, 2));
+            console.log("AGENT - About to call executeWorkflowRequest");
+            const result = await this.runtime.llm.executeWorkflowRequest(initialPrompt, this.memory, workflowOptions);
+            console.log("AGENT - executeWorkflowRequest completed");
+            console.log("AGENT LLM RESPONSE - toolCallsExecuted:", result.toolCallsExecuted);
+            console.log("AGENT LLM RESPONSE - stepLimitReached:", result.stepLimitReached);
+            console.log("AGENT LLM RESPONSE - content length:", result.content?.length || 0);
+            console.log("AGENT LLM RESPONSE - content:", result.content);
+            const structuredResponse = await this.parseStructuredResponse(result.content);
+            if (structuredResponse?.memory_updates) {
+                for (const [key, value] of Object.entries(structuredResponse.memory_updates)) {
+                    if (value !== undefined && value !== null) {
+                        (0, logging_1.debuglog)("Storing memory", { key, value });
+                        await this.memory.store(key, value);
+                    }
+                }
+            }
+            if (cycleType === 'initialization') {
+                this.initializationHistory.push({
+                    role: 'assistant',
+                    content: result.content
+                });
+            }
+            this.runtime.updates.raiseEvent({
+                type: 'action_taken',
+                action: {
+                    id: actionId,
+                    type: cycleType === 'initialization' ? 'analysis' : 'analysis',
+                    timestamp: new Date().toISOString(),
+                    description: structuredResponse?.decision || result.content || `${cycleType} completed`,
+                    result: structuredResponse ? { structured_response: structuredResponse } : { raw_response: result.content },
+                    parameters: { toolCallsExecuted: result.toolCallsExecuted || 0, cycleType },
+                    success: true
+                }
+            });
+            if (structuredResponse?.why) {
+                await this.memory?.store('last-cycle-why', structuredResponse.why);
+            }
+            if (structuredResponse?.decision) {
+                await this.memory?.store('last-cycle-decision', structuredResponse.decision);
+            }
+            console.log("AGENT executeWithToolLooping completed successfully");
+        }
+        catch (error) {
+            console.log("AGENT executeWithToolLooping caught error:", error);
+            this.runtime.updates.raiseEvent({
+                type: 'error_occurred',
+                error: error instanceof Error ? error.message : 'Unknown error during tool execution'
+            });
+            throw error;
+        }
+    }
+}
+const RESPONSE_FORMAT = `
+    IMPORTANT: You must respond in the following JSON format for ALL responses (specified below as a typescript record for convenience):
+
+    BEFORE FILLING THIS JSON: First calculate your final decision. If action is NOT due yet, your decision MUST be "wait" or "not to act".
+    IMPORTANT: DO NOT INCLUDE THE COMMENTS, RESULTM MUST BE VALID JSON
+    
+    {
+      /* ANALYSIS FIRST: Calculate timing and scheduling and determine if action is due
+         Show your calculations here - current time, last executed time, difference, required interval, data thresholds, etc
+         This determines what your decision will be */
+      why: string,
+      
+      /* Based on the analysis above, what did you ACTUALLY decide?
+        - If calculation shows action is NOT due: "I decided to wait for the next cycle"
+        - If calculation shows action IS due: "I decided to [specific action]"
+        - MUST match the conclusion from your 'why' analysis above */
+      decision: string,
+
+      /* the category of the decision made/action taken, if execute_task is returned then native function calling for any tools needed should be used to execute it 
+          - execute_task: We will loop again and allow you to perform actions
+          - discovery: We will loop again and allow you to perform actions
+          - wait: We will stop looping and wait for the next cycle
+          - finished: We will stop looping and wait for the next cycle
+      */
+      action_type: 'execute_task' | 'monitor' | 'wait' | 'discovery' | 'finished',
+
+      /* CRITICAL FOR INITIALIZATION: Store discovered components, routes 
+         Example keys:
+         - components: JSON array of component ids/types that are relevant to this agent's job
+         - tools: JSON array of the tools necessary to do this agent's job
+         - findings: An array that should be appended to with any useful information that is discovered during a cycle
+      memory_updates: {
+          components?: { id: string, type: string }[],
+          active_timers?: { id: string, name: string }[],
+          active_subscriptions?: { id: string, name: string }[],
+          tools?: { 
+            name: string,
+            description: string,
+            componentId: string,
+            commandName?: string,
+            url?: string,
+            method?: string,
+            schema?: string,
+            context?: string
+          }[],
+          findings: string[]
+        }
+
+      /* Current status of this session*/
+      status: 'analyzing' | 'executing' | 'monitoring' | 'waiting'
+    }
+
+    Respond ONLY with this valid JSON. Use native function calling for any tools you need to execute. If you say you are going to execute a tool, then make sure you include the native function calls alongside this response`;
+const TOOL_USAGE = `USING THESE TOOLS:
+ IMPORTANT: 
+  If commandName is present, it is likely an executeCommand tool
+  If url/method are present, it is likely an executeRoute tool
+
+ - When using executeCommand tools, the parameters are
+    - parameters: The actual body of the command, this is what the Schema defines
+    - commandName: The name of the command to execute, this is mandatory
+
+ - When using executeRoute tools, the parameters are
+    - body: The actual body of the command, this is what the Schema defines
+    - url: The url of the route to execute, this is mandatory
+    - method: The method of the route to execute, this is mandatory
+
+ - Prefer executeCommand over executeRoute when both are available
+ - Use executeRoute When executeCommand is not available or doesn't have the needed functionality
+`;
+const TOOL_DISCOVERY = `
+CRITICAL TOOL RULES:
+- Tools CANNOT be guessed or assumed - they MUST be discovered
+- Component IDs are NOT predictable - you MUST discover them first
+- If a tool call fails with "not found", you haven't discovered it properly
+- If a tool does not exist in the list, it does not exist, DO NOT INVENT tools
+
+AGENT-SPECIFIC TOOLS (Always Available):
+  These tools are provided by the agent itself for event management:
+  All parameters are MANDATORY
+
+1. studio_agent_subscribeImmediate - Subscribe to events that need immediate action
+   Parameters:
+   - componentId: string (ID of component to subscribe to)
+   - eventType: string (Type of event from listEvents)
+   - cyclePrompt: string (The prompt for the Cycle LLM when this callback is invoked)
+   NOTE: When these events fire, they'll appear in working memory as 'immediate_events'
+   
+2. studio_agent_subscribeAggregated - Subscribe to high-frequency events for batch analysis
+   Parameters:
+   - subscriptionId: string (Unique ID for this subscription group)
+   - sources: Array<{componentId: string, eventType: string, fieldPath?: string}> (Events to aggregate)
+   - windowSeconds: number (How often to analyze, e.g., 10)
+   - retentionSeconds?: number (How much history to keep, defaults to window)
+   - cyclePrompt: string (The prompt for the Cycle LLM when this callback is invoked)
+   - fieldPath: string (Optional dot notation path like "levels.rms" to extract specific data and reduce context bloat)
+   NOTE: Every windowSeconds, aggregated data will appear in working memory under the subscriptionId
+   FIELD EXTRACTION: Use fieldPath to extract specific data like "levels.rms" from audio level events
+   
+3. studio_agent_unsubscribe - Remove an event subscription
+   Parameters:
+   - subscriptionId: string (ID to unsubscribe)
+   
+4. studio_agent_setTimer - Set a timer that triggers after specified seconds
+   Parameters:
+   - timerId: string (Unique ID for this timer)
+   - delaySeconds: number (How many seconds until timer fires)
+   - cyclePrompt: string (The prompt for the Cycle LLM when this callback is invoked)
+   - recurring?: boolean (If true, timer repeats every delaySeconds)
+   NOTE: When timer fires, it appears in working memory as 'timer_events'
+   
+5. studio_agent_cancelTimer - Cancel an active timer
+   Parameters:
+   - timerId: string (ID of timer to cancel)
+   
+6. studio_agent_listSubscriptions - List all active subscriptions
+   Parameters: none
+
+AVAILABLE CONTROL METHODS:
+Many components now support Commands (structured control actions):
+- Input components: file, WHIP, SRT, RTMP - have play/stop/connect/disconnect commands
+- Output components: statistics, WHEP, UDP, SRT, RTMP, preview, CMAF, HLS - have enable/disable commands  
+- Processor components: switches, overlays, gates, browser overlay - have state control commands
+- Use {componentId}_cmd_executeCommand for direct component control
+- Use {componentId}_executeRoute for control when commands don't exist for a task
+  
+STEP-BY-STEP DISCOVERY (MANDATORY):
+1. workflow_listComponents - Returns actual component IDs (e.g., "ll-hls", "input-1", etc.)
+2. {componentId}_cmd_listCommands - Replace {componentId} with ACTUAL ID from step 1 - this returns available command names
+3. {componentId}_cmd_getCommandSchema - replace {componentId} with ACTUAL ID and provide 'commandName' from step 2 as a parameter, you MUST call this for each relevant command to get schemas, storing these schemas in memory is recommended
+4. {componentId}_listRoutes - Replace {componentId} with ACTUAL ID from step 1
+5. {componentId}_getRouteSchema - replace {componentId} with ACTUAL ID from step 1, providing the url AND method from step 4, you MUST call this to get the schema in order to execute a route, storing this schema in memory is recommended
+6. {componentId}_cmd_executeCommand - Direct command execution (preferred for supported components), ALWAYS conform to the schema gathered in step 3 for the parameters of a command
+7. {componentId}_executeRoute - Use HTTP routes when commands aren't available, ALWAYS conform to the schema gathered in step 5
+8. {componentId}_evt_listEvents - Lists all event types the component can emit, replace {componentId} with ACTUAL ID
+9. {componentId}_evt_getEventSchema - Gets the detailed schema for events, replace {componentId} with ACTUAL ID, and provide the event name from step 8
+
+IMPORTANT NOTES:
+- Tool names are now abbreviated for efficiency (e.g., "osc_gfx" = "on_screen_graphic")
+- ALWAYS read tool descriptions carefully - they contain the full component names and detailed functionality
+- Store component metadata in memory: original component ID, abbreviated name, type, and capabilities
+- Use tool descriptions to understand what each abbreviated tool actually does
+- Pay attention to tool descriptions when choosing between similar tools
+
+DO NOT SKIP DISCOVERY. DO NOT GUESS TOOL NAMES. READ TOOL DESCRIPTIONS CAREFULLY.
+`;
+//# sourceMappingURL=runtime.js.map