@elyracode/coding-agent 0.2.0 → 0.3.0

package/examples/extensions/plan-mode/index.ts

@@ -35,12 +35,12 @@ function getTextContent(message: AssistantMessage): string {
 		.join("\n");
 }
 
-export default function planModeExtension(pi: ExtensionAPI): void {
+export default function planModeExtension(elyra: ExtensionAPI): void {
 	let planModeEnabled = false;
 	let executionMode = false;
 	let todoItems: TodoItem[] = [];
 
-	pi.registerFlag("plan", {
+	elyra.registerFlag("plan", {
 		description: "Start in plan mode (read-only exploration)",
 		type: "boolean",
 		default: false,
@@ -79,29 +79,29 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 		todoItems = [];
 
 		if (planModeEnabled) {
-			pi.setActiveTools(PLAN_MODE_TOOLS);
+			elyra.setActiveTools(PLAN_MODE_TOOLS);
 			ctx.ui.notify(`Plan mode enabled. Tools: ${PLAN_MODE_TOOLS.join(", ")}`);
 		} else {
-			pi.setActiveTools(NORMAL_MODE_TOOLS);
+			elyra.setActiveTools(NORMAL_MODE_TOOLS);
 			ctx.ui.notify("Plan mode disabled. Full access restored.");
 		}
 		updateStatus(ctx);
 	}
 
 	function persistState(): void {
-		pi.appendEntry("plan-mode", {
+		elyra.appendEntry("plan-mode", {
 			enabled: planModeEnabled,
 			todos: todoItems,
 			executing: executionMode,
 		});
 	}
 
-	pi.registerCommand("plan", {
+	elyra.registerCommand("plan", {
 		description: "Toggle plan mode (read-only exploration)",
 		handler: async (_args, ctx) => togglePlanMode(ctx),
 	});
 
-	pi.registerCommand("todos", {
+	elyra.registerCommand("todos", {
 		description: "Show current plan todo list",
 		handler: async (_args, ctx) => {
 			if (todoItems.length === 0) {
@@ -113,13 +113,13 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 		},
 	});
 
-	pi.registerShortcut(Key.ctrlAlt("p"), {
+	elyra.registerShortcut(Key.ctrlAlt("p"), {
 		description: "Toggle plan mode",
 		handler: async (ctx) => togglePlanMode(ctx),
 	});
 
 	// Block destructive bash commands in plan mode
-	pi.on("tool_call", async (event) => {
+	elyra.on("tool_call", async (event) => {
 		if (!planModeEnabled || event.toolName !== "bash") return;
 
 		const command = event.input.command as string;
@@ -132,7 +132,7 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 	});
 
 	// Filter out stale plan mode context when not in plan mode
-	pi.on("context", async (event) => {
+	elyra.on("context", async (event) => {
 		if (planModeEnabled) return;
 
 		return {
@@ -156,7 +156,7 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 	});
 
 	// Inject plan/execution context before agent starts
-	pi.on("before_agent_start", async () => {
+	elyra.on("before_agent_start", async () => {
 		if (planModeEnabled) {
 			return {
 				message: {
@@ -205,7 +205,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
 	});
 
 	// Track progress after each turn
-	pi.on("turn_end", async (event, ctx) => {
+	elyra.on("turn_end", async (event, ctx) => {
 		if (!executionMode || todoItems.length === 0) return;
 		if (!isAssistantMessage(event.message)) return;
 
@@ -217,18 +217,18 @@ After completing a step, include a [DONE:n] tag in your response.`,
 	});
 
 	// Handle plan completion and plan mode UI
-	pi.on("agent_end", async (event, ctx) => {
+	elyra.on("agent_end", async (event, ctx) => {
 		// Check if execution is complete
 		if (executionMode && todoItems.length > 0) {
 			if (todoItems.every((t) => t.completed)) {
 				const completedList = todoItems.map((t) => `~~${t.text}~~`).join("\n");
-				pi.sendMessage(
+				elyra.sendMessage(
 					{ customType: "plan-complete", content: `**Plan Complete!** ✓\n\n${completedList}`, display: true },
 					{ triggerTurn: false },
 				);
 				executionMode = false;
 				todoItems = [];
-				pi.setActiveTools(NORMAL_MODE_TOOLS);
+				elyra.setActiveTools(NORMAL_MODE_TOOLS);
 				updateStatus(ctx);
 				persistState(); // Save cleared state so resume doesn't restore old execution mode
 			}
@@ -249,7 +249,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
 		// Show plan steps and prompt for next action
 		if (todoItems.length > 0) {
 			const todoListText = todoItems.map((t, i) => `${i + 1}. ☐ ${t.text}`).join("\n");
-			pi.sendMessage(
+			elyra.sendMessage(
 				{
 					customType: "plan-todo-list",
 					content: `**Plan Steps (${todoItems.length}):**\n\n${todoListText}`,
@@ -268,28 +268,28 @@ After completing a step, include a [DONE:n] tag in your response.`,
 		if (choice?.startsWith("Execute")) {
 			planModeEnabled = false;
 			executionMode = todoItems.length > 0;
-			pi.setActiveTools(NORMAL_MODE_TOOLS);
+			elyra.setActiveTools(NORMAL_MODE_TOOLS);
 			updateStatus(ctx);
 
 			const execMessage =
 				todoItems.length > 0
 					? `Execute the plan. Start with: ${todoItems[0].text}`
 					: "Execute the plan you just created.";
-			pi.sendMessage(
+			elyra.sendMessage(
 				{ customType: "plan-mode-execute", content: execMessage, display: true },
 				{ triggerTurn: true },
 			);
 		} else if (choice === "Refine the plan") {
 			const refinement = await ctx.ui.editor("Refine the plan:", "");
 			if (refinement?.trim()) {
-				pi.sendUserMessage(refinement.trim());
+				elyra.sendUserMessage(refinement.trim());
 			}
 		}
 	});
 
 	// Restore state on session start/resume
-	pi.on("session_start", async (_event, ctx) => {
-		if (pi.getFlag("plan") === true) {
+	elyra.on("session_start", async (_event, ctx) => {
+		if (elyra.getFlag("plan") === true) {
 			planModeEnabled = true;
 		}
 
@@ -333,7 +333,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
 		}
 
 		if (planModeEnabled) {
-			pi.setActiveTools(PLAN_MODE_TOOLS);
+			elyra.setActiveTools(PLAN_MODE_TOOLS);
 		}
 		updateStatus(ctx);
 	});

package/examples/extensions/preset.ts

@@ -104,14 +104,14 @@ interface OriginalState {
 	tools: string[];
 }
 
-export default function presetExtension(pi: ExtensionAPI) {
+export default function presetExtension(elyra: ExtensionAPI) {
 	let presets: PresetsConfig = {};
 	let activePresetName: string | undefined;
 	let activePreset: Preset | undefined;
 	let originalState: OriginalState | undefined;
 
 	// Register --preset CLI flag
-	pi.registerFlag("preset", {
+	elyra.registerFlag("preset", {
 		description: "Preset configuration to use",
 		type: "string",
 	});
@@ -124,8 +124,8 @@ export default function presetExtension(pi: ExtensionAPI) {
 		if (activePresetName === undefined) {
 			originalState = {
 				model: ctx.model,
-				thinkingLevel: pi.getThinkingLevel(),
-				tools: pi.getActiveTools(),
+				thinkingLevel: elyra.getThinkingLevel(),
+				tools: elyra.getActiveTools(),
 			};
 		}
 
@@ -133,7 +133,7 @@ export default function presetExtension(pi: ExtensionAPI) {
 		if (preset.provider && preset.model) {
 			const model = ctx.modelRegistry.find(preset.provider, preset.model);
 			if (model) {
-				const success = await pi.setModel(model);
+				const success = await elyra.setModel(model);
 				if (!success) {
 					ctx.ui.notify(`Preset "${name}": No API key for ${preset.provider}/${preset.model}`, "warning");
 				}
@@ -144,12 +144,12 @@ export default function presetExtension(pi: ExtensionAPI) {
 
 		// Apply thinking level if specified
 		if (preset.thinkingLevel) {
-			pi.setThinkingLevel(preset.thinkingLevel);
+			elyra.setThinkingLevel(preset.thinkingLevel);
 		}
 
 		// Apply tools if specified
 		if (preset.tools && preset.tools.length > 0) {
-			const allToolNames = pi.getAllTools().map((t) => t.name);
+			const allToolNames = elyra.getAllTools().map((t) => t.name);
 			const validTools = preset.tools.filter((t) => allToolNames.includes(t));
 			const invalidTools = preset.tools.filter((t) => !allToolNames.includes(t));
 
@@ -158,7 +158,7 @@ export default function presetExtension(pi: ExtensionAPI) {
 			}
 
 			if (validTools.length > 0) {
-				pi.setActiveTools(validTools);
+				elyra.setActiveTools(validTools);
 			}
 		}
 
@@ -273,12 +273,12 @@ export default function presetExtension(pi: ExtensionAPI) {
 			activePreset = undefined;
 			if (originalState) {
 				if (originalState.model) {
-					await pi.setModel(originalState.model);
+					await elyra.setModel(originalState.model);
 				}
-				pi.setThinkingLevel(originalState.thinkingLevel);
-				pi.setActiveTools(originalState.tools);
+				elyra.setThinkingLevel(originalState.thinkingLevel);
+				elyra.setActiveTools(originalState.tools);
 			} else {
-				pi.setActiveTools(["read", "bash", "edit", "write"]);
+				elyra.setActiveTools(["read", "bash", "edit", "write"]);
 			}
 			ctx.ui.notify("Preset cleared, defaults restored", "info");
 			updateStatus(ctx);
@@ -329,12 +329,12 @@ export default function presetExtension(pi: ExtensionAPI) {
 			activePreset = undefined;
 			if (originalState) {
 				if (originalState.model) {
-					await pi.setModel(originalState.model);
+					await elyra.setModel(originalState.model);
 				}
-				pi.setThinkingLevel(originalState.thinkingLevel);
-				pi.setActiveTools(originalState.tools);
+				elyra.setThinkingLevel(originalState.thinkingLevel);
+				elyra.setActiveTools(originalState.tools);
 			} else {
-				pi.setActiveTools(["read", "bash", "edit", "write"]);
+				elyra.setActiveTools(["read", "bash", "edit", "write"]);
 			}
 			ctx.ui.notify("Preset cleared, defaults restored", "info");
 			updateStatus(ctx);
@@ -349,7 +349,7 @@ export default function presetExtension(pi: ExtensionAPI) {
 		updateStatus(ctx);
 	}
 
-	pi.registerShortcut(Key.ctrlShift("u"), {
+	elyra.registerShortcut(Key.ctrlShift("u"), {
 		description: "Cycle presets",
 		handler: async (ctx) => {
 			await cyclePreset(ctx);
@@ -357,7 +357,7 @@ export default function presetExtension(pi: ExtensionAPI) {
 	});
 
 	// Register /preset command
-	pi.registerCommand("preset", {
+	elyra.registerCommand("preset", {
 		description: "Switch preset configuration",
 		handler: async (args, ctx) => {
 			// If preset name provided, apply directly
@@ -383,7 +383,7 @@ export default function presetExtension(pi: ExtensionAPI) {
 	});
 
 	// Inject preset instructions into system prompt
-	pi.on("before_agent_start", async (event) => {
+	elyra.on("before_agent_start", async (event) => {
 		if (activePreset?.instructions) {
 			return {
 				systemPrompt: `${event.systemPrompt}\n\n${activePreset.instructions}`,
@@ -392,12 +392,12 @@ export default function presetExtension(pi: ExtensionAPI) {
 	});
 
 	// Initialize on session start
-	pi.on("session_start", async (_event, ctx) => {
+	elyra.on("session_start", async (_event, ctx) => {
 		// Load presets from config files
 		presets = loadPresets(ctx.cwd);
 
 		// Check for --preset flag
-		const presetFlag = pi.getFlag("preset");
+		const presetFlag = elyra.getFlag("preset");
 		if (typeof presetFlag === "string" && presetFlag) {
 			const preset = presets[presetFlag];
 			if (preset) {
@@ -428,9 +428,9 @@ export default function presetExtension(pi: ExtensionAPI) {
 	});
 
 	// Persist preset state
-	pi.on("turn_start", async () => {
+	elyra.on("turn_start", async () => {
 		if (activePresetName) {
-			pi.appendEntry("preset-state", { name: activePresetName });
+			elyra.appendEntry("preset-state", { name: activePresetName });
 		}
 	});
 }

package/examples/extensions/prompt-customizer.ts

@@ -83,8 +83,8 @@ If you have additional requirements, configure them via --append-system-prompt o
 	return extensionSpecific;
 }
 
-export default function promptCustomizer(pi: ExtensionAPI) {
-	pi.on("before_agent_start", async (event) => {
+export default function promptCustomizer(elyra: ExtensionAPI) {
+	elyra.on("before_agent_start", async (event) => {
 		const { systemPrompt, systemPromptOptions } = event;
 
 		const customPrompt = addToolGuidance(systemPromptOptions, systemPrompt);

package/examples/extensions/protected-paths.ts

@@ -7,10 +7,10 @@
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	const protectedPaths = [".env", ".git/", "node_modules/"];
 
-	pi.on("tool_call", async (event, ctx) => {
+	elyra.on("tool_call", async (event, ctx) => {
 		if (event.toolName !== "write" && event.toolName !== "edit") {
 			return undefined;
 		}

package/examples/extensions/provider-payload.ts

@@ -2,17 +2,17 @@ import { appendFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	const logFile = join(process.cwd(), ".elyra", "provider-payload.log");
 
-	pi.on("before_provider_request", (event) => {
+	elyra.on("before_provider_request", (event) => {
 		appendFileSync(logFile, `${JSON.stringify(event.payload, null, 2)}\n\n`, "utf8");
 
 		// Optional: replace the payload instead of only logging it.
 		// return { ...event.payload, temperature: 0 };
 	});
 
-	pi.on("after_provider_response", (event) => {
+	elyra.on("after_provider_response", (event) => {
 		appendFileSync(logFile, `[${event.status}] ${JSON.stringify(event.headers)}\n\n`, "utf8");
 	});
 }

package/examples/extensions/qna.ts

@@ -27,8 +27,8 @@ A:
 
 Keep questions in the order they appeared. Be concise.`;
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("qna", {
+export default function (elyra: ExtensionAPI) {
+	elyra.registerCommand("qna", {
 		description: "Extract questions from last assistant message into editor",
 		handler: async (_args, ctx) => {
 			if (!ctx.hasUI) {

package/examples/extensions/question.ts

@@ -33,8 +33,8 @@ const QuestionParams = Type.Object({
 	options: Type.Array(OptionSchema, { description: "Options for the user to choose from" }),
 });
 
-export default function question(pi: ExtensionAPI) {
-	pi.registerTool({
+export default function question(elyra: ExtensionAPI) {
+	elyra.registerTool({
 		name: "question",
 		label: "Question",
 		description: "Ask the user a question and let them pick from options. Use when you need user input to proceed.",

package/examples/extensions/questionnaire.ts

@@ -73,8 +73,8 @@ function errorResult(
 	};
 }
 
-export default function questionnaire(pi: ExtensionAPI) {
-	pi.registerTool({
+export default function questionnaire(elyra: ExtensionAPI) {
+	elyra.registerTool({
 		name: "questionnaire",
 		label: "Questionnaire",
 		description:

package/examples/extensions/rainbow-editor.ts

@@ -81,8 +81,8 @@ class RainbowEditor extends CustomEditor {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", (_event, ctx) => {
+export default function (elyra: ExtensionAPI) {
+	elyra.on("session_start", (_event, ctx) => {
 		ctx.ui.setEditorComponent((tui, theme, kb) => new RainbowEditor(tui, theme, kb));
 	});
 }

package/examples/extensions/reload-runtime.ts

@@ -8,10 +8,10 @@
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 import { Type } from "typebox";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	// Command entrypoint for reload.
 	// Treat reload as terminal for this handler.
-	pi.registerCommand("reload-runtime", {
+	elyra.registerCommand("reload-runtime", {
 		description: "Reload extensions, skills, prompts, and themes",
 		handler: async (_args, ctx) => {
 			await ctx.reload();
@@ -21,13 +21,13 @@ export default function (pi: ExtensionAPI) {
 
 	// LLM-callable tool. Tools get ExtensionContext, so they cannot call ctx.reload() directly.
 	// Instead, queue a follow-up user command that executes the command above.
-	pi.registerTool({
+	elyra.registerTool({
 		name: "reload_runtime",
 		label: "Reload Runtime",
 		description: "Reload extensions, skills, prompts, and themes",
 		parameters: Type.Object({}),
 		async execute() {
-			pi.sendUserMessage("/reload-runtime", { deliverAs: "followUp" });
+			elyra.sendUserMessage("/reload-runtime", { deliverAs: "followUp" });
 			return {
 				content: [{ type: "text", text: "Queued /reload-runtime as a follow-up command." }],
 				details: {},

package/examples/extensions/rpc-demo.ts

@@ -19,31 +19,31 @@
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	let turnCount = 0;
 
 	// -- setTitle, setWidget, setStatus on session lifecycle --
 
-	pi.on("session_start", async (event, ctx) => {
-		ctx.ui.setTitle(event.reason === "new" ? "pi RPC Demo (new session)" : "pi RPC Demo");
+	elyra.on("session_start", async (event, ctx) => {
+		ctx.ui.setTitle(event.reason === "new" ? "elyra RPC Demo (new session)" : "elyra RPC Demo");
 		ctx.ui.setWidget("rpc-demo", ["--- RPC Extension UI Demo ---", "Loaded and ready."]);
 		ctx.ui.setStatus("rpc-demo", `Turns: ${turnCount}`);
 	});
 
 	// -- setStatus on turn lifecycle --
 
-	pi.on("turn_start", async (_event, ctx) => {
+	elyra.on("turn_start", async (_event, ctx) => {
 		turnCount++;
 		ctx.ui.setStatus("rpc-demo", `Turn ${turnCount} running...`);
 	});
 
-	pi.on("turn_end", async (_event, ctx) => {
+	elyra.on("turn_end", async (_event, ctx) => {
 		ctx.ui.setStatus("rpc-demo", `Turn ${turnCount} done`);
 	});
 
 	// -- select on dangerous tool calls --
 
-	pi.on("tool_call", async (event, ctx) => {
+	elyra.on("tool_call", async (event, ctx) => {
 		if (event.toolName !== "bash") return undefined;
 
 		const command = event.input.command as string;
@@ -67,7 +67,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- confirm on session clear --
 
-	pi.on("session_before_switch", async (event, ctx) => {
+	elyra.on("session_before_switch", async (event, ctx) => {
 		if (event.reason !== "new") return;
 		if (!ctx.hasUI) return;
 
@@ -80,7 +80,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- input via command --
 
-	pi.registerCommand("rpc-input", {
+	elyra.registerCommand("rpc-input", {
 		description: "Prompt for text input (demonstrates ctx.ui.input in RPC)",
 		handler: async (_args, ctx) => {
 			const value = await ctx.ui.input("Enter a value", "type something...");
@@ -94,7 +94,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- editor via command --
 
-	pi.registerCommand("rpc-editor", {
+	elyra.registerCommand("rpc-editor", {
 		description: "Open multi-line editor (demonstrates ctx.ui.editor in RPC)",
 		handler: async (_args, ctx) => {
 			const text = await ctx.ui.editor("Edit some text", "Line 1\nLine 2\nLine 3");
@@ -108,7 +108,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- setEditorText via command --
 
-	pi.registerCommand("rpc-prefill", {
+	elyra.registerCommand("rpc-prefill", {
 		description: "Prefill the input editor (demonstrates ctx.ui.setEditorText in RPC)",
 		handler: async (_args, ctx) => {
 			ctx.ui.setEditorText("This text was set by the rpc-demo extension.");

package/examples/extensions/sandbox/index.ts

@@ -198,8 +198,8 @@ function createSandboxedBashOps(): BashOperations {
 	};
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.registerFlag("no-sandbox", {
+export default function (elyra: ExtensionAPI) {
+	elyra.registerFlag("no-sandbox", {
 		description: "Disable OS-level sandboxing for bash commands",
 		type: "boolean",
 		default: false,
@@ -211,7 +211,7 @@ export default function (pi: ExtensionAPI) {
 	let sandboxEnabled = false;
 	let sandboxInitialized = false;
 
-	pi.registerTool({
+	elyra.registerTool({
 		...localBash,
 		label: "bash (sandboxed)",
 		async execute(id, params, signal, onUpdate, _ctx) {
@@ -226,13 +226,13 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.on("user_bash", () => {
+	elyra.on("user_bash", () => {
 		if (!sandboxEnabled || !sandboxInitialized) return;
 		return { operations: createSandboxedBashOps() };
 	});
 
-	pi.on("session_start", async (_event, ctx) => {
-		const noSandbox = pi.getFlag("no-sandbox") as boolean;
+	elyra.on("session_start", async (_event, ctx) => {
+		const noSandbox = elyra.getFlag("no-sandbox") as boolean;
 
 		if (noSandbox) {
 			sandboxEnabled = false;
@@ -284,7 +284,7 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	pi.on("session_shutdown", async () => {
+	elyra.on("session_shutdown", async () => {
 		if (sandboxInitialized) {
 			try {
 				await SandboxManager.reset();
@@ -294,7 +294,7 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	pi.registerCommand("sandbox", {
+	elyra.registerCommand("sandbox", {
 		description: "Show sandbox configuration",
 		handler: async (_args, ctx) => {
 			if (!sandboxEnabled) {

package/examples/extensions/sandbox/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "elyra-extension-sandbox",
 	"private": true,
-	"version": "0.2.0",
-			"type": "module",
+	"version": "0.3.0",
+				"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",
 		"build": "echo 'nothing to build'",

package/examples/extensions/send-user-message.ts

@@ -1,8 +1,8 @@
 /**
  * Send User Message Example
  *
- * Demonstrates pi.sendUserMessage() for sending user messages from extensions.
- * Unlike pi.sendMessage() which sends custom messages, sendUserMessage() sends
+ * Demonstrates elyra.sendUserMessage() for sending user messages from extensions.
+ * Unlike elyra.sendMessage() which sends custom messages, sendUserMessage() sends
  * actual user messages that appear in the conversation as if typed by the user.
  *
  * Usage:
@@ -13,9 +13,9 @@
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	// Simple command that sends a user message
-	pi.registerCommand("ask", {
+	elyra.registerCommand("ask", {
 		description: "Send a user message to the agent",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -30,12 +30,12 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			pi.sendUserMessage(args);
+			elyra.sendUserMessage(args);
 		},
 	});
 
 	// Command that steers the agent mid-conversation
-	pi.registerCommand("steer", {
+	elyra.registerCommand("steer", {
 		description: "Send a steering message (interrupts current processing)",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -45,16 +45,16 @@ export default function (pi: ExtensionAPI) {
 
 			if (ctx.isIdle()) {
 				// Not streaming, just send normally
-				pi.sendUserMessage(args);
+				elyra.sendUserMessage(args);
 			} else {
 				// Streaming - use steer to interrupt
-				pi.sendUserMessage(args, { deliverAs: "steer" });
+				elyra.sendUserMessage(args, { deliverAs: "steer" });
 			}
 		},
 	});
 
 	// Command that queues a follow-up message
-	pi.registerCommand("followup", {
+	elyra.registerCommand("followup", {
 		description: "Queue a follow-up message (waits for current processing)",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -64,17 +64,17 @@ export default function (pi: ExtensionAPI) {
 
 			if (ctx.isIdle()) {
 				// Not streaming, just send normally
-				pi.sendUserMessage(args);
+				elyra.sendUserMessage(args);
 			} else {
 				// Streaming - queue as follow-up
-				pi.sendUserMessage(args, { deliverAs: "followUp" });
+				elyra.sendUserMessage(args, { deliverAs: "followUp" });
 				ctx.ui.notify("Follow-up queued", "info");
 			}
 		},
 	});
 
 	// Example with content array (text + images would go here)
-	pi.registerCommand("askwith", {
+	elyra.registerCommand("askwith", {
 		description: "Send a user message with structured content",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -88,7 +88,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			// sendUserMessage accepts string or (TextContent | ImageContent)[]
-			pi.sendUserMessage([
+			elyra.sendUserMessage([
 				{ type: "text", text: `User request: ${args}` },
 				{ type: "text", text: "Please respond concisely." },
 			]);