@townco/ui 0.1.82 → 0.1.93

package/dist/gui/lib/motion.js

@@ -219,11 +219,11 @@ export function getDuration(shouldReduceMotion, duration = motionDuration.normal
 // Sidebar Animations (AppSidebar)
 // ============================================================================
 export const sidebarTransition = {
-    duration: 0.5,
+    duration: 0.25,
     ease: motionEasing.smooth,
 };
 export const sidebarMobileTransition = {
-    duration: 0.3,
+    duration: 0.15,
     ease: motionEasing.smooth,
 };
 // Desktop: Slide animation (fixed width, no reflow)
@@ -244,9 +244,9 @@ export const sidebarContentVariants = {
     animate: { opacity: 1, x: 0 },
 };
 export const sidebarContentTransition = {
-    duration: 0.5,
+    duration: 0.25,
     ease: motionEasing.smooth,
-    delay: 0.25,
+    delay: 0.1,
 };
 // Backdrop animation for mobile overlay
 export const backdropVariants = {
@@ -275,12 +275,12 @@ export const asideContentVariants = {
     animate: { opacity: 1, x: 0 },
 };
 export const asideContentTransition = {
-    duration: 0.35,
+    duration: 0.25,
     ease: motionEasing.smooth,
     delay: 0.1,
 };
 // Mobile transition (faster, matches sidebar)
 export const asideMobileTransition = {
-    duration: 0.3,
+    duration: 0.15,
     ease: motionEasing.smooth,
 };

package/dist/gui/lib/remark-citations.d.ts

@@ -0,0 +1,28 @@
+import type { Root } from "mdast";
+/**
+ * Citation node type for the MDAST
+ * Uses 'span' as hName since Streamdown only supports standard HTML elements
+ */
+export interface CitationNode {
+    type: "citation";
+    data: {
+        hName: "span";
+        hProperties: {
+            "data-citation-id": string;
+            className: "citation-marker";
+        };
+    };
+    sourceId: string;
+}
+/**
+ * Remark plugin that transforms citation syntax into citation nodes.
+ *
+ * Finds patterns like [[1]], [[2]], [[12]] (double brackets) or
+ * [1], [2], [12] (single brackets) in text and converts them
+ * to custom citation elements that can be rendered with a custom component.
+ *
+ * Single-bracket citations are only matched when NOT followed by:
+ * - `(` - would be a markdown link [text](url)
+ * - `:` - would be a markdown reference definition [1]: url
+ */
+export declare function remarkCitations(): (tree: Root) => void;

package/dist/gui/lib/remark-citations.js

@@ -0,0 +1,70 @@
+import { visit } from "unist-util-visit";
+/**
+ * Remark plugin that transforms citation syntax into citation nodes.
+ *
+ * Finds patterns like [[1]], [[2]], [[12]] (double brackets) or
+ * [1], [2], [12] (single brackets) in text and converts them
+ * to custom citation elements that can be rendered with a custom component.
+ *
+ * Single-bracket citations are only matched when NOT followed by:
+ * - `(` - would be a markdown link [text](url)
+ * - `:` - would be a markdown reference definition [1]: url
+ */
+export function remarkCitations() {
+    return (tree) => {
+        visit(tree, "text", (node, index, parent) => {
+            if (!parent || index === undefined)
+                return;
+            // Match both [[N]] (double brackets) and [N] (single brackets)
+            // Single brackets use negative lookahead to avoid matching markdown links/refs
+            const citationRegex = /\[\[(\d+)\]\]|\[(\d+)\](?![:(])/g;
+            const text = node.value;
+            // Check if there are any citations in this text
+            if (!citationRegex.test(text))
+                return;
+            // Reset regex state
+            citationRegex.lastIndex = 0;
+            // Split text by citations and create mixed content
+            const parts = [];
+            let lastIndex = 0;
+            let match;
+            // biome-ignore lint/suspicious/noAssignInExpressions: Standard regex exec loop pattern
+            while ((match = citationRegex.exec(text)) !== null) {
+                // Add text before the citation
+                if (match.index > lastIndex) {
+                    parts.push({
+                        type: "text",
+                        value: text.slice(lastIndex, match.index),
+                    });
+                }
+                // Add the citation node
+                // sourceId is in match[1] for [[N]] format, or match[2] for [N] format
+                const sourceId = match[1] ?? match[2] ?? "";
+                parts.push({
+                    type: "citation",
+                    data: {
+                        hName: "span",
+                        hProperties: {
+                            "data-citation-id": sourceId,
+                            className: "citation-marker",
+                        },
+                    },
+                    sourceId,
+                });
+                lastIndex = match.index + match[0].length;
+            }
+            // Add remaining text after last citation
+            if (lastIndex < text.length) {
+                parts.push({
+                    type: "text",
+                    value: text.slice(lastIndex),
+                });
+            }
+            // Replace the original text node with the new nodes
+            if (parts.length > 0) {
+                // biome-ignore lint/suspicious/noExplicitAny: Parent children array needs dynamic assignment
+                parent.children.splice(index, 1, ...parts);
+            }
+        });
+    };
+}

package/dist/sdk/client/acp-client.d.ts

@@ -54,6 +54,10 @@ export declare class AcpClient {
     listSessions(): Promise<SessionSummary[]>;
     /**
      * Send a message in the current session
+     * @param content - The message text content
+     * @param sessionId - Optional session ID (defaults to current session)
+     * @param attachments - Optional image attachments
+     * @param promptParameters - Optional per-message parameters to influence agent behavior
      */
     sendMessage(content: string, sessionId?: string, attachments?: Array<{
         name: string;
@@ -61,11 +65,33 @@ export declare class AcpClient {
         size: number;
         mimeType: string;
         data: string;
-    }>): Promise<void>;
+    }>, promptParameters?: Record<string, string>): Promise<void>;
     /**
      * Receive messages from the agent (streaming)
      */
     receiveMessages(): AsyncIterableIterator<MessageChunk>;
+    /**
+     * Cancel the current agent turn
+     * Stops streaming, tool execution, and sub-agent processes
+     */
+    cancel(sessionId?: string): Promise<void>;
+    /**
+     * Edit and resend a message from a specific point in the conversation.
+     * This truncates the session history to the specified message index
+     * and sends the new content.
+     *
+     * @param messageIndex - The index of the user message to replace (0-based)
+     * @param content - The new text content
+     * @param sessionId - Optional session ID (defaults to current session)
+     * @param attachments - Optional image attachments
+     */
+    editAndResend(messageIndex: number, content: string, sessionId?: string, attachments?: Array<{
+        name: string;
+        path: string;
+        size: number;
+        mimeType: string;
+        data: string;
+    }>): Promise<void>;
     /**
      * Get a session by ID
      */
@@ -94,6 +120,7 @@ export declare class AcpClient {
      * - mcps: List of MCP servers connected to the agent
      * - subagents: List of subagents available via Task tool
      * - uiConfig: UI configuration for interface appearance
+     * - promptParameters: Configurable parameters users can select per-message
      */
     getAgentInfo(): {
         name?: string;
@@ -118,6 +145,16 @@ export declare class AcpClient {
             name: string;
             description: string;
         }>;
+        promptParameters?: Array<{
+            id: string;
+            label: string;
+            description?: string;
+            options: Array<{
+                id: string;
+                label: string;
+            }>;
+            defaultOptionId?: string;
+        }>;
     };
     /**
      * Create transport based on explicit configuration

package/dist/sdk/client/acp-client.js

@@ -142,8 +142,12 @@ export class AcpClient {
     }
     /**
      * Send a message in the current session
+     * @param content - The message text content
+     * @param sessionId - Optional session ID (defaults to current session)
+     * @param attachments - Optional image attachments
+     * @param promptParameters - Optional per-message parameters to influence agent behavior
      */
-    async sendMessage(content, sessionId, attachments) {
+    async sendMessage(content, sessionId, attachments, promptParameters) {
         const targetSessionId = sessionId || this.currentSessionId;
         if (!targetSessionId) {
             throw new Error("No active session. Start a session first.");
@@ -188,8 +192,8 @@ export class AcpClient {
         // Add to session
         session.messages.push(message);
         this.updateSessionStatus(targetSessionId, "active");
-        // Send through transport
-        await this.transport.send(message);
+        // Send through transport with optional promptParameters
+        await this.transport.send(message, promptParameters ? { promptParameters } : undefined);
     }
     /**
      * Receive messages from the agent (streaming)
@@ -200,6 +204,65 @@ export class AcpClient {
         }
         yield* this.transport.receive();
     }
+    /**
+     * Cancel the current agent turn
+     * Stops streaming, tool execution, and sub-agent processes
+     */
+    async cancel(sessionId) {
+        const targetSessionId = sessionId || this.currentSessionId;
+        if (!targetSessionId) {
+            logger.warn("Cannot cancel: no session ID");
+            return;
+        }
+        logger.info("Cancelling session", { sessionId: targetSessionId });
+        await this.transport.cancel(targetSessionId);
+    }
+    /**
+     * Edit and resend a message from a specific point in the conversation.
+     * This truncates the session history to the specified message index
+     * and sends the new content.
+     *
+     * @param messageIndex - The index of the user message to replace (0-based)
+     * @param content - The new text content
+     * @param sessionId - Optional session ID (defaults to current session)
+     * @param attachments - Optional image attachments
+     */
+    async editAndResend(messageIndex, content, sessionId, attachments) {
+        const targetSessionId = sessionId || this.currentSessionId;
+        if (!targetSessionId) {
+            throw new Error("No active session. Start a session first.");
+        }
+        if (!this.transport.isConnected()) {
+            throw new Error("Transport not connected");
+        }
+        if (!this.transport.editAndResend) {
+            throw new Error("Transport does not support edit and resend");
+        }
+        // Build prompt content blocks (images first, then text)
+        const prompt = [];
+        // Add image attachments
+        if (attachments && attachments.length > 0) {
+            for (const attachment of attachments) {
+                if (attachment.mimeType.startsWith("image/")) {
+                    prompt.push({
+                        type: "image",
+                        data: attachment.data,
+                        mimeType: attachment.mimeType,
+                    });
+                }
+            }
+        }
+        // Add text content
+        prompt.push({
+            type: "text",
+            text: content,
+        });
+        logger.info("Edit and resend", {
+            sessionId: targetSessionId,
+            messageIndex,
+        });
+        await this.transport.editAndResend(targetSessionId, messageIndex, prompt);
+    }
     /**
      * Get a session by ID
      */
@@ -246,6 +309,7 @@ export class AcpClient {
      * - mcps: List of MCP servers connected to the agent
      * - subagents: List of subagents available via Task tool
      * - uiConfig: UI configuration for interface appearance
+     * - promptParameters: Configurable parameters users can select per-message
      */
     getAgentInfo() {
         return this.transport.getAgentInfo?.() || {};

package/dist/sdk/schemas/message.d.ts

@@ -406,6 +406,35 @@ export declare const HookNotificationChunk: z.ZodObject<{
     messageId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type HookNotificationChunk = z.infer<typeof HookNotificationChunk>;
+/**
+ * Citation source schema (for inline citations from tool calls)
+ */
+export declare const CitationSource: z.ZodObject<{
+    id: z.ZodString;
+    url: z.ZodString;
+    title: z.ZodString;
+    snippet: z.ZodOptional<z.ZodString>;
+    favicon: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodString;
+    sourceName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CitationSource = z.infer<typeof CitationSource>;
+/**
+ * Sources chunk - for streaming citation sources from tool calls
+ */
+export declare const SourcesChunk: z.ZodObject<{
+    type: z.ZodLiteral<"sources">;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodString;
+        snippet: z.ZodOptional<z.ZodString>;
+        favicon: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+        sourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SourcesChunk = z.infer<typeof SourcesChunk>;
 /**
  * Message chunk - discriminated union of all chunk types
  */
@@ -520,5 +549,16 @@ export declare const MessageChunk: z.ZodDiscriminatedUnion<[z.ZodObject<{
         toolCallId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">;
     messageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sources">;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodString;
+        snippet: z.ZodOptional<z.ZodString>;
+        favicon: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+        sourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "type">;
 export type MessageChunk = z.infer<typeof MessageChunk>;

package/dist/sdk/schemas/message.js

@@ -209,6 +209,25 @@ export const HookNotificationChunk = z.object({
     notification: HookNotification,
     messageId: z.string().optional(),
 });
+/**
+ * Citation source schema (for inline citations from tool calls)
+ */
+export const CitationSource = z.object({
+    id: z.string(),
+    url: z.string().url(),
+    title: z.string(),
+    snippet: z.string().optional(),
+    favicon: z.string().optional(),
+    toolCallId: z.string(),
+    sourceName: z.string().optional(),
+});
+/**
+ * Sources chunk - for streaming citation sources from tool calls
+ */
+export const SourcesChunk = z.object({
+    type: z.literal("sources"),
+    sources: z.array(CitationSource),
+});
 /**
  * Message chunk - discriminated union of all chunk types
  */
@@ -217,4 +236,5 @@ export const MessageChunk = z.discriminatedUnion("type", [
     ToolCallChunk,
     ToolCallUpdateChunk,
     HookNotificationChunk,
+    SourcesChunk,
 ]);

package/dist/sdk/transports/http.d.ts

@@ -34,7 +34,19 @@ export declare class HttpTransport implements Transport {
      */
     listSessions(): Promise<SessionSummary[]>;
     disconnect(): Promise<void>;
-    send(message: Message): Promise<void>;
+    send(message: Message, options?: {
+        promptParameters?: Record<string, string>;
+    }): Promise<void>;
+    cancel(sessionId: string): Promise<void>;
+    /**
+     * Edit and resend a message from a specific point in the conversation.
+     * This truncates the session history and sends the new prompt.
+     */
+    editAndResend(sessionId: string, messageIndex: number, prompt: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>): Promise<void>;
     receive(): AsyncIterableIterator<MessageChunk>;
     isConnected(): boolean;
     onSessionUpdate(callback: (update: SessionUpdate) => void): () => void;
@@ -66,7 +78,18 @@ export declare class HttpTransport implements Transport {
             name: string;
             description: string;
         }>;
+        promptParameters?: Array<{
+            id: string;
+            label: string;
+            description?: string;
+            options: Array<{
+                id: string;
+                label: string;
+            }>;
+            defaultOptionId?: string;
+        }>;
     };
+    private sendNotification;
     private sendRpcRequest;
     private connectSSE;
     private handleSSEDisconnect;

package/dist/sdk/transports/http.js

@@ -86,6 +86,11 @@ export class HttpTransport {
                     typeof meta.uiConfig === "object"
                     ? meta.uiConfig
                     : undefined;
+                const promptParameters = metaIsObject &&
+                    "promptParameters" in meta &&
+                    Array.isArray(meta.promptParameters)
+                    ? meta.promptParameters
+                    : undefined;
                 this.agentInfo = {
                     name: initResponse.agentInfo.name,
                     // title is the ACP field for human-readable display name
@@ -100,6 +105,7 @@ export class HttpTransport {
                     ...(tools ? { tools } : {}),
                     ...(mcps ? { mcps } : {}),
                     ...(subagents ? { subagents } : {}),
+                    ...(promptParameters ? { promptParameters } : {}),
                 };
             }
             logger.info("ACP connection initialized", { initResponse });
@@ -181,6 +187,11 @@ export class HttpTransport {
                     typeof meta.uiConfig === "object"
                     ? meta.uiConfig
                     : undefined;
+                const promptParameters = metaIsObject &&
+                    "promptParameters" in meta &&
+                    Array.isArray(meta.promptParameters)
+                    ? meta.promptParameters
+                    : undefined;
                 this.agentInfo = {
                     name: initResponse.agentInfo.name,
                     // title is the ACP field for human-readable display name
@@ -195,6 +206,7 @@ export class HttpTransport {
                     ...(tools ? { tools } : {}),
                     ...(mcps ? { mcps } : {}),
                     ...(subagents ? { subagents } : {}),
+                    ...(promptParameters ? { promptParameters } : {}),
                 };
             }
             // Check if loadSession is supported
@@ -294,7 +306,7 @@ export class HttpTransport {
             throw err;
         }
     }
-    async send(message) {
+    async send(message, options) {
         if (!this.connected || !this.currentSessionId) {
             throw new Error("Transport not connected");
         }
@@ -346,6 +358,12 @@ export class HttpTransport {
                 sessionId: this.currentSessionId,
                 prompt: promptBlocks,
             };
+            // Add promptParameters to _meta if provided
+            if (options?.promptParameters) {
+                promptRequest._meta = {
+                    promptParameters: options.promptParameters,
+                };
+            }
             // Send the prompt - this will trigger streaming responses via SSE
             const promptResponse = await this.sendRpcRequest("session/prompt", promptRequest);
             logger.debug("Prompt sent", { promptResponse });
@@ -379,6 +397,116 @@ export class HttpTransport {
             throw err;
         }
     }
+    async cancel(sessionId) {
+        if (!this.connected) {
+            logger.warn("Cannot cancel: transport not connected");
+            return;
+        }
+        const targetSessionId = sessionId || this.currentSessionId;
+        if (!targetSessionId) {
+            logger.warn("Cannot cancel: no session ID");
+            return;
+        }
+        logger.info("Cancelling session", { sessionId: targetSessionId });
+        // Mark stream as complete FIRST to stop processing new messages
+        this.streamComplete = true;
+        // Clear any queued messages to prevent them from being processed
+        this.messageQueue.length = 0;
+        // Send cancel notification to the agent (notification = no id, no response expected)
+        await this.sendNotification("session/cancel", {
+            sessionId: targetSessionId,
+        });
+        // Resolve any pending chunk resolvers with a completion marker
+        const completionChunk = {
+            type: "content",
+            id: targetSessionId,
+            role: "assistant",
+            contentDelta: { type: "text", text: "" },
+            isComplete: true,
+        };
+        // Drain all pending resolvers
+        while (this.chunkResolvers.length > 0) {
+            const resolver = this.chunkResolvers.shift();
+            if (resolver) {
+                resolver(completionChunk);
+            }
+        }
+    }
+    /**
+     * Edit and resend a message from a specific point in the conversation.
+     * This truncates the session history and sends the new prompt.
+     */
+    async editAndResend(sessionId, messageIndex, prompt) {
+        if (!this.connected) {
+            throw new Error("Transport not connected");
+        }
+        const targetSessionId = sessionId || this.currentSessionId;
+        if (!targetSessionId) {
+            throw new Error("No session ID available");
+        }
+        // Exit replay mode when user sends their first message
+        if (this.isInReplayMode) {
+            logger.info("Exiting replay mode - user edited a message");
+            this.isInReplayMode = false;
+        }
+        // Reset stream state for new message
+        this.streamComplete = false;
+        this.messageQueue = [];
+        logger.info("Edit and resend", {
+            sessionId: targetSessionId,
+            messageIndex,
+        });
+        const headers = {
+            "Content-Type": "application/json",
+            ...this.options.headers,
+        };
+        const timeoutMs = this.options.timeout ?? 10 * 60 * 1000;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${this.options.baseUrl}/sessions/${targetSessionId}/edit-and-resend`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ messageIndex, prompt }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            // Mark stream as complete after edit-and-resend finishes
+            this.streamComplete = true;
+            // Send completion chunk
+            const resolver = this.chunkResolvers.shift();
+            if (resolver) {
+                resolver({
+                    type: "content",
+                    id: targetSessionId,
+                    role: "assistant",
+                    contentDelta: { type: "text", text: "" },
+                    isComplete: true,
+                });
+            }
+            else {
+                this.messageQueue.push({
+                    type: "content",
+                    id: targetSessionId,
+                    role: "assistant",
+                    contentDelta: { type: "text", text: "" },
+                    isComplete: true,
+                });
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            this.streamComplete = true;
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`Request timeout after ${timeoutMs}ms`);
+            }
+            throw error;
+        }
+    }
     async *receive() {
         // Mark that we're actively receiving messages (prevents duplicate session updates)
         this.isReceivingMessages = true;
@@ -448,6 +576,39 @@ export class HttpTransport {
     getAgentInfo() {
         return this.agentInfo || {};
     }
+    /**
+     * Send an ACP notification to the server (no response expected)
+     */
+    async sendNotification(method, params) {
+        // Construct ACP notification message (no id = notification)
+        const notification = {
+            jsonrpc: "2.0",
+            method,
+            params,
+        };
+        logger.debug("Sending notification", { method, params });
+        const headers = {
+            "Content-Type": "application/json",
+            ...this.options.headers,
+        };
+        try {
+            const response = await fetch(`${this.options.baseUrl}/rpc`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(notification),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                logger.error("Notification failed", {
+                    status: response.status,
+                    errorText,
+                });
+            }
+        }
+        catch (error) {
+            logger.error("Error sending notification", { error });
+        }
+    }
     /**
      * Send an ACP RPC request to the server
      */
@@ -661,6 +822,11 @@ export class HttpTransport {
      * Handle a session notification from the agent
      */
     handleSessionNotification(params) {
+        // Skip processing if stream has been cancelled/completed
+        if (this.streamComplete) {
+            logger.debug("Skipping session notification - stream complete/cancelled");
+            return;
+        }
         logger.debug("handleSessionNotification called", { params });
         // Extract content from the update
         const paramsExtended = params;
@@ -1207,6 +1373,28 @@ export class HttpTransport {
                 sessionUpdate,
             });
         }
+        else if (update &&
+            "sessionUpdate" in update &&
+            update.sessionUpdate === "sources") {
+            // Sources notification - citation sources from tool calls
+            const sourcesUpdate = update;
+            logger.debug("Received sources notification", {
+                sourcesCount: sourcesUpdate.sources.length,
+            });
+            // Create a sources chunk for the message queue
+            const sourcesChunk = {
+                type: "sources",
+                sources: sourcesUpdate.sources,
+            };
+            // Queue for ordered processing
+            const resolver = this.chunkResolvers.shift();
+            if (resolver) {
+                resolver(sourcesChunk);
+            }
+            else {
+                this.messageQueue.push(sourcesChunk);
+            }
+        }
         else if (update?.sessionUpdate === "agent_message_chunk") {
             // Check if this is a replay (not live streaming)
             const isReplay = update._meta &&