@pillar-ai/sdk 0.1.18 → 0.1.21

package/dist/actions/index.d.ts

@@ -29,5 +29,5 @@
  *
  * @module actions
  */
-export type { ActionType, ActionDataSchema, ActionDefinition, ActionDefinitions, ActionManifest, ActionManifestEntry, ClientInfo, Platform, SyncActionDefinition, SyncActionDefinitions, ActionTypeDataMap, NavigateActionData, TriggerActionData, InlineUIData, ExternalLinkData, CopyTextData, ActionDataType, ActionNames, TypedTaskHandler, TypedOnTask, TypedPillarMethods, } from './types';
+export type { ActionType, ActionDataSchema, ActionDefinition, ActionDefinitions, ActionManifest, ActionManifestEntry, ClientInfo, Platform, SyncActionDefinition, SyncActionDefinitions, ActionTypeDataMap, NavigateActionData, TriggerActionData, InlineUIData, ExternalLinkData, CopyTextData, ActionDataType, ActionNames, TypedTaskHandler, TypedOnTask, TypedPillarMethods, ActionResult, ActionSchema, } from './types';
 export { setClientInfo, getClientInfo, getHandler, getActionDefinition, hasAction, getActionNames, getManifest, clearRegistry, getActionCount, } from './registry';

package/dist/actions/types.d.ts

@@ -439,3 +439,92 @@ export interface TypedOnTask<TActions extends SyncActionDefinitions | ActionDefi
 export interface TypedPillarMethods<TActions extends SyncActionDefinitions | ActionDefinitions> {
     onTask: TypedOnTask<TActions>;
 }
+/**
+ * Result returned from an action's execute function.
+ *
+ * Follows the MCP tool result format. Plain objects are also accepted
+ * by the SDK and normalized to this shape automatically.
+ */
+export interface ActionResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    }>;
+    isError?: boolean;
+}
+/**
+ * Unified action definition that co-locates metadata and handler.
+ *
+ * Use with `pillar.defineAction()` or the `usePillarAction()` React hook.
+ * The CLI scanner (`npx pillar-sync --scan ./src`) discovers these
+ * definitions automatically — no barrel file needed.
+ *
+ * @template TInput - Type of the input object passed to `execute`
+ *
+ * @example
+ * ```ts
+ * pillar.defineAction({
+ *   name: 'add_to_cart',
+ *   description: 'Add a product to the shopping cart',
+ *   inputSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       productId: { type: 'string', description: 'Product ID' },
+ *       quantity: { type: 'number', description: 'Quantity to add' },
+ *     },
+ *     required: ['productId', 'quantity'],
+ *   },
+ *   execute: async ({ productId, quantity }) => {
+ *     await cartApi.add(productId, quantity);
+ *     return { content: [{ type: 'text', text: 'Added to cart' }] };
+ *   },
+ * });
+ * ```
+ */
+export interface ActionSchema<TInput = Record<string, unknown>> {
+    /** Unique action name (e.g., 'add_to_cart') */
+    name: string;
+    /** Human-readable description for AI matching */
+    description: string;
+    /**
+     * Type of action - determines how the SDK handles it and organizes it in the UI.
+     */
+    type?: ActionType;
+    /**
+     * JSON Schema describing the input parameters.
+     * The AI extracts structured data from the conversation to populate these.
+     */
+    inputSchema?: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    /**
+     * Example user queries that should trigger this action.
+     * Used for semantic matching alongside the description.
+     */
+    examples?: string[];
+    /**
+     * Whether to auto-execute without user confirmation.
+     * @default false
+     */
+    autoRun?: boolean;
+    /**
+     * Whether the action completes immediately after execution.
+     * @default true
+     */
+    autoComplete?: boolean;
+    /**
+     * Handler function executed when the AI invokes this action.
+     *
+     * Can return:
+     * - An `ActionResult` with MCP-style content blocks
+     * - A plain object (SDK normalizes it for the agent)
+     * - `void` if the action has no return value
+     */
+    execute: (input: TInput) => Promise<ActionResult | unknown | void> | ActionResult | unknown | void;
+}

package/dist/cli/sync.js

@@ -4,7 +4,6 @@
 import * as fs from "fs";
 import * as path from "path";
 import { execSync } from "child_process";
-import { pathToFileURL } from "url";
 var DEFAULT_API_URL = "https://help-api.trypillar.com";
 var LOCAL_API_URL = "http://localhost:8003";
 function parseArgs(args) {
@@ -28,12 +27,13 @@ function printUsage() {
   console.log(`
 Pillar Action Sync CLI
 
+Scans for usePillarAction/defineAction calls and syncs to the Pillar backend.
+
 Usage:
-  npx pillar-sync --actions <path> [--local]
+  npx pillar-sync --scan <dir> [--local]
 
 Arguments:
-  --actions <path>   Path to your actions definition file (required)
-                     Supports .ts, .js, .mjs files
+  --scan <dir>       Directory to scan for usePillarAction/defineAction calls
   --local            Use localhost:8003 as the API URL (for local development)
   --help             Show this help message
 
@@ -46,157 +46,13 @@ Environment Variables:
   GIT_SHA            Git commit SHA for traceability
 
 Examples:
-  # Production
-  PILLAR_SLUG=my-app PILLAR_SECRET=xxx npx pillar-sync --actions ./lib/actions.ts
+  # Scan and sync actions
+  PILLAR_SLUG=my-app PILLAR_SECRET=xxx npx pillar-sync --scan ./src
 
   # Local development
-  PILLAR_SLUG=my-app PILLAR_SECRET=xxx npx pillar-sync --actions ./lib/actions.ts --local
+  PILLAR_SLUG=my-app PILLAR_SECRET=xxx npx pillar-sync --scan ./src --local
 `);
 }
-async function loadActions(actionsPath) {
-  const absolutePath = path.resolve(process.cwd(), actionsPath);
-  if (!fs.existsSync(absolutePath)) {
-    throw new Error(`Actions file not found: ${absolutePath}`);
-  }
-  const isTypeScript = absolutePath.endsWith(".ts") || absolutePath.endsWith(".tsx");
-  if (isTypeScript) {
-    try {
-      const tempDir = path.dirname(absolutePath);
-      const tempFile = path.join(tempDir, `.pillar-sync-temp-${Date.now()}.mjs`);
-      const importPath = absolutePath.replace(/\\/g, "/");
-      const extractScript = `import * as module from '${importPath}';
-
-// Resolve actions - tsx may wrap all exports in module.default
-function resolveActions(mod) {
-  // Direct named export
-  if (mod.actions && typeof mod.actions === 'object' && !mod.actions.default) {
-    return mod.actions;
-  }
-  // Default export is the actions object directly
-  if (mod.default && typeof mod.default === 'object') {
-    // Check if default is a module namespace (has nested default or actions)
-    if (mod.default.default && typeof mod.default.default === 'object') {
-      return mod.default.default;
-    }
-    if (mod.default.actions && typeof mod.default.actions === 'object') {
-      return mod.default.actions;
-    }
-    // default is the actions object itself
-    return mod.default;
-  }
-  return null;
-}
-
-const actions = resolveActions(module);
-const agentGuidance = module.agentGuidance || module.default?.agentGuidance;
-console.log(JSON.stringify({ actions, agentGuidance }));`;
-      fs.writeFileSync(tempFile, extractScript, "utf-8");
-      try {
-        const result = execSync(`npx tsx "${tempFile}"`, {
-          encoding: "utf-8",
-          cwd: process.cwd(),
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        const parsed = JSON.parse(result.trim());
-        const actions = parsed.actions;
-        const agentGuidance = parsed.agentGuidance;
-        if (!actions || typeof actions !== "object") {
-          throw new Error(
-            'Actions file must export an actions object as default or named export "actions"'
-          );
-        }
-        return { actions, agentGuidance };
-      } finally {
-        if (fs.existsSync(tempFile)) {
-          fs.unlinkSync(tempFile);
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("tsx")) {
-        console.error("[pillar-sync] TypeScript files require tsx.");
-        console.error("[pillar-sync] Make sure tsx is installed: npm install -D tsx");
-        console.error("[pillar-sync] Then run: npx pillar-sync --actions ./actions.ts");
-      }
-      throw error;
-    }
-  }
-  const fileUrl = pathToFileURL(absolutePath).href;
-  try {
-    let resolveActions2 = function(mod) {
-      if (mod.actions && typeof mod.actions === "object" && !mod.actions.default) {
-        return mod.actions;
-      }
-      if (mod.default && typeof mod.default === "object") {
-        const defaultExport = mod.default;
-        if (defaultExport.default && typeof defaultExport.default === "object") {
-          return defaultExport.default;
-        }
-        if (defaultExport.actions && typeof defaultExport.actions === "object") {
-          return defaultExport.actions;
-        }
-        return defaultExport;
-      }
-      return null;
-    };
-    var resolveActions = resolveActions2;
-    const module = await import(fileUrl);
-    const actions = resolveActions2(module);
-    const agentGuidance = module.agentGuidance || module.default?.agentGuidance;
-    if (!actions || typeof actions !== "object") {
-      throw new Error(
-        'Actions file must export an actions object as default or named export "actions"'
-      );
-    }
-    return { actions, agentGuidance };
-  } catch (error) {
-    throw error;
-  }
-}
-function buildManifest(actions, platform, version, gitSha, agentGuidance) {
-  const entries = [];
-  for (const [name, definition] of Object.entries(actions)) {
-    const entry = {
-      name,
-      description: definition.description,
-      type: definition.type
-    };
-    if (definition.examples?.length)
-      entry.examples = definition.examples;
-    if (definition.path)
-      entry.path = definition.path;
-    if (definition.externalUrl)
-      entry.external_url = definition.externalUrl;
-    if (definition.autoRun)
-      entry.auto_run = definition.autoRun;
-    if (definition.autoComplete)
-      entry.auto_complete = definition.autoComplete;
-    if (definition.returns !== void 0) {
-      entry.returns_data = definition.returns;
-    } else if (definition.type === "query") {
-      entry.returns_data = true;
-    }
-    if (definition.dataSchema)
-      entry.data_schema = definition.dataSchema;
-    if (definition.defaultData)
-      entry.default_data = definition.defaultData;
-    if (definition.requiredContext)
-      entry.required_context = definition.requiredContext;
-    if (definition.parameterExamples?.length)
-      entry.parameter_examples = definition.parameterExamples;
-    entries.push(entry);
-  }
-  const manifest = {
-    platform,
-    version,
-    gitSha,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    actions: entries
-  };
-  if (agentGuidance) {
-    manifest.agentGuidance = agentGuidance;
-  }
-  return manifest;
-}
 async function pollStatus(statusUrl, secret, maxWaitSeconds = 300) {
   const startTime = Date.now();
   let lastProgress = { processed: 0, total: 0 };
@@ -262,15 +118,226 @@ function getGitSha() {
     return void 0;
   }
 }
+function globFiles(dir, extensions) {
+  const results = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".next") {
+      continue;
+    }
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...globFiles(fullPath, extensions));
+    } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function evaluateNode(node, ts) {
+  const n = node;
+  if (ts.isStringLiteral(n)) {
+    return n.text;
+  }
+  if (ts.isNoSubstitutionTemplateLiteral(n)) {
+    return n.text;
+  }
+  if (ts.isNumericLiteral(n)) {
+    return Number(n.text);
+  }
+  if (n.kind === ts.SyntaxKind.TrueKeyword)
+    return true;
+  if (n.kind === ts.SyntaxKind.FalseKeyword)
+    return false;
+  if (n.kind === ts.SyntaxKind.NullKeyword)
+    return null;
+  if (ts.isPrefixUnaryExpression(n)) {
+    const expr = n;
+    if (expr.operator === ts.SyntaxKind.MinusToken) {
+      const operand = evaluateNode(expr.operand, ts);
+      if (typeof operand === "number")
+        return -operand;
+    }
+  }
+  if (ts.isArrayLiteralExpression(n)) {
+    const arr = n;
+    const result = [];
+    for (const elem of arr.elements) {
+      const val = evaluateNode(elem, ts);
+      if (val === void 0)
+        return void 0;
+      result.push(val);
+    }
+    return result;
+  }
+  if (ts.isObjectLiteralExpression(n)) {
+    const obj = n;
+    const result = {};
+    for (const prop of obj.properties) {
+      if (ts.isPropertyAssignment(prop)) {
+        const key = prop.name ? ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : void 0 : void 0;
+        if (!key)
+          continue;
+        const val = evaluateNode(prop.initializer, ts);
+        if (val !== void 0) {
+          result[key] = val;
+        }
+      }
+      if (ts.isShorthandPropertyAssignment(prop)) {
+        continue;
+      }
+    }
+    return result;
+  }
+  if (ts.isAsExpression(n)) {
+    return evaluateNode(n.expression, ts);
+  }
+  if (ts.isParenthesizedExpression(n)) {
+    return evaluateNode(n.expression, ts);
+  }
+  if (ts.isBinaryExpression(n)) {
+    const bin = n;
+    if (bin.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      const left = evaluateNode(bin.left, ts);
+      const right = evaluateNode(bin.right, ts);
+      if (typeof left === "string" && typeof right === "string") {
+        return left + right;
+      }
+    }
+  }
+  return void 0;
+}
+async function scanActions(scanDir) {
+  const absoluteDir = path.resolve(process.cwd(), scanDir);
+  if (!fs.existsSync(absoluteDir)) {
+    throw new Error(`Scan directory not found: ${absoluteDir}`);
+  }
+  let ts;
+  try {
+    ts = await import("typescript");
+  } catch {
+    console.error("[pillar-sync] TypeScript is required for --scan mode.");
+    console.error("[pillar-sync] Install it: npm install -D typescript");
+    process.exit(1);
+  }
+  const files = globFiles(absoluteDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+  console.log(`[pillar-sync] Scanning ${files.length} files in ${scanDir}`);
+  const PATTERNS = ["defineAction", "usePillarAction"];
+  const candidateFiles = files.filter((file) => {
+    const content = fs.readFileSync(file, "utf-8");
+    return PATTERNS.some((p) => content.includes(p));
+  });
+  console.log(`[pillar-sync] Found ${candidateFiles.length} files with action definitions`);
+  const actions = [];
+  for (const filePath of candidateFiles) {
+    let visit2 = function(node) {
+      if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        let isTargetCall = false;
+        if (ts.isIdentifier(callee)) {
+          isTargetCall = PATTERNS.includes(callee.text);
+        } else if (ts.isPropertyAccessExpression(callee)) {
+          isTargetCall = callee.name.text === "defineAction";
+        }
+        if (isTargetCall && node.arguments.length > 0) {
+          const arg = node.arguments[0];
+          const lineNumber = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+          const relativePath = path.relative(process.cwd(), filePath);
+          const processActionObject = (obj, line) => {
+            if (obj && typeof obj.name === "string" && typeof obj.description === "string") {
+              actions.push({
+                name: obj.name,
+                description: obj.description,
+                type: obj.type,
+                inputSchema: obj.inputSchema,
+                examples: obj.examples,
+                autoRun: obj.autoRun,
+                autoComplete: obj.autoComplete,
+                sourceFile: relativePath,
+                line
+              });
+              console.log(`[pillar-sync]   ${obj.name} (${relativePath}:${line})`);
+            } else if (obj) {
+              console.warn(
+                `[pillar-sync] \u26A0 Skipping action at ${relativePath}:${line} \u2014 missing name or description`
+              );
+            }
+          };
+          if (ts.isObjectLiteralExpression(arg)) {
+            const obj = evaluateNode(arg, ts);
+            processActionObject(obj, lineNumber);
+          } else if (ts.isArrayLiteralExpression(arg)) {
+            for (const element of arg.elements) {
+              if (ts.isObjectLiteralExpression(element)) {
+                const elementLine = sourceFile.getLineAndCharacterOfPosition(element.getStart()).line + 1;
+                const obj = evaluateNode(element, ts);
+                processActionObject(obj, elementLine);
+              } else {
+                const elementLine = sourceFile.getLineAndCharacterOfPosition(element.getStart()).line + 1;
+                console.warn(
+                  `[pillar-sync] \u26A0 Skipping action at ${relativePath}:${elementLine} \u2014 array element is not an inline object literal`
+                );
+              }
+            }
+          } else {
+            console.warn(
+              `[pillar-sync] \u26A0 Skipping action at ${relativePath}:${lineNumber} \u2014 argument is not an inline object literal or array (variable reference can't be resolved statically)`
+            );
+          }
+        }
+      }
+      ts.forEachChild(node, visit2);
+    };
+    var visit = visit2;
+    const content = fs.readFileSync(filePath, "utf-8");
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      // setParentNodes
+      filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : filePath.endsWith(".jsx") ? ts.ScriptKind.JSX : /\.m?js$/.test(filePath) ? ts.ScriptKind.JS : ts.ScriptKind.TS
+    );
+    visit2(sourceFile);
+  }
+  return actions;
+}
+function buildManifestFromScan(actions, platform, version, gitSha) {
+  const entries = [];
+  for (const action of actions) {
+    const entry = {
+      name: action.name,
+      description: action.description,
+      type: action.type || "trigger_action"
+    };
+    if (action.examples?.length)
+      entry.examples = action.examples;
+    if (action.autoRun)
+      entry.auto_run = action.autoRun;
+    if (action.autoComplete !== void 0)
+      entry.auto_complete = action.autoComplete;
+    entry.returns_data = true;
+    if (action.inputSchema)
+      entry.data_schema = action.inputSchema;
+    entries.push(entry);
+  }
+  return {
+    platform,
+    version,
+    gitSha,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    actions: entries
+  };
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.help) {
     printUsage();
     process.exit(0);
   }
-  const actionsPath = args.actions;
-  if (!actionsPath) {
-    console.error("[pillar-sync] Missing required --actions argument");
+  const scanDir = args.scan;
+  if (!scanDir) {
+    console.error("[pillar-sync] Missing required argument: --scan <dir>");
     console.error("");
     printUsage();
     process.exit(1);
@@ -292,31 +359,27 @@ async function main() {
     console.error("Get these from the Pillar admin: Actions \u2192 Configure Sync");
     process.exit(1);
   }
-  console.log(`[pillar-sync] Loading actions from: ${actionsPath}`);
-  let loadedModule;
+  const platform = process.env.PILLAR_PLATFORM || "web";
+  const version = process.env.PILLAR_VERSION || getPackageVersion();
+  const gitSha = process.env.GIT_SHA || getGitSha();
+  console.log(`[pillar-sync] Scanning for actions in: ${scanDir}`);
+  let scannedActions;
   try {
-    loadedModule = await loadActions(actionsPath);
+    scannedActions = await scanActions(scanDir);
   } catch (error) {
-    console.error(`[pillar-sync] Failed to load actions:`, error);
+    console.error(`[pillar-sync] Failed to scan actions:`, error);
     process.exit(1);
   }
-  const { actions, agentGuidance } = loadedModule;
-  const actionCount = Object.keys(actions).length;
+  const actionCount = scannedActions.length;
   console.log(`[pillar-sync] Found ${actionCount} actions`);
-  if (agentGuidance) {
-    console.log(`[pillar-sync] Found agent guidance (${agentGuidance.length} chars)`);
-  }
   if (actionCount === 0) {
     console.warn("[pillar-sync] No actions found. Nothing to sync.");
     process.exit(0);
   }
-  const platform = process.env.PILLAR_PLATFORM || "web";
-  const version = process.env.PILLAR_VERSION || getPackageVersion();
-  const gitSha = process.env.GIT_SHA || getGitSha();
+  const manifest = buildManifestFromScan(scannedActions, platform, version, gitSha);
   console.log(`[pillar-sync] Platform: ${platform}`);
   console.log(`[pillar-sync] Version: ${version}`);
   console.log(`[pillar-sync] Git SHA: ${gitSha || "not available"}`);
-  const manifest = buildManifest(actions, platform, version, gitSha, agentGuidance);
   if (process.env.PILLAR_DEBUG) {
     const manifestPath = path.join(process.cwd(), "actions-manifest.json");
     fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
@@ -329,9 +392,6 @@ async function main() {
     git_sha: gitSha,
     actions: manifest.actions
   };
-  if (agentGuidance) {
-    requestBody.agent_guidance = agentGuidance;
-  }
   const syncUrl = `${apiUrl}/api/admin/configs/${slug}/actions/sync/?async=true`;
   console.log(`[pillar-sync] POST ${syncUrl}`);
   try {

package/dist/components/Button/EdgeTrigger.d.ts

@@ -43,11 +43,16 @@ export declare class EdgeTrigger {
      */
     private getEdgePosition;
     /**
-     * Detect the current theme from the document
+     * Detect the current theme from the document (for auto mode)
      * Checks for .dark class (next-themes) or data-theme attribute
      * Returns explicit 'light' or 'dark' to match app theme (not system preference)
      */
-    private detectTheme;
+    private detectThemeFromDOM;
+    /**
+     * Apply theme mode - respects explicit config, only auto-detects when mode is 'auto'
+     * Matches Panel behavior for consistency.
+     */
+    private applyThemeMode;
     /**
      * Initialize the edge trigger
      */

package/dist/components/PagePilot/PagePilotManager.d.ts

@@ -3,30 +3,35 @@
  * Manages the "Page being piloted by Agent" banner, rendering it outside Shadow DOM
  * so it appears above all other content on the page.
  */
+import type { ThemeMode } from '../../core/config';
 export declare class PagePilotManager {
     private container;
     private stylesInjected;
     private unsubscribe;
     private themeObserver;
     private primaryColor;
+    private themeMode;
     /**
-     * Detect the current theme from the document
+     * Detect the current theme from the document (for auto mode)
      * Checks for .dark class (next-themes) or data-theme attribute
      */
     private detectThemeFromDOM;
     /**
      * Apply theme mode to container element
+     * Respects explicit config, only auto-detects when mode is 'auto'
      */
-    private applyTheme;
+    private applyThemeMode;
     /**
      * Set up observer to watch for theme changes on documentElement
+     * Only needed for auto mode
      */
     private setupThemeObserver;
     /**
      * Initialize the page pilot manager
      * @param primaryColor - Optional primary color from theme config to override the default
+     * @param themeMode - Theme mode from config ('light', 'dark', or 'auto')
      */
-    init(primaryColor?: string): void;
+    init(primaryColor?: string, themeMode?: ThemeMode): void;
     /**
      * Update the primary color used by the banner
      */

package/dist/components/Panel/Panel.d.ts

@@ -15,9 +15,16 @@ export declare class Panel {
     private backdrop;
     private panelElement;
     private renderRoot;
+    private resizeHandle;
     private unsubscribe;
     private isManualMount;
     private themeObserver;
+    private _isResizing;
+    private _resizeStartX;
+    private _resizeStartWidth;
+    private _resizeRafId;
+    private _boundHandleResizeMove;
+    private _boundHandleResizeEnd;
     constructor(config: ResolvedConfig, api: APIClient, events: EventEmitter, rootContainer?: HTMLElement | null);
     /**
      * Detect the current theme from the document
@@ -53,6 +60,20 @@ export declare class Panel {
      * Destroy the panel
      */
     destroy(): void;
+    /** Internal safety clamp -- not user-configurable */
+    private static readonly MIN_PANEL_WIDTH;
+    /**
+     * Handle resize start from mouse or touch event on the drag handle
+     */
+    private handleResizeStart;
+    /**
+     * Handle resize move - throttled via requestAnimationFrame
+     */
+    private handleResizeMove;
+    /**
+     * Handle resize end - save final width and clean up
+     */
+    private handleResizeEnd;
     private subscribeToState;
     /**
      * Toggle backdrop visibility using inline styles.

package/dist/components/Progress/ErrorRow.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ErrorRow Component
+ *
+ * A subtle, red-tinted progress-row-style error indicator with a retry button.
+ * Shown at the bottom of the chat thread when an MCP request fails.
+ */
+import type { ChatError } from '../../store/chat';
+export interface ErrorRowProps {
+    error: ChatError;
+    onRetry: () => void;
+}
+export declare function ErrorRow({ error, onRetry }: ErrorRowProps): import("preact").JSX.Element;

package/dist/components/Progress/index.d.ts

@@ -1,3 +1,4 @@
 export { ProgressRow, type ProgressRowProps } from './ProgressRow';
 export { ProgressGroup, type ProgressGroupProps } from './ProgressGroup';
 export { ProgressStack, type ProgressStackProps } from './ProgressStack';
+export { ErrorRow, type ErrorRowProps } from './ErrorRow';