daycare-cli 2026.2.25 → 2026.2.26

package/dist/engine/agents/agentSystem.js

@@ -8,7 +8,7 @@ import { cuid2Is } from "../../utils/cuid2Is.js";
 import { Memory } from "../memory/memory.js";
 import { UserHome } from "../users/userHome.js";
 import { Agent } from "./agent.js";
-import { Context } from "./context.js";
+import { contextForAgent, contextForUser } from "./context.js";
 import { agentDescriptorCacheKey } from "./ops/agentDescriptorCacheKey.js";
 import { agentDescriptorMatchesStrategy } from "./ops/agentDescriptorMatchesStrategy.js";
 import { agentDescriptorRead } from "./ops/agentDescriptorRead.js";
@@ -102,9 +102,10 @@ export class AgentSystem {
         const records = await this.storage.agents.findMany();
         for (const record of records) {
             const agentId = record.id;
+            const ctx = contextForAgent({ userId: record.userId, agentId });
             let state = null;
             try {
-                state = await agentStateRead(this.storage, agentId);
+                state = await agentStateRead(this.storage, ctx);
             }
             catch (error) {
                 logger.warn({ agentId, error }, "restore: Agent restore skipped due to invalid persisted data");
@@ -126,17 +127,16 @@ export class AgentSystem {
                         deliverAt: state.updatedAt + AGENT_POISON_PILL_DELAY_MS
                     });
                 }
-                const key = agentDescriptorCacheKey(descriptor);
+                const key = agentCacheKeyForCtx(ctx, descriptor);
                 this.keyMap.set(key, agentId);
                 logger.info({ agentId }, "restore: Agent restore skipped (sleeping)");
                 continue;
             }
             const inbox = new AgentInbox(agentId);
             const userHome = this.userHomeForUserId(record.userId);
-            const agent = Agent.restore(agentId, record.userId, descriptor, state, inbox, this, userHome);
+            const agent = Agent.restore(ctx, descriptor, state, inbox, this, userHome);
             const registered = this.registerEntry({
-                agentId,
-                userId: record.userId,
+                ctx,
                 descriptor,
                 agent,
                 inbox
@@ -160,20 +160,20 @@ export class AgentSystem {
             this.startEntryIfRunning(entry);
         }
     }
-    async post(target, item) {
+    async post(ctx, target, item) {
         if (this.stage === "idle" && (item.type === "message" || item.type === "system_message")) {
             const agentType = "descriptor" in target ? target.descriptor.type : "agent";
             logger.warn({ agentType }, "load: AgentSystem received message before load");
         }
         const targetLabel = "descriptor" in target ? `descriptor:${target.descriptor.type}` : `agent:${target.agentId}`;
         logger.debug(`receive: post() received itemType=${item.type} target=${targetLabel} stage=${this.stage}`);
-        const entry = await this.resolveEntry(target, item);
+        const entry = await this.resolveEntry(ctx, target, item);
         await this.enqueueEntry(entry, item, null);
-        logger.debug(`event: post() queued item agentId=${entry.agentId} inboxSize=${entry.inbox.size()}`);
+        logger.debug(`event: post() queued item agentId=${entry.ctx.agentId} inboxSize=${entry.inbox.size()}`);
         this.startEntryIfRunning(entry);
     }
-    async postAndAwait(target, item) {
-        const entry = await this.resolveEntry(target, item);
+    async postAndAwait(ctx, target, item) {
+        const entry = await this.resolveEntry(ctx, target, item);
         const completion = this.createCompletion();
         await this.enqueueEntry(entry, item, completion.completion);
         this.startEntryIfRunning(entry);
@@ -183,16 +183,16 @@ export class AgentSystem {
      * Resolves a target to its concrete agent id, creating/restoring when needed.
      * Expects: descriptor targets are valid for agent creation.
      */
-    async agentIdForTarget(target) {
-        const entry = await this.resolveEntry(target, {
+    async agentIdForTarget(ctx, target) {
+        const entry = await this.resolveEntry(ctx, target, {
             type: "message",
             message: { text: null },
             context: {}
         });
-        return entry.agentId;
+        return entry.ctx.agentId;
     }
-    async tokensForTarget(target) {
-        const entry = await this.resolveEntry(target, {
+    async tokensForTarget(ctx, target) {
+        const entry = await this.resolveEntry(ctx, target, {
             type: "message",
             message: { text: null },
             context: {}
@@ -212,7 +212,11 @@ export class AgentSystem {
             return true;
         }
         try {
-            const descriptor = await agentDescriptorRead(this.storage, agentId);
+            const context = await this.contextForAgentId(agentId);
+            if (!context) {
+                return false;
+            }
+            const descriptor = await agentDescriptorRead(this.storage, context);
             return !!descriptor;
         }
         catch {
@@ -226,13 +230,13 @@ export class AgentSystem {
     async contextForAgentId(agentId) {
         const loaded = this.entries.get(agentId);
         if (loaded) {
-            return new Context(loaded.agentId, loaded.userId);
+            return loaded.ctx;
         }
         const record = await this.storage.agents.findById(agentId);
         if (!record) {
             return null;
         }
-        return new Context(record.id, record.userId);
+        return contextForAgent({ userId: record.userId, agentId: record.id });
     }
     async signalDeliver(signal, subscriptions) {
         await Promise.all(subscriptions.map(async (subscription) => {
@@ -244,7 +248,7 @@ export class AgentSystem {
                 return;
             }
             try {
-                await this.post({ agentId: subscription.ctx.agentId }, {
+                await this.post(context, { agentId: subscription.ctx.agentId }, {
                     type: "signal",
                     signal,
                     subscriptionPattern: subscription.pattern
@@ -266,18 +270,21 @@ export class AgentSystem {
      * The current tool completes but remaining queued tools are cancelled.
      * Wakes the agent if sleeping.
      */
-    async steer(agentId, steering) {
+    async steer(ctx, agentId, steering) {
         const entry = this.entries.get(agentId);
         if (!entry) {
             throw new Error(`Agent not found: ${agentId}`);
         }
+        if (ctx.userId !== entry.ctx.userId) {
+            throw new Error(`Cannot steer agent from another user: ${agentId}`);
+        }
         let woke = false;
         await entry.lock.inLock(async () => {
             woke = await this.wakeEntryIfSleeping(entry);
             entry.inbox.steer(steering);
         });
         if (woke) {
-            await this.signalLifecycle(entry.agentId, "wake");
+            await this.signalLifecycle(entry.ctx.agentId, "wake");
         }
         logger.info({ agentId, origin: steering.origin }, "event: Steering message delivered");
         this.startEntryIfRunning(entry);
@@ -292,7 +299,7 @@ export class AgentSystem {
             return false;
         }
         const aborted = entry.agent.abortInference();
-        logger.info({ agentId: entry.agentId, aborted }, "event: Abort inference requested");
+        logger.info({ agentId: entry.ctx.agentId, aborted }, "event: Abort inference requested");
         return aborted;
     }
     markStopped(agentId, error) {
@@ -318,7 +325,7 @@ export class AgentSystem {
                 return;
             }
             entry.agent.state.state = "sleeping";
-            await agentStateWrite(this.storage, agentId, entry.agent.state);
+            await agentStateWrite(this.storage, entry.ctx, entry.agent.state);
             this.eventBus.emit("agent.sleep", { agentId, reason });
             logger.debug({ agentId, reason }, "event: Agent entered sleep mode");
             // Mark session for memory processing on idle
@@ -342,9 +349,9 @@ export class AgentSystem {
             await this.signalLifecycle(agentId, "sleep");
         }
     }
-    agentFor(strategy) {
+    agentFor(ctx, strategy) {
         const candidates = Array.from(this.entries.values()).filter((entry) => {
-            return agentDescriptorMatchesStrategy(entry.descriptor, strategy);
+            return entry.ctx.userId === ctx.userId && agentDescriptorMatchesStrategy(entry.descriptor, strategy);
         });
         if (candidates.length === 0) {
             return null;
@@ -354,7 +361,7 @@ export class AgentSystem {
             const bTime = agentTimestampGet(b.agent.state.updatedAt);
             return bTime - aTime;
         });
-        return candidates[0]?.agentId ?? null;
+        return candidates[0]?.ctx.agentId ?? null;
     }
     /**
      * Returns the descriptor for an agent by id.
@@ -399,7 +406,7 @@ export class AgentSystem {
         }
         entry.agent.state.modelOverride = override;
         entry.agent.state.updatedAt = Date.now();
-        await agentStateWrite(this.storage, agentId, entry.agent.state);
+        await agentStateWrite(this.storage, entry.ctx, entry.agent.state);
         return true;
     }
     async inReadLock(operation) {
@@ -412,30 +419,37 @@ export class AgentSystem {
         if ("agentId" in target) {
             return this.entries.get(target.agentId) ?? null;
         }
-        const key = agentDescriptorCacheKey(target.descriptor);
-        const agentId = this.keyMap.get(key);
-        if (!agentId) {
-            return null;
+        const descriptorKey = agentDescriptorCacheKey(target.descriptor);
+        for (const entry of this.entries.values()) {
+            if (agentDescriptorCacheKey(entry.descriptor) === descriptorKey) {
+                return entry;
+            }
         }
-        return this.entries.get(agentId) ?? null;
+        return null;
     }
-    async resolveEntry(target, _item) {
+    async resolveEntry(ctx, target, _item) {
         if ("agentId" in target) {
             const existing = this.entries.get(target.agentId);
             if (existing) {
                 if (existing.agent.state.state === "dead" || existing.terminating) {
                     throw deadErrorBuild(target.agentId);
                 }
+                if (existing.ctx.userId !== ctx.userId) {
+                    throw new Error(`Cannot post to agent from another user: ${target.agentId}`);
+                }
                 return existing;
             }
             const restored = await this.restoreAgent(target.agentId, { allowSleeping: true });
             if (restored) {
+                if (restored.ctx.userId !== ctx.userId) {
+                    throw new Error(`Cannot post to agent from another user: ${target.agentId}`);
+                }
                 return restored;
             }
             throw new Error(`Agent not found: ${target.agentId}`);
         }
         const descriptor = target.descriptor;
-        const key = agentDescriptorCacheKey(descriptor);
+        const key = agentCacheKeyForCtx(ctx, descriptor);
         const existingAgentId = this.keyMap.get(key);
         if (existingAgentId) {
             const existing = this.entries.get(existingAgentId);
@@ -443,10 +457,16 @@ export class AgentSystem {
                 if (existing.agent.state.state === "dead" || existing.terminating) {
                     throw deadErrorBuild(existingAgentId);
                 }
+                if (existing.ctx.userId !== ctx.userId) {
+                    throw new Error(`Cannot resolve agent from another user: ${existingAgentId}`);
+                }
                 return existing;
             }
             const restored = await this.restoreAgent(existingAgentId, { allowSleeping: true });
             if (restored) {
+                if (restored.ctx.userId !== ctx.userId) {
+                    throw new Error(`Cannot resolve agent from another user: ${existingAgentId}`);
+                }
                 return restored;
             }
         }
@@ -456,10 +476,16 @@ export class AgentSystem {
                 if (existing.agent.state.state === "dead" || existing.terminating) {
                     throw deadErrorBuild(descriptor.id);
                 }
+                if (existing.ctx.userId !== ctx.userId) {
+                    throw new Error(`Cannot resolve agent from another user: ${descriptor.id}`);
+                }
                 return existing;
             }
             const restored = await this.restoreAgent(descriptor.id, { allowSleeping: true });
             if (restored) {
+                if (restored.ctx.userId !== ctx.userId) {
+                    throw new Error(`Cannot resolve agent from another user: ${descriptor.id}`);
+                }
                 return restored;
             }
         }
@@ -469,12 +495,15 @@ export class AgentSystem {
             : descriptor;
         logger.debug(`event: Creating agent entry agentId=${agentId} type=${resolvedDescriptor.type}`);
         const inbox = new AgentInbox(agentId);
-        const userId = await this.resolveUserIdForDescriptor(resolvedDescriptor);
-        const userHome = this.userHomeForUserId(userId);
-        const agent = await Agent.create(agentId, resolvedDescriptor, userId, inbox, this, userHome);
+        const userId = await this.resolveUserIdForDescriptor(ctx, resolvedDescriptor);
+        if (userId !== ctx.userId) {
+            throw new Error(`Cannot create agent for another user: ${agentId}`);
+        }
+        const createdCtx = contextForAgent({ userId, agentId });
+        const userHome = this.userHomeForCtx(createdCtx);
+        const agent = await Agent.create(createdCtx, resolvedDescriptor, inbox, this, userHome);
         const entry = this.registerEntry({
-            agentId,
-            userId,
+            ctx: createdCtx,
             descriptor: resolvedDescriptor,
             agent,
             inbox
@@ -484,8 +513,7 @@ export class AgentSystem {
     }
     registerEntry(input) {
         const entry = {
-            agentId: input.agentId,
-            userId: input.userId,
+            ctx: input.ctx,
             descriptor: input.descriptor,
             agent: input.agent,
             inbox: input.inbox,
@@ -493,21 +521,21 @@ export class AgentSystem {
             terminating: false,
             lock: new AsyncLock()
         };
-        this.entries.set(input.agentId, entry);
-        const key = agentDescriptorCacheKey(input.descriptor);
-        this.keyMap.set(key, input.agentId);
+        this.entries.set(input.ctx.agentId, entry);
+        const key = agentCacheKeyForCtx(input.ctx, input.descriptor);
+        this.keyMap.set(key, input.ctx.agentId);
         return entry;
     }
     startEntryIfRunning(entry) {
         if (this.stage !== "running") {
-            logger.debug(`skip: startEntryIfRunning skipped agentId=${entry.agentId} reason=stage:${this.stage}`);
+            logger.debug(`skip: startEntryIfRunning skipped agentId=${entry.ctx.agentId} reason=stage:${this.stage}`);
             return;
         }
         if (entry.running) {
-            logger.debug(`skip: startEntryIfRunning skipped agentId=${entry.agentId} reason=already-running`);
+            logger.debug(`skip: startEntryIfRunning skipped agentId=${entry.ctx.agentId} reason=already-running`);
             return;
         }
-        logger.debug(`start: startEntryIfRunning starting agentId=${entry.agentId} type=${entry.descriptor.type}`);
+        logger.debug(`start: startEntryIfRunning starting agentId=${entry.ctx.agentId} type=${entry.descriptor.type}`);
         entry.running = true;
         entry.agent.start();
     }
@@ -517,28 +545,28 @@ export class AgentSystem {
             woke = await this.wakeEntryIfSleeping(entry);
             const postedAt = Date.now();
             const generatedId = createId();
-            await this.storage.inbox.insert(generatedId, entry.agentId, postedAt, item.type, inboxItemSerialize(item));
+            await this.storage.inbox.insert(generatedId, entry.ctx.agentId, postedAt, item.type, inboxItemSerialize(item));
             const queued = entry.inbox.post(item, completion, { id: generatedId, postedAt });
             if (queued.id !== generatedId) {
                 // Message merge consumed the new row into an existing queue entry.
                 await this.storage.inbox.delete(generatedId);
-                await this.storage.inbox.insert(queued.id, entry.agentId, queued.postedAt, queued.item.type, inboxItemSerialize(queued.item));
+                await this.storage.inbox.insert(queued.id, entry.ctx.agentId, queued.postedAt, queued.item.type, inboxItemSerialize(queued.item));
             }
         });
         if (woke) {
-            await this.signalLifecycle(entry.agentId, "wake");
+            await this.signalLifecycle(entry.ctx.agentId, "wake");
         }
     }
     async replayPersistedInboxItems(entry) {
         await entry.lock.inLock(async () => {
-            const rows = await this.storage.inbox.findByAgentId(entry.agentId);
+            const rows = await this.storage.inbox.findByAgentId(entry.ctx.agentId);
             for (const row of rows) {
                 try {
                     const item = inboxItemDeserialize(row.data);
                     entry.inbox.post(item, null, { id: row.id, postedAt: row.postedAt, merge: false });
                 }
                 catch (error) {
-                    logger.warn({ agentId: entry.agentId, inboxItemId: row.id, error }, "restore: Dropping invalid persisted inbox row");
+                    logger.warn({ agentId: entry.ctx.agentId, inboxItemId: row.id, error }, "restore: Dropping invalid persisted inbox row");
                     await this.storage.inbox.delete(row.id);
                 }
             }
@@ -548,12 +576,12 @@ export class AgentSystem {
         if (entry.agent.state.state !== "sleeping") {
             return false;
         }
-        await this.cancelIdleSignal(entry.agentId);
-        await this.cancelPoisonPill(entry.agentId, { descriptor: entry.descriptor });
+        await this.cancelIdleSignal(entry.ctx.agentId);
+        await this.cancelPoisonPill(entry.ctx.agentId, { descriptor: entry.descriptor });
         entry.agent.state.state = "active";
-        await agentStateWrite(this.storage, entry.agentId, entry.agent.state);
-        this.eventBus.emit("agent.woke", { agentId: entry.agentId });
-        logger.debug({ agentId: entry.agentId }, "event: Agent woke from sleep");
+        await agentStateWrite(this.storage, entry.ctx, entry.agent.state);
+        this.eventBus.emit("agent.woke", { agentId: entry.ctx.agentId });
+        logger.debug({ agentId: entry.ctx.agentId }, "event: Agent woke from sleep");
         return true;
     }
     async scheduleIdleSignal(agentId) {
@@ -688,8 +716,12 @@ export class AgentSystem {
         let descriptor = null;
         let state = null;
         try {
-            descriptor = await agentDescriptorRead(this.storage, agentId);
-            state = await agentStateRead(this.storage, agentId);
+            const context = await this.contextForAgentId(agentId);
+            if (!context) {
+                return;
+            }
+            descriptor = await agentDescriptorRead(this.storage, context);
+            state = await agentStateRead(this.storage, context);
         }
         catch (error) {
             logger.warn({ agentId, error }, "error: Poison-pill read failed");
@@ -704,7 +736,11 @@ export class AgentSystem {
         await this.cancelPoisonPill(agentId, { descriptor });
         state.state = "dead";
         state.updatedAt = Date.now();
-        await agentStateWrite(this.storage, agentId, state);
+        const context = await this.contextForAgentId(agentId);
+        if (!context) {
+            return;
+        }
+        await agentStateWrite(this.storage, context, state);
         await this.storage.inbox.deleteByAgentId(agentId);
         this.eventBus.emit("agent.dead", { agentId, reason: "poison-pill" });
     }
@@ -717,43 +753,45 @@ export class AgentSystem {
                 pending = [];
                 return;
             }
-            await this.cancelIdleSignal(entry.agentId);
-            await this.cancelPoisonPill(entry.agentId, { descriptor: entry.descriptor });
+            await this.cancelIdleSignal(entry.ctx.agentId);
+            await this.cancelPoisonPill(entry.ctx.agentId, { descriptor: entry.descriptor });
             entry.agent.state.state = "dead";
             entry.agent.state.updatedAt = Date.now();
-            await agentStateWrite(this.storage, entry.agentId, entry.agent.state);
+            await agentStateWrite(this.storage, entry.ctx, entry.agent.state);
             pending = entry.inbox.drainPending();
-            await this.storage.inbox.deleteByAgentId(entry.agentId);
+            await this.storage.inbox.deleteByAgentId(entry.ctx.agentId);
             changed = true;
         });
         if (!changed) {
             return;
         }
         entry.running = false;
-        this.entries.delete(entry.agentId);
-        const key = agentDescriptorCacheKey(entry.descriptor);
+        this.entries.delete(entry.ctx.agentId);
+        const key = agentCacheKeyForCtx(entry.ctx, entry.descriptor);
         this.keyMap.delete(key);
-        const deadError = deadErrorBuild(entry.agentId);
+        const deadError = deadErrorBuild(entry.ctx.agentId);
         for (const queued of pending) {
             queued.completion?.reject(deadError);
         }
-        this.eventBus.emit("agent.dead", { agentId: entry.agentId, reason });
+        this.eventBus.emit("agent.dead", { agentId: entry.ctx.agentId, reason });
     }
     async restoreAgent(agentId, options) {
         let descriptor = null;
         let state = null;
-        let recordUserId = "";
+        let ctx = null;
         try {
-            descriptor = await agentDescriptorRead(this.storage, agentId);
-            state = await agentStateRead(this.storage, agentId);
-            const record = await this.storage.agents.findById(agentId);
-            recordUserId = record?.userId ?? "";
+            ctx = await this.contextForAgentId(agentId);
+            if (!ctx) {
+                return null;
+            }
+            descriptor = await agentDescriptorRead(this.storage, ctx);
+            state = await agentStateRead(this.storage, ctx);
         }
         catch (error) {
             logger.warn({ agentId, error }, "error: Agent restore failed due to invalid persisted data");
             return null;
         }
-        if (!descriptor || !state || !recordUserId) {
+        if (!descriptor || !state || !ctx) {
             return null;
         }
         if (state.state === "dead") {
@@ -763,11 +801,10 @@ export class AgentSystem {
             return null;
         }
         const inbox = new AgentInbox(agentId);
-        const userHome = this.userHomeForUserId(recordUserId);
-        const agent = Agent.restore(agentId, recordUserId, descriptor, state, inbox, this, userHome);
+        const userHome = this.userHomeForCtx(ctx);
+        const agent = Agent.restore(ctx, descriptor, state, inbox, this, userHome);
         const entry = this.registerEntry({
-            agentId,
-            userId: recordUserId,
+            ctx,
             descriptor,
             agent,
             inbox
@@ -777,23 +814,33 @@ export class AgentSystem {
         this.startEntryIfRunning(entry);
         return entry;
     }
-    async resolveUserIdForDescriptor(descriptor) {
+    async resolveUserIdForDescriptor(ctx, descriptor) {
         if (descriptor.type === "user") {
             const connectorKey = userConnectorKeyCreate(descriptor.connector, descriptor.userId);
             return this.resolveUserIdForConnectorKey(connectorKey);
         }
-        if (descriptor.type === "subagent" || descriptor.type === "app") {
+        if (descriptor.type === "subagent" || descriptor.type === "app" || descriptor.type === "memory-search") {
             const parent = await this.contextForAgentId(descriptor.parentAgentId);
             if (parent) {
                 return parent.userId;
             }
-            return this.ownerUserIdEnsure();
+            throw new Error("Parent agent not found");
+        }
+        if (descriptor.type === "memory-agent") {
+            const source = await this.contextForAgentId(descriptor.id);
+            if (source) {
+                return source.userId;
+            }
+            throw new Error("Source agent not found for memory-agent");
         }
         // Subuser gateway agents belong to the subuser — descriptor.id IS the subuser's userId
         if (descriptor.type === "subuser") {
             return descriptor.id;
         }
-        return this.ownerUserIdEnsure();
+        if (descriptor.type === "system" || descriptor.type === "cron" || descriptor.type === "permanent") {
+            return ctx.userId;
+        }
+        throw new Error("Cannot resolve user for descriptor");
     }
     async resolveUserIdForConnectorKey(connectorKey) {
         try {
@@ -804,14 +851,14 @@ export class AgentSystem {
             }
         }
         catch (error) {
-            logger.warn({ connectorKey, error }, "warn: Failed to resolve connector user; falling back to owner");
+            logger.warn({ connectorKey, error }, "warn: Failed to resolve connector user");
         }
-        return this.ownerUserIdEnsure();
+        throw new Error("User not found for connector key");
     }
-    async ownerUserIdEnsure() {
+    async ownerCtxEnsure() {
         const owner = await this.storage.users.findOwner();
         if (owner) {
-            return owner.id;
+            return contextForUser({ userId: owner.id });
         }
         const now = Date.now();
         const ownerId = createId();
@@ -822,12 +869,12 @@ export class AgentSystem {
                 createdAt: now,
                 updatedAt: now
             });
-            return ownerId;
+            return contextForUser({ userId: ownerId });
         }
         catch {
             const recovered = await this.storage.users.findOwner();
             if (recovered) {
-                return recovered.id;
+                return contextForUser({ userId: recovered.id });
             }
             throw new Error("Failed to resolve owner user");
         }
@@ -839,6 +886,13 @@ export class AgentSystem {
     userHomeForUserId(userId) {
         return new UserHome(this.config.current.usersDir, userId);
     }
+    /**
+     * Resolves a UserHome facade from caller context.
+     * Expects: ctx.userId belongs to an existing or soon-to-be-created runtime user.
+     */
+    userHomeForCtx(ctx) {
+        return this.userHomeForUserId(ctx.userId);
+    }
     createCompletion() {
         let resolve = null;
         let reject = null;
@@ -858,6 +912,9 @@ export class AgentSystem {
 function lifecycleSignalTypeBuild(agentId, state) {
     return `agent:${agentId}:${state}`;
 }
+function agentCacheKeyForCtx(ctx, descriptor) {
+    return `${ctx.userId}:${agentDescriptorCacheKey(descriptor)}`;
+}
 function parsePoisonPillAgentId(signalType) {
     const parts = signalType.split(":");
     if (parts.length !== 3) {