deepclause-sdk 0.2.2 → 0.4.0

package/dist/repl/session.js

@@ -13,6 +13,7 @@ import { loadProlog, mountWorkspace, takePrologMessages, } from '../prolog/loade
 import { describeShellExecutionBackend, } from '../system/runtime/shell-manager.js';
 import { getWorkspaceDocAssetPath } from '../system/assets/index.js';
 import { DMLRunner, toJsValue } from '../runner.js';
+import { resolveReplJudgeSelection } from './judge.js';
 import { DmlProcessExecutor } from './process-executor.js';
 import { pidKey } from './processes.js';
 import { compactMemory, estimateMemoryTokens, shouldCompact, toCompactionEvent, } from './compaction.js';
@@ -23,6 +24,7 @@ import { buildHarnessHeader, } from './export.js';
 import { HistoryStore, harnessHash, moduleVersion, } from './history.js';
 import { buildDiagramPrompt, extractMermaid, parseMermaidFlowchart, rasterizeSvg, renderFlowchartSvg, renderMermaidAscii, resolveMedia, validateMermaid, } from '../visualize/index.js';
 import { generateLlmReply } from '../prolog/bridge.js';
+import { FormRegistry } from '../forms/registry.js';
 import { formatModelCatalogEntry } from './model-resolver.js';
 /**
  * Context note added when a saved session is reloaded. The opening words are
@@ -52,6 +54,16 @@ function historyEventFromRecord(record) {
         case 'answer':
         case 'error':
             return { type, frameKind, content };
+        case 'html':
+            return {
+                type,
+                frameKind,
+                html: {
+                    path: typeof record.html?.path === 'string'
+                        ? record.html.path
+                        : '',
+                },
+            };
         case 'log':
             return { type, frameKind, content, level: record.level };
         case 'tool_call':
@@ -62,6 +74,10 @@ function historyEventFromRecord(record) {
                 toolState: record.toolState,
                 toolSummary: typeof record.toolSummary === 'string' ? record.toolSummary : undefined,
                 toolArgs: record.toolArgs,
+                toolResult: record.toolResult,
+                toolError: typeof record.toolError === 'string' ? record.toolError : undefined,
+                toolDurationMs: typeof record.toolDurationMs === 'number' ? record.toolDurationMs : undefined,
+                toolExitCode: typeof record.toolExitCode === 'number' ? record.toolExitCode : undefined,
             };
         case 'solution':
             return {
@@ -123,8 +139,11 @@ export class DMLSession {
     model;
     provider;
     tools;
+    authoringTools;
     toolPolicy;
     inputHandler;
+    /** Host-side interaction for an opened form (docs/DML_FORMS.md). */
+    formHandler;
     maxDepth;
     maxModelCalls;
     hostToolsCatalog;
@@ -155,6 +174,7 @@ export class DMLSession {
     modelCallBudget;
     dmlReference;
     dmlAuthoring;
+    dmlForms;
     harnessExamples;
     harnessPatterns;
     prologSnippets;
@@ -175,6 +195,8 @@ export class DMLSession {
     /** Session-scoped subagents (spec §2). */
     processBackend;
     processBackendPromise;
+    /** Form host state (docs/DML_FORMS.md); active only when the harness opts in. */
+    forms = new FormRegistry();
     /**
      * The harness snapshot new processes should run. On the main session this is
      * unset (children snapshot the live module); a worker host sets it to the
@@ -187,6 +209,7 @@ export class DMLSession {
     static PROCESS_LOG_LIMIT = 500;
     /** Service declarations replayed from the session record (resume only). */
     recordedServices = [];
+    pendingSuspensionValue;
     /** Monotonic per-session turn counter used by history records. */
     turnCounter = 0;
     historyWarned = false;
@@ -198,11 +221,13 @@ export class DMLSession {
         this.model = options.runnerOptions.model;
         this.provider = String(options.runnerOptions.provider);
         this.tools = options.tools ?? new Map();
+        this.authoringTools = options.authoringTools ?? new Map();
         this.toolPolicy = options.toolPolicy ?? null;
         this.inputHandler = options.onInput
             ?? (options.askUser ? (prompt, choices) => options.askUser(prompt, choices).then((r) => ('cancelled' in r ? undefined : r.answer)) : undefined)
             ?? options.onInputRequired
             ?? undefined;
+        this.formHandler = options.onForm;
         this.maxDepth = options.maxDepth ?? 3;
         this.maxModelCalls = options.maxModelCalls ?? 100;
         this.modelCallBudget = this.maxModelCalls;
@@ -222,9 +247,26 @@ export class DMLSession {
         this.modelResolver = options.runnerOptions.modelResolver;
         this.temperature = options.runnerOptions.temperature;
         this.maxTokens = options.runnerOptions.maxTokens;
+        // Direct DMLSession users (notably the browser child workers) do not go
+        // through createHarnessRepl's judge wiring. Without a default selection,
+        // judge/2 fails with "Unknown judgment backend: llm".
+        const judgeSelection = options.runnerOptions.judgeSelection
+            ?? resolveReplJudgeSelection({
+                llmBackend: options.runnerOptions.llmBackend,
+                model: options.runnerOptions.model,
+                provider: String(options.runnerOptions.provider),
+                temperature: options.runnerOptions.temperature,
+                maxTokens: options.runnerOptions.maxTokens,
+                baseUrl: options.runnerOptions.baseUrl,
+                providerOptions: options.runnerOptions.providerOptions,
+                defaultJudge: options.defaultJudge,
+                jev: options.jev,
+            }).selection;
         this.runner = new DMLRunner(swipl, {
             ...options.runnerOptions,
+            judgeSelection,
             environment: this.executionEnvironment,
+            capabilityTool: options.capabilityTool,
             compactMessages: options.compaction
                 ? (messages, lastInputTokens, contextWindow) => this.compactLoopMessages(messages, lastInputTokens, contextWindow)
                 : undefined,
@@ -250,9 +292,11 @@ export class DMLSession {
             const store = new HistoryStore(options.workspacePath ?? process.cwd(), session.sessionId, options.history, session.harnessName);
             snapshot = await store.readSessionHarness();
             session.recordedServices = await store.readServiceRecords();
-            if (!snapshot) {
-                throw new Error(`session not found or has no saved harness: ${session.sessionId}`);
-            }
+            session.pendingSuspensionValue = (await store.readSuspendRecord()) ?? undefined;
+            // A session can have a transcript but no harness snapshot (older builds,
+            // or a turn interrupted before its first commit). Resume it from the
+            // current harness instead of refusing to open it; the transcript reader
+            // still restores every turn and event it has.
         }
         const sessionParams = {
             workspace_path: options.workspacePath ?? './',
@@ -292,6 +336,27 @@ export class DMLSession {
                     session.warnHistory(new Error(`could not load harness '${session.harnessName}': ${loaded.error}`));
                 }
             }
+            if (options.resume)
+                session.noteSessionResumed();
+        }
+        // Creating a session (or loading a harness) can move SWI's cwd away from the
+        // workspace, so reassert it before any goal runs — with the **mounted** path.
+        // `mountWorkspace` puts every workspace at `/workspace` and points both
+        // Emscripten's cwd and SWI's there; the host path is not in the WASM filesystem,
+        // so asserting *that* throws (harmlessly in the main thread, but it means the
+        // reassert never happened where it was needed).
+        //
+        // `working_directory/2` is process-global, so this is only meaningful while a
+        // process has one mount — true for every session today, since the mount itself
+        // is process-global. Query with `.once()`: `prolog.call()` returns an
+        // unexecuted query and wedges the next one.
+        if (options.workspacePath) {
+            try {
+                swipl.prolog.query("working_directory(_, '/workspace').").once();
+            }
+            catch {
+                /* non-fatal: absolute paths still resolve */
+            }
         }
         return session;
     }
@@ -354,7 +419,12 @@ export class DMLSession {
             };
             if (mode === 'worker') {
                 const { RemoteProcessHost } = await import('./worker-host.js');
-                const host = new RemoteProcessHost(this, { onEvent });
+                const host = new RemoteProcessHost(this, {
+                    onEvent,
+                    workerFactory: this.openOptions.processWorkerFactory,
+                    beforeStart: this.openOptions.beforeProcessStart,
+                    beforeSpawn: this.openOptions.beforeProcessSpawn,
+                });
                 await host.start();
                 this.processBackend = host;
                 return host;
@@ -398,6 +468,47 @@ export class DMLSession {
     recordedProcesses() {
         return this.recordedServices;
     }
+    /**
+     * A turn stopped by `suspend/1`: where it stopped and the goal that continues
+     * it. Set on resume, so a host can run the continuation once the harness and
+     * memory are back.
+     */
+    pendingSuspension() {
+        return this.pendingSuspensionValue;
+    }
+    /** Forget the pending suspension (after resuming it, or deliberately dropping it). */
+    async clearSuspension() {
+        this.pendingSuspensionValue = undefined;
+        await this.history?.clearSuspendRecord();
+    }
+    /**
+     * Persist a suspension: the continuation, the memory it stopped with, and the
+     * module version it was running. The harness snapshot is written too, so the
+     * resumed session starts from exactly this module + memory.
+     */
+    async handleSuspend(payload) {
+        if (!this.history)
+            return;
+        try {
+            if (payload.memory) {
+                // The turn's threaded memory is the authoritative one at the stop; make it
+                // the session's, so `harness.json` and the resumed state agree.
+                this.prologQuery(`deepclause_mi:repl_set_memory('${this.sessionId}', harness, ${payload.memory})`);
+            }
+            await this.history.writeSuspendRecord({
+                continuation: payload.continuation,
+                memory: payload.memory,
+                turn: this.turnCounter,
+                moduleVersion: this.history.currentVersion ? String(this.history.currentVersion) : undefined,
+                moduleHash: this.history.currentHash,
+            });
+            await this.persistSessionHarness(this.history.currentVersion);
+            this.pendingSuspensionValue = { continuation: payload.continuation, memory: payload.memory };
+        }
+        catch (error) {
+            this.warnHistory(error);
+        }
+    }
     /**
      * Recent subagent output for the log view, oldest first. Answers and exits are
      * included; per-tick state/activity updates are not (the summary shows those).
@@ -410,7 +521,7 @@ export class DMLSession {
      * Events from the resumed session, to render it on load. Empty unless this
      * session was opened with `resume` and history is enabled.
      */
-    async resumedTranscript(limit = 400) {
+    async resumedTranscript(limit = Number.POSITIVE_INFINITY) {
         if (!this.resume || !this.history)
             return [];
         const records = await this.history.readEvents(this.sessionId, limit);
@@ -481,11 +592,40 @@ export class DMLSession {
     sendProcess(to, messageTerm) {
         this.processBackend?.send(to, messageTerm);
     }
-    /** Request/reply against a service process (library(service) protocol). */
-    async callProcess(to, messageTerm, timeoutMs = 300_000) {
-        return (await this.ensureProcessBackend()).callTerm(to, messageTerm, timeoutMs);
+    /**
+     * Request/reply against a service process (library(service) protocol).
+     *
+     * The message is normalized first: prose ("hello from the REPL") is not a
+     * Prolog term, and interpolating it into `request(From, Ref, …)` used to leave
+     * the caller waiting out the timeout while the service failed to parse the goal.
+     */
+    async callProcess(to, messageTerm, timeoutMs = 30_000, signal) {
+        return (await this.ensureProcessBackend()).callTerm(to, this.normalizeMessage(messageTerm), timeoutMs, signal);
+    }
+    /** Quote a `call` message that does not parse as a term, so it is a payload. */
+    normalizeMessage(text) {
+        if (!text.trim())
+            return 'true';
+        const result = this.prologQuery(`deepclause_mi:repl_normalize_message(${quoteString(text)}, Term)`);
+        return String(plainValue(result?.Term) ?? text);
+    }
+    /** The synthetic pid shared by foreground/execute work in this session. */
+    async processHostPid() {
+        const backend = await this.ensureProcessBackend();
+        const hostPid = backend.hostPid?.();
+        if (!hostPid)
+            throw new Error('this process backend has no host pid');
+        return hostPid;
+    }
+    /** Handle a process primitive on behalf of a remote child session. */
+    async handleProcessRequest(pid, request, signal) {
+        const backend = await this.ensureProcessBackend();
+        const candidate = backend;
+        if (typeof candidate.handleRequest !== 'function') {
+            throw new Error('this process backend cannot service remote child requests');
+        }
+        return candidate.handleRequest(pid, request, signal);
     }
-    /** Resolve a process primitive for this (non-process) foreground run. */
     async handleForeground(request, signal) {
         return (await this.ensureProcessBackend()).foregroundHandle(request, signal);
     }
@@ -570,7 +710,12 @@ export class DMLSession {
      * (a swarm item reports `failed`, say), whereas throwing would kill the process
      * before it can report and leave a waiting parent hanging.
      */
-    async createProcessSession() {
+    async createProcessSession(pid) {
+        if (this.openOptions.createProcessSession) {
+            if (!pid)
+                throw new Error('createProcessSession requires a pid');
+            return this.openOptions.createProcessSession(pid);
+        }
         const text = this.processSnapshotFor().text;
         const child = await DMLSession.open({
             ...this.openOptions,
@@ -860,6 +1005,25 @@ export class DMLSession {
             return undefined;
         }
     }
+    /** Write the user turn immediately, so an interrupted turn keeps its request. */
+    async recordHistoryTurnStart(record) {
+        if (!this.history)
+            return;
+        try {
+            this.assertHistoryFacts(await this.history.recordTurn({
+                ...record,
+                outcome: 'running',
+                durationMs: 0,
+                modelCalls: 0,
+            }));
+            // Snapshot before the turn as well: an interrupted turn then still has a
+            // resumable harness and transcript, not just the previous turn's files.
+            await this.persistSessionHarness(this.history.currentVersion);
+        }
+        catch (error) {
+            this.warnHistory(error);
+        }
+    }
     async finishHistoryTurn(record) {
         if (!this.history)
             return;
@@ -942,6 +1106,7 @@ export class DMLSession {
         this.turnCounter += 1;
         const historyTurn = this.turnCounter;
         const historyStart = Date.now();
+        await this.recordHistoryTurnStart({ turn: historyTurn, mode: 'goal', request: goal });
         const frame = this.runner.registerDefaultFrame(frameKind);
         if (!frame) {
             yield { type: 'error', content: 'Failed to create query frame' };
@@ -976,6 +1141,7 @@ export class DMLSession {
             durationMs: Date.now() - historyStart,
             modelCalls: this.modelCallsThisTurn,
         });
+        await this.persistSessionHarness(this.history?.currentVersion ?? 0);
     }
     /** Load the bundled DML reference once, for inclusion in the meta prompt. */
     async loadDmlReference() {
@@ -1005,6 +1171,17 @@ export class DMLSession {
     }
     /** Load a bundled doc asset once (cached by field). */
     async loadDocAsset(name) {
+        if (name === 'dml-forms') {
+            if (this.dmlForms !== undefined)
+                return this.dmlForms;
+            try {
+                this.dmlForms = await fs.readFile(getWorkspaceDocAssetPath('dml-forms'), 'utf8');
+            }
+            catch {
+                this.dmlForms = '';
+            }
+            return this.dmlForms;
+        }
         const cached = name === 'harness-examples'
             ? this.harnessExamples
             : name === 'harness-patterns'
@@ -1286,6 +1463,7 @@ export class DMLSession {
         this.turnCounter += 1;
         const turn = this.turnCounter;
         const historyStart = Date.now();
+        await this.recordHistoryTurnStart({ turn, mode: 'prompt', request });
         this.lastTurnCommitted = false;
         this.lastCommitVersion = undefined;
         // No automatic transaction: `define`/`assert`/… are refused until the agent
@@ -1374,8 +1552,24 @@ export class DMLSession {
     async getHarnessAgent() {
         if (this.harnessAgent)
             return this.harnessAgent;
+        const authoringTools = createHarnessTools(this);
+        const allowed = this.openOptions.authoringToolNames
+            ? new Set(this.openOptions.authoringToolNames)
+            : null;
+        if (allowed) {
+            for (const name of [...authoringTools.keys()]) {
+                if (!allowed.has(name))
+                    authoringTools.delete(name);
+            }
+        }
+        for (const [name, tool] of this.authoringTools) {
+            if (allowed && !allowed.has(name))
+                continue;
+            if (!authoringTools.has(name))
+                authoringTools.set(name, tool);
+        }
         this.harnessAgent = new HarnessAgent({
-            tools: createHarnessTools(this),
+            tools: authoringTools,
             llmBackend: this.llmBackend,
             model: this.model,
             temperature: this.temperature,
@@ -1389,9 +1583,11 @@ export class DMLSession {
                 : undefined,
             workspacePath: this.workspacePath,
             environment: this.executionEnvironment,
+            capabilityTool: this.openOptions.capabilityTool,
             currentModel: `${this.provider}:${this.model}`,
             modelCatalog: this.modelResolver?.catalog(),
             knownMessages: this.agentMessages,
+            agentSystemPrompt: this.openOptions.agentSystemPrompt,
         });
         return this.harnessAgent;
     }
@@ -1520,13 +1716,14 @@ export class DMLSession {
         return undefined;
     }
     async beginTurn() {
-        // A second begin_turn would re-snapshot the *mid-transaction* state, so
+        // A second begin_turn must not re-snapshot the *mid-transaction* state:
         // `rollback` would stop meaning "the last committed harness" and the
-        // recorded diff would lose the edits made before it.
+        // recorded diff would lose edits made before it. Treat it as an idempotent
+        // reminder instead of an error so agents do not get stuck retrying it.
         if (this.transactionBefore !== null) {
             return {
-                ok: false,
-                error: 'a transaction is already open; call end_turn to commit it, or rollback to discard it',
+                ok: true,
+                message: 'transaction is already open; continue editing, then call end_turn to commit or rollback to discard',
             };
         }
         this.prologQuery(`deepclause_mi:repl_snapshot_save('${this.sessionId}')`);
@@ -1541,8 +1738,8 @@ export class DMLSession {
         }
         const before = this.transactionBefore;
         const after = this.predicateList();
-        const changed = this.simplePredicateDiff(before, after);
         const touched = this.editTouched();
+        const changed = this.simplePredicateDiff(before, after, touched);
         this.transactionBefore = null;
         const committed = this.transactionDirty;
         let version;
@@ -1567,6 +1764,61 @@ export class DMLSession {
             warnings.push(...this.probeToolContracts());
             warnings.push(...this.probeDocContracts());
         }
+        // `committed` means a version was recorded. It used to be hard-coded `true`,
+        // so a turn whose every edit was refused reported `{committed: true,
+        // changed: []}` — which reads as "committed, nothing changed" and hides that
+        // the edit never landed.
+        return { committed, changed, warnings };
+    }
+    /**
+     * The living module serialized as loadable DML (the editable harness source).
+     * `header: none` keeps it free of the export banner, so it round-trips through
+     * `replaceHarness` without accumulating comments.
+     */
+    async harnessSource() {
+        const result = this.prologQuery(`deepclause_mi:export_harness('${this.sessionId}', none, Text)`);
+        return String(plainValue(result?.Text) ?? '');
+    }
+    /**
+     * Replace the whole living module with `source` and commit it as a new
+     * version.
+     *
+     * `loadCode` only adds/replaces clauses, so a predicate deleted from the text
+     * would survive. This abolishes the user predicates (and their directives,
+     * tools and sources) and reloads the text, preserving conversation memory, so
+     * the editor's text is the source of truth. The result is an ordinary commit:
+     * a history version, the persisted harness, and the same contract warnings.
+     */
+    async replaceHarness(source) {
+        if (this.disposed)
+            return { committed: false, error: 'Session has been disposed' };
+        if (this.isFrozen())
+            return { committed: false, error: 'harness is frozen; editing is disabled' };
+        // `repl_rollback` abolishes the predicates *before* loading, so a syntax error
+        // would otherwise leave the session empty. Keep the previous text and put it
+        // back if the new source does not load.
+        const previous = await this.harnessSource();
+        const before = this.predicateList();
+        const result = this.prologQuery(`deepclause_mi:repl_rollback('${this.sessionId}', ${quoteString(source)}, Result)`);
+        const outcome = plainValue(result?.Result);
+        if (outcome !== 'ok') {
+            this.prologQuery(`deepclause_mi:repl_rollback('${this.sessionId}', ${quoteString(previous)}, _)`);
+            return { committed: false, error: String(outcome ?? 'replace failed') };
+        }
+        const after = this.predicateList();
+        const changed = this.simplePredicateDiff(before, after);
+        let version;
+        if (this.history) {
+            version = await this.recordHistoryChange('commit', this.turnCounter, before, { touched: after });
+        }
+        this.lastTurnCommitted = true;
+        this.lastCommitVersion = version;
+        await this.persistSessionHarness(this.history?.currentVersion ?? 0);
+        const warnings = [
+            ...(await this.probeNondeterminism(after)),
+            ...this.probeToolContracts(),
+            ...this.probeDocContracts(),
+        ];
         return { committed: true, changed, warnings };
     }
     /**
@@ -1658,13 +1910,27 @@ export class DMLSession {
         this.lastCommitVersion = undefined;
         this.transactionDirty = false;
     }
-    simplePredicateDiff(before, after) {
+    /**
+     * `+f/1` added, `-f/1` removed, `~f/1` rewritten in place.
+     *
+     * A set diff alone reports `[]` when a predicate is replaced by a new definition
+     * with the same name and arity — the most common edit there is. An agent that
+     * reads `changed` as "did my edit land?" was then told nothing had happened
+     * while the clause block had in fact been swapped. `touched` is what makes the
+     * rewrite visible: the edit tools replace by abolish-and-reassert, so anything
+     * they touched and that still exists was rewritten.
+     */
+    simplePredicateDiff(before, after, touched = []) {
         const beforeSet = new Set(before);
         const afterSet = new Set(after);
+        const touchedSet = new Set(touched);
         const changed = [];
-        for (const predicate of after)
+        for (const predicate of after) {
             if (!beforeSet.has(predicate))
                 changed.push(`+${predicate}`);
+            else if (touchedSet.has(predicate))
+                changed.push(`~${predicate}`);
+        }
         for (const predicate of before)
             if (!afterSet.has(predicate))
                 changed.push(`-${predicate}`);
@@ -1746,13 +2012,16 @@ export class DMLSession {
                 return this.loadDocAsset('harness-patterns');
             case 'snippets':
                 return this.loadDocAsset('prolog-snippets');
+            case 'forms':
+            case 'dml-forms':
+                return this.loadDocAsset('dml-forms');
             case 'tools':
                 return this.hostToolsCatalog ?? '(no host capability tools registered)';
             default:
-                return `unknown reference topic '${topic}'. Topics: language, authoring, examples, patterns, snippets, tools.`;
+                return `unknown reference topic '${topic}'. Topics: language, authoring, examples, patterns, snippets, forms, tools.`;
         }
     }
-    async execute(goal, limit, signal, onEvent, bindingMode = 'full') {
+    async execute(goal, limit, signal, onEvent, bindingMode = 'full', _timeoutMs) {
         return this.executeGoal(goal, limit ?? 5, onEvent, signal, bindingMode);
     }
     /**
@@ -1803,6 +2072,10 @@ export class DMLSession {
             onInputRequired: inputHandler
                 ? (prompt) => this.requireInput(prompt)
                 : async () => undefined,
+            onForm: this.formHandler,
+            // A turn that called suspend/1 stops here; the record is what --session
+            // resumes from (docs/DML_REPL_SUSPEND_RESUME.md).
+            onSuspend: (payload) => this.handleSuspend(payload),
             signal: options.signal,
             onModelCall: () => this.reserveModelCall(),
             // A run that is not itself a process resolves primitives through the
@@ -1810,9 +2083,33 @@ export class DMLSession {
             onProcessRequest: options.process
                 ? (request, signal) => options.process.handle(request, signal)
                 : (request, signal) => this.handleForeground(request, signal),
+            forms: this.forms,
         };
     }
+    /** The session's form host (docs/DML_FORMS.md). */
+    formRegistry() {
+        return this.forms;
+    }
+    /** Install the host-side interaction for opened forms. */
+    setFormHandler(handler) {
+        this.formHandler = handler;
+    }
+    /**
+     * Send a form action from the UI (the REPL's half of the form protocol).
+     * Resolves an `await_form`/`wait_for_form_change` blocked in the session.
+     */
+    submitForm(formId, change) {
+        const record = this.forms.get(formId);
+        if (!record || record.state !== 'open')
+            return false;
+        this.forms.submit(formId, change.action, change.values ?? {}, change.errors ?? []);
+        return true;
+    }
     // ---- TypeScript compaction (ported from pi) ----
+    /** Read the live harness memory (for disposable execute workers). */
+    harnessMemory() {
+        return this.getMemory('harness');
+    }
     /** Read a live memory slot as `MemoryMessage[]`. */
     getMemory(slot) {
         const result = this.prologQuery(`deepclause_mi:repl_get_memory('${this.sessionId}', ${slot}, Messages)`);