@chatbridge/vscode 0.8.2 → 0.9.0

package/dist/chat-view-bridge.d.ts

@@ -1,3 +1,4 @@
+import type { CommandInfo } from "@chatbridge/core";
 import type { QueueEntry, State, ToHost, ToWebview, UiConfig, WebviewCommand } from "./protocol.js";
 /** The slice of vscode.Webview the bridge uses; a fake in tests. */
 export interface WebviewLike {
@@ -12,6 +13,7 @@ export interface ChatViewHandlers {
     takeBack(): void;
     removeQueued(index: number): void;
     command(name: WebviewCommand): void;
+    customCommand(name: string, args: string, text: string): void;
     attachUris(uris: string[]): void;
     pasted(id: number, text: string): void;
 }
@@ -24,7 +26,7 @@ export declare class ChatViewBridge {
     private readonly handlers;
     private webview;
     constructor(getState: () => State, handlers: ChatViewHandlers);
-    attach(webview: WebviewLike, uiConfig?: UiConfig): {
+    attach(webview: WebviewLike, uiConfig?: UiConfig, commands?: CommandInfo[]): {
         dispose(): void;
     };
     pushState(state: State): void;

package/dist/chat-view-bridge.js

@@ -25,6 +25,10 @@ function isToHost(m) {
             return typeof msg.index === "number";
         case "command":
             return typeof msg.name === "string" && COMMANDS.has(msg.name);
+        case "customCommand":
+            return (typeof msg.name === "string" &&
+                typeof msg.args === "string" &&
+                typeof msg.text === "string");
         case "attachUris":
             return (Array.isArray(msg.uris) && msg.uris.every((u) => typeof u === "string"));
         case "pasted":
@@ -43,15 +47,20 @@ export class ChatViewBridge {
         this.getState = getState;
         this.handlers = handlers;
     }
-    attach(webview, uiConfig) {
+    attach(webview, uiConfig, commands) {
         this.webview = webview;
         const sub = webview.onDidReceiveMessage((raw) => {
             if (!isToHost(raw))
                 return;
             switch (raw.type) {
                 case "ready":
-                    if (uiConfig)
-                        void webview.postMessage({ type: "config", ...uiConfig });
+                    if (uiConfig || commands) {
+                        void webview.postMessage({
+                            type: "config",
+                            ...uiConfig,
+                            ...(commands ? { commands } : {}),
+                        });
+                    }
                     this.pushState(this.getState());
                     break;
                 case "send":
@@ -69,6 +78,9 @@ export class ChatViewBridge {
                 case "command":
                     this.handlers.command(raw.name);
                     break;
+                case "customCommand":
+                    this.handlers.customCommand(raw.name, raw.args, raw.text);
+                    break;
                 case "attachUris":
                     this.handlers.attachUris(raw.uris);
                     break;

package/dist/chat-view-provider.d.ts

@@ -1,3 +1,4 @@
+import type { CommandInfo } from "@chatbridge/core";
 import * as vscode from "vscode";
 import type { ChatViewBridge } from "./chat-view-bridge.js";
 import type { ResolvedUiConfig } from "./ui-config.js";
@@ -6,6 +7,7 @@ export declare class ChatViewProvider implements vscode.WebviewViewProvider {
     private readonly title;
     private readonly bridge;
     private readonly ui?;
-    constructor(extensionUri: vscode.Uri, title: string, bridge: ChatViewBridge, ui?: ResolvedUiConfig | undefined);
+    private readonly commands?;
+    constructor(extensionUri: vscode.Uri, title: string, bridge: ChatViewBridge, ui?: ResolvedUiConfig | undefined, commands?: CommandInfo[] | undefined);
     resolveWebviewView(view: vscode.WebviewView): void;
 }

package/dist/chat-view-provider.js

@@ -6,11 +6,13 @@ export class ChatViewProvider {
     title;
     bridge;
     ui;
-    constructor(extensionUri, title, bridge, ui) {
+    commands;
+    constructor(extensionUri, title, bridge, ui, commands) {
         this.extensionUri = extensionUri;
         this.title = title;
         this.bridge = bridge;
         this.ui = ui;
+        this.commands = commands;
     }
     resolveWebviewView(view) {
         const root = vscode.Uri.joinPath(this.extensionUri, "dist", "webview");
@@ -44,7 +46,7 @@ export class ChatViewProvider {
                 }
                 : rest;
         }
-        const sub = this.bridge.attach(view.webview, uiConfig);
+        const sub = this.bridge.attach(view.webview, uiConfig, this.commands);
         view.onDidDispose(() => sub.dispose());
     }
 }

package/dist/commands.d.ts

@@ -1,6 +1,6 @@
-import type { LoginOptions } from "@chatbridge/core";
+import type { CommandInfo, LoginOptions } from "@chatbridge/core";
 import type { InstallBrowserOptions } from "./install-browser.js";
-import type { SessionController } from "./session-controller.js";
+import type { SendResult, SessionController } from "./session-controller.js";
 import type { VscodeUi } from "./vscode-ui.js";
 export interface CommandDeps {
     displayName: string;
@@ -12,6 +12,8 @@ export interface CommandDeps {
     loginOptions: () => Omit<LoginOptions, "signal" | "onProgress">;
     installOptions: () => Omit<InstallBrowserOptions, "onProgress">;
     clearAuth: () => Promise<void>;
+    /** The provider's own commands, listed by `/help`. */
+    commands?: readonly CommandInfo[];
 }
 export interface CommandHandlers {
     login(): Promise<void>;
@@ -21,11 +23,14 @@ export interface CommandHandlers {
     installBrowser(): Promise<void>;
     /** From the webview's `/help`: the listing joins the history. */
     help(): void;
+    /** From the webview's `/name args`. */
+    customCommand(name: string, args: string, text: string): Promise<void>;
     sendSelection(): Promise<void>;
     sendFile(uri: unknown): Promise<void>;
     focus(): void;
-    /** From the webview's input box. */
-    send(text: string): Promise<void>;
+    /** From the webview's input box. The result is returned so the caller can
+     * hand the text back to the composer when the turn was refused. */
+    send(text: string): Promise<SendResult>;
     /** Files dropped on the webview; unreadable URIs are reported together. */
     attachUris(uris: string[]): Promise<void>;
     /** A paste into the input box; true when it became a selection chip. */

package/dist/commands.js

@@ -91,7 +91,17 @@ export function createCommands(deps) {
             }
         },
         reopen: () => controller.reopen(),
-        help: () => controller.pushHelp(helpText()),
+        help: () => controller.pushHelp(helpText(deps.commands ?? [])),
+        async customCommand(name, args, text) {
+            const result = await controller.runCommand(name, args, text);
+            if (result.ok || result.code !== "BROWSER_UNAVAILABLE")
+                return;
+            const choice = await ui.showErrorMessage(result.message, "Install");
+            if (choice !== "Install")
+                return;
+            if (await runInstall())
+                await controller.retryLast();
+        },
         async installBrowser() {
             if (await runInstall())
                 ui.showInformationMessage("Chromium installed.");
@@ -150,12 +160,13 @@ export function createCommands(deps) {
         async send(text) {
             const result = await controller.send(text);
             if (result.ok || result.code !== "BROWSER_UNAVAILABLE")
-                return;
+                return result;
             const choice = await ui.showErrorMessage(result.message, "Install");
             if (choice !== "Install")
-                return;
+                return result;
             if (await runInstall())
                 await controller.retryLast();
+            return result;
         },
     };
 }

package/dist/create-extension.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { ChatSession, createAuthStore, runLogin, } from "@chatbridge/core";
+import { ChatSession, commandInfoOf, createAuthStore, resolveUrlHooks, runLogin, } from "@chatbridge/core";
 import * as vscode from "vscode";
 import { ChatViewBridge } from "./chat-view-bridge.js";
 import { ChatViewProvider } from "./chat-view-provider.js";
@@ -28,8 +28,15 @@ export function createExtension(opts) {
         const output = vscode.window.createOutputChannel(opts.displayName);
         const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
         context.subscriptions.push(output, statusBar);
+        const commands = commandInfoOf(opts.provider);
         const bridge = new ChatViewBridge(() => controller.getState(), {
-            send: (text) => void handlers.send(text),
+            send: (text) => void handlers.send(text).then((r) => {
+                // The webview empties the composer as it posts `send`; a hook
+                // refusal sends nothing, so give the text back to be fixed.
+                if (!r.ok && r.code === "URL_HOOK") {
+                    bridge.pushTookBack([{ text, attachments: [] }]);
+                }
+            }),
             removeAttachment: (i) => controller?.removeAttachment(i),
             takeBack: () => {
                 const r = controller?.takeBack();
@@ -45,6 +52,7 @@ export function createExtension(opts) {
             },
             removeQueued: (i) => controller?.removeQueued(i),
             command: (name) => void handlers[name](),
+            customCommand: (name, args, text) => void handlers.customCommand(name, args, text),
             attachUris: (uris) => void handlers.attachUris(uris),
             pasted: (id, text) => bridge.pushPasteResult(id, handlers.pasted(text)),
         });
@@ -74,6 +82,9 @@ export function createExtension(opts) {
                 ...settings(),
                 onProgress: progress,
             }),
+            expandUrls: (text) => resolveUrlHooks(text, opts.provider.urlHooks ?? [], {
+                timeoutMs: settings().timeoutMs,
+            }),
             hints: {
                 BLOCKED: `Set the "${opts.id}.headless" setting to false and try again.`,
                 BROWSER_UNAVAILABLE: `Run "${opts.displayName}: Install Browser" and send again.`,
@@ -104,8 +115,9 @@ export function createExtension(opts) {
                 return { cliPath };
             },
             clearAuth: () => authStore.clear(),
+            commands,
         });
-        context.subscriptions.push(vscode.window.registerWebviewViewProvider(`${opts.id}.chat`, new ChatViewProvider(context.extensionUri, opts.displayName, bridge, uiConfig)));
+        context.subscriptions.push(vscode.window.registerWebviewViewProvider(`${opts.id}.chat`, new ChatViewProvider(context.extensionUri, opts.displayName, bridge, uiConfig, commands)));
         for (const name of COMMAND_NAMES) {
             context.subscriptions.push(vscode.commands.registerCommand(`${opts.id}.${name}`, (arg) => name === "sendFile" ? handlers.sendFile(arg) : handlers[name]()));
         }

package/dist/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { Attachment } from "@chatbridge/core";
+import type { Attachment, CommandInfo } from "@chatbridge/core";
 export type Role = "user" | "assistant" | "error" | "separator" | "help";
 export interface Message {
     role: Role;
@@ -45,6 +45,13 @@ export type ToHost = {
     type: "command";
     name: WebviewCommand;
 }
+/** A provider `/command`; `text` is the line as typed, for the history. */
+ | {
+    type: "customCommand";
+    name: string;
+    args: string;
+    text: string;
+}
 /** Files dropped on the webview, as URI strings. */
  | {
     type: "attachUris";
@@ -78,7 +85,10 @@ export type ToWebview = ({
     text: string;
 } | ({
     type: "config";
-} & UiConfig)
+} & UiConfig & {
+    /** The provider's commands, so the webview can parse `/name args`. */
+    commands?: CommandInfo[];
+})
 /** Answer to `pasted`: when attached, the webview drops the pasted text. */
  | {
     type: "pasteResult";

package/dist/session-controller.d.ts

@@ -1,8 +1,9 @@
-import { type Attachment } from "@chatbridge/core";
+import { type Attachment, type ProviderCommandResult, type ResolvedUrl } from "@chatbridge/core";
 import type { QueueEntry, State } from "./protocol.js";
 /** What the controller needs from a ChatSession; lets tests inject a fake. */
 export interface ChatSessionLike {
     send(prompt: string): Promise<string>;
+    runCommand?(name: string, args: string): Promise<ProviderCommandResult>;
     close(): Promise<void>;
     kill(): Promise<void>;
 }
@@ -47,6 +48,9 @@ export interface SessionControllerOptions {
      * `ChatBridgeError.code`. Core's messages carry no UI-specific remedy;
      * the extension adds the VSCode-side one. */
     hints?: Partial<Record<HintCode, string>>;
+    /** URL hook expansion for the text of a turn; the extension builds it from
+     * the provider's hooks and the timeout setting. Default: none. */
+    expandUrls?: (text: string) => Promise<ResolvedUrl[]>;
 }
 export declare const CLOSE_TIMEOUT_MS = 5000;
 /** Owns the history, the pending attachments and the ChatSession. No
@@ -69,6 +73,10 @@ export declare class SessionController {
     /** The openSession in flight (first send or reopen), so close() can wait
      * for it instead of orphaning the browser it is about to produce. */
     private opening;
+    /** True while a turn's URL hooks are being resolved: the turn is claimed
+     * but no status change shows it yet, so a send arriving meanwhile must
+     * queue rather than start a second turn. */
+    private expanding;
     private readonly closeTimeoutMs;
     constructor(opts: SessionControllerOptions);
     getState(): State;
@@ -87,8 +95,23 @@ export declare class SessionController {
      * when a turn is already running. Never throws: the outcome is the
      * result and the history. */
     send(text: string): Promise<SendResult>;
-    /** Pushes the user entry and runs the turn. Shared by send and drain. */
+    /** Pushes the user entry and runs the turn (or the command). Shared by
+     * send, runCommand and drain. */
     private startTurn;
+    /** A provider `/command` from the webview. Queued like a message when a
+     * turn is running; `text` is the line as typed, which is what the
+     * history shows. */
+    runCommand(name: string, args: string, text: string): Promise<SendResult>;
+    /** Runs the command on the session (opening one lazily, like a turn).
+     * `show` prints; `send` continues as an ordinary turn with the prompt. */
+    private runProviderCommand;
+    /** Leaves a ready status synchronously, before the first await, so a
+     * send arriving in the same tick queues instead of starting a second
+     * turn on the session. */
+    private claimTurn;
+    /** The open session, opening one when there is none. Undefined when a
+     * reopen ran meanwhile (the caller's generation is stale). */
+    private ensureSession;
     /** Starts the oldest queued entry, if any, when the controller is ready
      * for a turn. Called at every transition back to a ready state, before
      * the caller emits, so the webview never sees an idle frame with a

package/dist/session-controller.js

@@ -1,4 +1,4 @@
-import { ChatBridgeError, MAX_FILE_BYTES, MAX_TOTAL_BYTES, closeOrKill, formatAttachment, formatSize, } from "@chatbridge/core";
+import { ChatBridgeError, MAX_FILE_BYTES, MAX_TOTAL_BYTES, UrlHookError, closeOrKill, formatAttachment, formatSize, } from "@chatbridge/core";
 /** The separator pushed into the history by `reopen()`. */
 export const REOPENED_SEPARATOR = "reopened";
 export const CLOSE_TIMEOUT_MS = 5_000;
@@ -27,6 +27,10 @@ export class SessionController {
     /** The openSession in flight (first send or reopen), so close() can wait
      * for it instead of orphaning the browser it is about to produce. */
     opening;
+    /** True while a turn's URL hooks are being resolved: the turn is claimed
+     * but no status change shows it yet, so a send arriving meanwhile must
+     * queue rather than start a second turn. */
+    expanding = false;
     closeTimeoutMs;
     constructor(opts) {
         this.opts = opts;
@@ -95,6 +99,8 @@ export class SessionController {
      * send is the user retrying, and only automatic draining must stop
      * while the controller is dead. */
     get canStartTurn() {
+        if (this.expanding)
+            return false;
         return (this.status === "idle" ||
             this.status === "closed" ||
             this.status === "dead");
@@ -120,19 +126,151 @@ export class SessionController {
         }
         return this.startTurn({ text: body, attachments });
     }
-    /** Pushes the user entry and runs the turn. Shared by send and drain. */
-    startTurn(turn) {
-        const sections = turn.attachments.map((a) => formatAttachment(a.path, a.content));
+    /** Pushes the user entry and runs the turn (or the command). Shared by
+     * send, runCommand and drain. */
+    async startTurn(turn) {
+        // URL expansion is a network wait; a reopen or a close during it makes
+        // this turn stale, and it must not open a browser of its own.
+        const generation = this.generation;
+        if (turn.command) {
+            this.push({ role: "user", text: turn.text, attachments: [] });
+            return this.runProviderCommand(turn.command, generation);
+        }
+        let attachments = turn.attachments;
+        if (this.opts.expandUrls) {
+            this.expanding = true;
+            try {
+                const urls = await this.opts.expandUrls(turn.text);
+                if (generation !== this.generation) {
+                    // Stale: the reopen/close owns the state now. The turn is not
+                    // sent, but `send` already emptied the composer, so give the
+                    // attachments back and leave the text in the history.
+                    this.expanding = false;
+                    this.pending = [...turn.attachments, ...this.pending];
+                    this.messages.push({
+                        role: "error",
+                        text: `Reopened while resolving URLs; message not sent: ${turn.text}`,
+                    });
+                    // Nothing else will run the entries queued behind this one. Only
+                    // from `idle`: a stale turn from `close()` must not open a browser
+                    // after deactivate.
+                    if (this.status === "idle")
+                        this.drain();
+                    this.emit();
+                    return { ok: true };
+                }
+                attachments = [
+                    ...attachments,
+                    ...urls.map((u) => ({
+                        path: u.label,
+                        bytes: u.bytes,
+                        content: u.content,
+                    })),
+                ];
+            }
+            catch (err) {
+                if (!(err instanceof UrlHookError))
+                    throw err;
+                // The user's to fix: report, send nothing, leave the status alone.
+                const message = err.message;
+                // Cleared here rather than only in `finally`, which runs after the
+                // push and the drain below: both must see the turn released.
+                this.expanding = false;
+                // The composer was emptied by `send`; give the attachments back so
+                // the user only has to re-type the text.
+                this.pending = [...turn.attachments, ...this.pending];
+                this.push({ role: "error", text: message });
+                // Nothing else will run the entries that queued behind this one.
+                this.drain();
+                return { ok: false, code: "URL_HOOK", message };
+            }
+            finally {
+                this.expanding = false;
+            }
+        }
+        const sections = attachments.map((a) => formatAttachment(a.path, a.content));
         const prompt = [turn.text, ...sections]
             .filter((s) => s !== "")
             .join("\n\n");
         this.push({
             role: "user",
             text: turn.text,
-            attachments: turn.attachments.map(({ path, bytes }) => ({ path, bytes })),
+            attachments: attachments.map(({ path, bytes }) => ({ path, bytes })),
         });
         this.lastPrompt = prompt;
-        return this.runTurn(prompt);
+        return this.runTurn(prompt, generation);
+    }
+    /** A provider `/command` from the webview. Queued like a message when a
+     * turn is running; `text` is the line as typed, which is what the
+     * history shows. */
+    async runCommand(name, args, text) {
+        const turn = { text, attachments: [], command: { name, args } };
+        if (!this.canStartTurn || this.queue.length > 0) {
+            this.queue.push(turn);
+            this.drain();
+            this.emit();
+            return { ok: true, queued: true };
+        }
+        return this.startTurn(turn);
+    }
+    /** Runs the command on the session (opening one lazily, like a turn).
+     * `show` prints; `send` continues as an ordinary turn with the prompt. */
+    async runProviderCommand(command, generation) {
+        this.lastError = undefined;
+        // A `show` sets no prompt; leaving the previous turn's would make a
+        // retryLast after a failure resend that message instead. A `send`
+        // result sets it again below.
+        this.lastPrompt = undefined;
+        this.claimTurn();
+        try {
+            const session = await this.ensureSession(generation);
+            if (session === undefined)
+                return { ok: true }; // stale
+            if (session.runCommand === undefined) {
+                throw new Error(`/${command.name} is not available in this session.`);
+            }
+            if (this.status !== "busy")
+                this.setStatus("busy");
+            const result = await session.runCommand(command.name, command.args);
+            if (generation !== this.generation)
+                return { ok: true }; // stale
+            if (result.kind === "show") {
+                this.messages.push({ role: "help", text: result.text });
+                // Claim the next turn before emitting, so no idle frame is shown.
+                this.status = "idle";
+                this.drain();
+                this.emit();
+                return { ok: true };
+            }
+            this.lastPrompt = result.prompt;
+            return this.runTurn(result.prompt, generation);
+        }
+        catch (err) {
+            if (generation !== this.generation)
+                return { ok: true }; // stale
+            return this.fail(err);
+        }
+    }
+    /** Leaves a ready status synchronously, before the first await, so a
+     * send arriving in the same tick queues instead of starting a second
+     * turn on the session. */
+    claimTurn() {
+        this.setStatus(this.session === undefined ? "opening" : "busy");
+    }
+    /** The open session, opening one when there is none. Undefined when a
+     * reopen ran meanwhile (the caller's generation is stale). */
+    async ensureSession(generation) {
+        if (this.session !== undefined)
+            return this.session;
+        const session = await this.trackOpen(this.opts.openSession());
+        // A reopen ran while we were opening: this browser is an orphan.
+        // dropSession may have closed it already; close/kill are idempotent.
+        if (generation !== this.generation) {
+            await closeOrKill(session, this.closeTimeoutMs);
+            return undefined;
+        }
+        this.session = session;
+        return session;
     }
     /** Starts the oldest queued entry, if any, when the controller is ready
      * for a turn. Called at every transition back to a ready state, before
@@ -146,6 +284,9 @@ export class SessionController {
         const next = this.queue.shift();
         if (next === undefined)
             return;
+        // A URL_HOOK failure here pushes its error entry and drops the entry:
+        // the queue is not a composer, so there is nowhere to hand the text
+        // back to — the user reads the error and re-types.
         void this.startTurn(next);
     }
     /** Empties the queue back into the composer: the entries are returned
@@ -200,28 +341,21 @@ export class SessionController {
         if (this.status === "dead")
             this.status = "closed";
         this.emit();
-        return this.runTurn(this.lastPrompt);
+        return this.runTurn(this.lastPrompt, this.generation);
     }
-    async runTurn(prompt) {
+    async runTurn(prompt, generation) {
         // A new turn supersedes whatever killed the previous one: a stale
         // `lastError` would keep the webview's error banner up after a
         // successful send from `dead`.
         this.lastError = undefined;
-        const generation = this.generation;
+        this.claimTurn();
         try {
-            if (this.session === undefined) {
-                this.setStatus("opening");
-                const session = await this.trackOpen(this.opts.openSession());
-                // A reopen ran while we were opening: this browser is an orphan.
-                // dropSession may have closed it already; close/kill are idempotent.
-                if (generation !== this.generation) {
-                    await closeOrKill(session, this.closeTimeoutMs);
-                    return { ok: true };
-                }
-                this.session = session;
-            }
-            this.setStatus("busy");
-            const reply = await this.session.send(prompt);
+            const session = await this.ensureSession(generation);
+            if (session === undefined)
+                return { ok: true }; // stale
+            if (this.status !== "busy")
+                this.setStatus("busy");
+            const reply = await session.send(prompt);
             if (generation !== this.generation)
                 return { ok: true }; // stale
             this.messages.push({ role: "assistant", text: reply });

package/dist/webview/main.js

@@ -9,12 +9,20 @@
     { name: "help", description: "List these commands" }
   ];
   var NAMES = new Set(SLASH_COMMANDS.map((c) => c.name));
-  var PATTERN = /^\/([a-z]+)$/;
-  function parseSlashCommand(text) {
-    const word = PATTERN.exec(text.trim())?.[1];
-    if (word === void 0)
+  var EMPTY = /* @__PURE__ */ new Set();
+  var PATTERN = /^\/([a-z]+)(?:\s+([\s\S]*))?$/;
+  function parseSlashCommand(text, custom = EMPTY) {
+    const m = PATTERN.exec(text.trim());
+    if (m === null)
       return void 0;
-    return NAMES.has(word) ? { command: word } : { unknown: word };
+    const word = m[1];
+    const args = (m[2] ?? "").trim();
+    if (NAMES.has(word)) {
+      return args === "" ? { command: word } : { error: `/${word} takes no arguments.` };
+    }
+    if (custom.has(word))
+      return { custom: word, args };
+    return { unknown: word };
   }
   function unknownCommandMessage(word) {
     return `Unknown command: /${word}. Type /help.`;
@@ -41,10 +49,12 @@
     if (atBottom) history.scrollTop = history.scrollHeight;
   }
   var config = {};
+  var commandNames = /* @__PURE__ */ new Set();
   var lastState;
   var lastProgress;
   function applyConfig(c) {
     config = c;
+    commandNames = new Set((c.commands ?? []).map((x) => x.name));
     if (c.sendButton?.background) {
       sendButton.style.setProperty("--cb-send-bg", c.sendButton.background);
     }
@@ -212,15 +222,28 @@
   function submit() {
     const text = input.value;
     if (text.trim() === "" && attachments.childElementCount === 0) return;
-    const slash = parseSlashCommand(text);
+    const slash = parseSlashCommand(text, commandNames);
     if (slash && "unknown" in slash) {
       showInlineError(unknownCommandMessage(slash.unknown));
       return;
     }
+    if (slash && "error" in slash) {
+      showInlineError(slash.error);
+      return;
+    }
     showInlineError(void 0);
     if (slash) {
       input.value = "";
       fitComposer();
+      if ("custom" in slash) {
+        vscode.postMessage({
+          type: "customCommand",
+          name: slash.custom,
+          args: slash.args,
+          text: text.trim()
+        });
+        return;
+      }
       const name = slash.command === "new" ? "newChat" : slash.command;
       vscode.postMessage({ type: "command", name });
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatbridge/vscode",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "VSCode extension factory for chatbridge: a sidebar chat view on top of ChatSession",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,7 @@
     "build:webview": "bun run check:webview && esbuild src/webview/main.ts --bundle --format=iife --target=es2022 --outfile=dist/webview/main.js && mkdir -p dist/webview && cp src/webview/style.css dist/webview/style.css"
   },
   "dependencies": {
-    "@chatbridge/core": "0.8.2"
+    "@chatbridge/core": "0.9.0"
   },
   "devDependencies": {
     "@types/vscode": "1.138.0",