@rtc-agent/component 0.2.7-rc.3 → 0.2.8-rc.0

package/dist/utils/session-exporter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Session Export to HTML
+ *
+ * Exports current session conversation to a static HTML file for offline
+ * reading, archiving, and sharing. Pure frontend implementation.
+ */
+import type { Session, Message } from '../types/index.js';
+/**
+ * Generate a safe filename from session title and creation date.
+ *
+ * Format: `rtc-{sanitized-title}-{YYYY-MM-DD}.html`
+ * - Replaces illegal filename characters with hyphens
+ * - Replaces spaces with hyphens
+ * - Truncates title to 50 characters
+ */
+export declare function generateFilename(session: Session): string;
+/**
+ * Determine if a message should be expanded (shown inline) or collapsed.
+ *
+ * Expanded: user messages, assistant markdown messages
+ * Collapsed: tool calls, thinking, errors, prompts, summaries
+ */
+export declare function shouldExpand(message: Message): boolean;
+/**
+ * Render message content to sanitized HTML.
+ *
+ * - user_message: extract text, render as Markdown → sanitize
+ * - markdown: render as Markdown → sanitize
+ * - text: escape HTML, render as plain text
+ * - toolcall_input/toolcall_output: parse tool data, render as formatted JSON
+ * - other types: render as JSON or escaped text in <pre><code>
+ *
+ * Markdown rendering uses the same pipeline as rtc-message.ts:
+ * marked.parse() → highlight.js → DOMPurify.sanitize()
+ *
+ * Tool call data may be an object or a JSON string (double-serialized).
+ * Field name is `tool_name` (not `name`). See rtc-toolcall-card.ts:53-91.
+ */
+export declare function renderMessageContent(message: Message): Promise<string>;
+/**
+ * Generate preview text for collapsed messages.
+ *
+ * Provides a short, meaningful label for each content type.
+ * Tool call field name is `tool_name` (see rtc-toolcall-card.ts:53-91).
+ * Uses shared parseContentData() for uniform JSON string/object handling.
+ */
+export declare function getPreviewText(message: Message): string;
+/**
+ * Generate complete HTML document for session export.
+ *
+ * Async because renderMessageContent requires lazy-loaded marked/DOMPurify.
+ */
+export declare function generateSessionHTML(session: Session, messages: Message[]): Promise<string>;
+/**
+ * Trigger browser download of HTML content.
+ */
+export declare function triggerDownload(html: string, filename: string): void;
+/**
+ * Export session to HTML file.
+ *
+ * Main entry point: generates HTML and triggers download.
+ * Async because generateSessionHTML requires lazy-loaded marked/DOMPurify.
+ */
+export declare function exportSession(session: Session, messages: Message[]): Promise<void>;
+//# sourceMappingURL=session-exporter.d.ts.map

package/dist/utils/session-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-exporter.d.ts","sourceRoot":"","sources":["../../src/utils/session-exporter.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CASzD;AA6ED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CA0D5E;AAsCD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CA4BvD;AAkCD;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAoXhG;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAQpE;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxF"}

package/dist/utils/skeleton-tracker.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Skeleton Tracker - Unified skeleton screen lifecycle management
+ *
+ * Replaces the previously scattered state management:
+ * - _placeholderItemIds: Set<string>
+ * - _placeholderPositions: Array<{itemId: string; y: number}>
+ * - _placeholderIndexMap: Map<string, number>
+ * - _pendingRestorationIds: Set<string>
+ *
+ * Unified management of skeleton screen creation, tracking, and restoration, providing a clear API.
+ */
+/**
+ * Skeleton screen info
+ */
+export interface SkeletonInfo {
+    /** Element ID */
+    itemId: string;
+    /** Index in _items */
+    index: number;
+    /** Absolute Y coordinate (relative to scroll content) */
+    y: number;
+    /** DOM element reference */
+    element: HTMLElement;
+    /** Whether it is in the pending restoration queue */
+    isPendingRestoration: boolean;
+}
+/**
+ * Skeleton screen tracker
+ *
+ * Responsibilities:
+ * 1. Track state of all skeleton screens (position, DOM reference, restoration state)
+ * 2. Provide efficient query API (by range, by ID)
+ * 3. Support batch operations (rebuild positions, clear)
+ *
+ * Usage:
+ * ```typescript
+ * const tracker = new SkeletonTracker();
+ *
+ * // Add skeleton
+ * tracker.add(itemId, index, y, element);
+ *
+ * // Query skeletons in range
+ * const skeletons = tracker.getSkeletonsInRange(top, bottom);
+ *
+ * // Rebuild all positions (after layout changes)
+ * tracker.rebuildPositions(scrollContainer, elementMap);
+ *
+ * // Remove restored skeleton
+ * tracker.remove(itemId);
+ * ```
+ */
+export declare class SkeletonTracker {
+    /** Skeleton info map: itemId -> SkeletonInfo */
+    private _skeletons;
+    /**
+     * Add a skeleton
+     *
+     * @param itemId Element ID
+     * @param index Index in _items
+     * @param y Absolute Y coordinate
+     * @param element DOM element reference
+     */
+    add(itemId: string, index: number, y: number, element: HTMLElement): void;
+    /**
+     * Remove a skeleton
+     *
+     * @param itemId Element ID
+     */
+    remove(itemId: string): void;
+    /**
+     * Get skeleton info
+     *
+     * @param itemId Element ID
+     * @returns Skeleton info, or undefined if not found
+     */
+    get(itemId: string): SkeletonInfo | undefined;
+    /**
+     * Check if an item is a skeleton
+     *
+     * @param itemId Element ID
+     * @returns Whether it is a skeleton
+     */
+    has(itemId: string): boolean;
+    /**
+     * Get skeletons within a Y range
+     *
+     * Checks if any part of the skeleton (top, bottom, or fully contained) is within range.
+     *
+     * @param yMin Range upper bound
+     * @param yMax Range lower bound
+     * @returns Array of skeletons within range
+     */
+    getInRange(yMin: number, yMax: number): SkeletonInfo[];
+    /**
+     * Mark a skeleton as pending restoration
+     *
+     * @param itemId Element ID
+     */
+    markPending(itemId: string): void;
+    /**
+     * Clear pending restoration flag
+     *
+     * @param itemId Element ID
+     */
+    clearPending(itemId: string): void;
+    /**
+     * Rebuild Y positions for all skeletons
+     *
+     * Called after layout changes (container resize, element insertion, etc.)
+     * to recalculate absolute Y coordinates for all skeletons based on current DOM state.
+     *
+     * @param scrollContainer Scroll container
+     * @param elementMap Index -> DOM element map
+     */
+    rebuildPositions(scrollContainer: HTMLElement, elementMap: Map<number, HTMLElement>): void;
+    /**
+     * Update skeleton indices
+     *
+     * Called after the _items array changes (prepend, splice, etc.)
+     * to update all skeleton indices to match the new _items array.
+     *
+     * @param indexMap Old index -> new index map
+     */
+    updateIndices(indexMap: Map<number, number>): void;
+    /**
+     * Clear all skeletons
+     */
+    clear(): void;
+    /**
+     * Get all skeletons
+     *
+     * @returns Array of all skeletons
+     */
+    getAll(): SkeletonInfo[];
+    /**
+     * Get skeleton count
+     */
+    get size(): number;
+    /**
+     * Get count of skeletons pending restoration
+     */
+    get pendingCount(): number;
+}
+//# sourceMappingURL=skeleton-tracker.d.ts.map

package/dist/utils/skeleton-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton-tracker.d.ts","sourceRoot":"","sources":["../../src/utils/skeleton-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,iBAAiB;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;IACV,4BAA4B;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,qDAAqD;IACrD,oBAAoB,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,eAAe;IACxB,gDAAgD;IAChD,OAAO,CAAC,UAAU,CAAwC;IAE1D;;;;;;;OAOG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAgBzE;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO5B;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI7C;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B;;;;;;;;OAQG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE;IAiCtD;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOjC;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOlC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI;IAiB1F;;;;;;;OAOG;IACH,aAAa,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IASlD;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;;;OAIG;IACH,MAAM,IAAI,YAAY,EAAE;IAIxB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAQzB;CACJ"}

package/dist/utils/visibility-manager.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Visibility Manager - Visibility state machine
+ *
+ * Manages virtual scroll visibility state, ensuring operations are paused when not visible,
+ * and state is synchronously rebuilt when visibility is restored.
+ *
+ * Problems addressed:
+ * - Virtual scroll continues operating during tab switches (visibility: hidden)
+ * - Inconsistent state when browser window loses focus (document.hidden)
+ * - Skeletons fail to restore when transitioning from hidden back to visible
+ */
+/**
+ * Visibility state
+ */
+export declare enum VisibilityState {
+    /** Visible and active */
+    VISIBLE = "visible",
+    /** Not visible (tab switch or window out of focus) */
+    HIDDEN = "hidden",
+    /** Transitioning (transition period from hidden to visible) */
+    TRANSITIONING = "transitioning"
+}
+/**
+ * Visibility state change listener
+ */
+export type VisibilityChangeListener = (state: VisibilityState) => void;
+/**
+ * Visibility manager
+ *
+ * Responsibilities:
+ * 1. Maintain the visibility state machine (VISIBLE <-> HIDDEN <-> TRANSITIONING)
+ * 2. Notify listeners of state changes
+ * 3. Provide operation permission check (shouldPerformOperations)
+ *
+ * Usage:
+ * ```typescript
+ * const manager = new VisibilityManager();
+ *
+ * // Listen for state changes
+ * manager.onStateChange(state => {
+ *     console.log('Visibility changed:', state);
+ * });
+ *
+ * // Update visibility (called externally)
+ * manager.update(true);  // Become visible
+ * manager.update(false); // Become hidden
+ *
+ * // Check whether operations should be performed
+ * if (manager.shouldPerformOperations()) {
+ *     // Execute virtual scroll operations
+ * }
+ * ```
+ */
+export declare class VisibilityManager {
+    private _state;
+    private _listeners;
+    /**
+     * Get current state
+     */
+    get state(): VisibilityState;
+    /**
+     * Update visibility state
+     *
+     * State transition rules:
+     * - VISIBLE -> HIDDEN: direct transition
+     * - HIDDEN -> VISIBLE: via TRANSITIONING intermediate state
+     * - TRANSITIONING -> VISIBLE: auto-transition (after one frame)
+     *
+     * @param isVisible Whether it is visible
+     */
+    update(isVisible: boolean): void;
+    /**
+     * Transition to the specified state and notify listeners
+     */
+    private _transitionTo;
+    /**
+     * Register a state change listener
+     *
+     * @param listener Listener function
+     * @returns Unregister function
+     */
+    onStateChange(listener: VisibilityChangeListener): () => void;
+    /**
+     * Check whether virtual scroll operations should be performed
+     *
+     * Only VISIBLE state allows operations (skeletonize, restore, etc.).
+     * HIDDEN and TRANSITIONING states should pause all operations.
+     *
+     * @returns Whether operations should be performed
+     */
+    shouldPerformOperations(): boolean;
+    /**
+     * Check whether currently visible
+     *
+     * @returns Whether visible (VISIBLE or TRANSITIONING)
+     */
+    isVisible(): boolean;
+    /**
+     * Clear all listeners (for dispose)
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=visibility-manager.d.ts.map

package/dist/utils/visibility-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility-manager.d.ts","sourceRoot":"","sources":["../../src/utils/visibility-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;GAEG;AACH,oBAAY,eAAe;IACvB,yBAAyB;IACzB,OAAO,YAAY;IACnB,sDAAsD;IACtD,MAAM,WAAW;IACjB,+DAA+D;IAC/D,aAAa,kBAAkB;CAClC;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,UAAU,CAA4C;IAE9D;;OAEG;IACH,IAAI,KAAK,IAAI,eAAe,CAE3B;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAyBhC;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;;;;OAKG;IACH,aAAa,CAAC,QAAQ,EAAE,wBAAwB,GAAG,MAAM,IAAI;IAQ7D;;;;;;;OAOG;IACH,uBAAuB,IAAI,OAAO;IAIlC;;;;OAIG;IACH,SAAS,IAAI,OAAO;IAKpB;;OAEG;IACH,OAAO,IAAI,IAAI;CAIlB"}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function generateUUID(): string;
+export declare function escapeHtml(text: string): string;
+export declare function formatDate(dateStr: string): string;
+export declare function showToast(message: string, type?: 'info' | 'success' | 'error'): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AASA,wBAAgB,YAAY,IAAI,MAAM,CAWrC;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,GAAG,SAAS,GAAG,OAAgB,GAAG,IAAI,CAY5F"}

package/dist/validation/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Runtime parameter validation module
+ *
+ * Provides a unified parameter validation entry point, supporting Zod schema and OpenAPI Schema
+ * Validation failures return friendly errors, guiding Agent to read /functions/INDEX.md
+ */
+import { z, type ZodType } from 'zod';
+import type { ParameterDef } from '../types/skill.js';
+/** Validation error info */
+export interface ValidationError {
+    field: string;
+    message: string;
+    code?: string;
+}
+/** Validation result */
+export interface ValidationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationError[];
+}
+/**
+ * Validate parameters with Zod schema
+ *
+ * @param schema Zod schema
+ * @param params Parameters to validate
+ */
+export declare function validateParams<T extends ZodType>(schema: T, params: Record<string, unknown>): ValidationResult<z.infer<T>>;
+/**
+ * Format validation error into Agent-friendly message
+ */
+export declare function formatValidationError(groupName: string, functionName: string, errors: ValidationError[]): string;
+/**
+ * Build validator
+ *
+ * Prefers zodSchema, otherwise generates from parameters
+ *
+ * @param zodSchema Optional Zod schema
+ * @param parameters Parameter definitions in OpenAPI format
+ * @returns Zod schema for validation
+ */
+export declare function buildValidator(zodSchema: ZodType | undefined, parameters: ParameterDef[] | undefined): ZodType | null;
+/**
+ * Handler wrapper with validation
+ *
+ * Used for wrapping FunctionDef.handler, automatically validates parameters
+ */
+export declare function withValidation<TParams extends ZodType, TResult>(groupName: string, functionName: string, schema: TParams, handler: (params: z.infer<TParams>) => Promise<TResult> | TResult): (params: Record<string, unknown>) => Promise<TResult | {
+    error: string;
+}>;
+export { z } from 'zod';
+export { zodToParams, zodToOpenAPISchema, withMeta } from './zod-to-openapi.js';
+export { openApiToZod } from './openapi-to-zod.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKtD,4BAA4B;AAC5B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAwB;AACxB,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAID;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAC9C,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAc9B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,eAAe,EAAE,GACxB,MAAM,CAMR;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,OAAO,GAAG,SAAS,EAC9B,UAAU,EAAE,YAAY,EAAE,GAAG,SAAS,GACrC,OAAO,GAAG,IAAI,CAWhB;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,OAAO,EAAE,OAAO,EAC7D,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,GAChE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAsB3E;AAID,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/validation/openapi-to-zod.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenAPI Schema to Zod Schema conversion
+ *
+ * Converts OpenAPI Schema to Zod schema for backward compatibility with existing OpenAPI Schema registration
+ */
+import { type ZodType } from 'zod';
+import type { ParameterDef } from '../types/skill.js';
+/**
+ * Generate ZodObject schema from OpenAPI parameters
+ *
+ * @param parameters Array of parameter definitions in OpenAPI format
+ * @returns ZodObject schema, can be used for runtime validation
+ */
+export declare function openApiToZod(parameters: ParameterDef[]): ZodType;
+//# sourceMappingURL=openapi-to-zod.d.ts.map

package/dist/validation/openapi-to-zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-to-zod.d.ts","sourceRoot":"","sources":["../../src/validation/openapi-to-zod.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAK,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAErE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,OAAO,CAoBhE"}

package/dist/validation/zod-to-openapi.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Zod Schema to OpenAPI Schema conversion
+ *
+ * Converts Zod schema to OpenAPI Schema format, used for generating Agent documentation
+ *
+ * Migrated from peep/src/lib/rtc-agent-validation.ts
+ *
+ * Supported Zod features:
+ * - .describe() → description (parameter description)
+ * - .optional() → required: false
+ * - .default() → default + required: false
+ * - .min()/.max() → minimum/maximum
+ * - .minLength()/.maxLength() → minLength/maxLength
+ * - .regex() → pattern
+ * - .enum() → enum
+ * - z.array() → array + items
+ *
+ * Extended features (via meta method):
+ * - .meta({ example: ... }) → example (example value)
+ */
+import type { ZodType } from 'zod';
+import type { OpenAPISchema, ParameterDef } from '../types/skill.js';
+/**
+ * Zod metadata extension interface
+ *
+ * Used to store example values and other OpenAPI-specific information
+ */
+interface ZodMeta {
+    example?: unknown;
+    examples?: unknown[];
+    format?: string;
+}
+/**
+ * Generate OpenAPI parameters from Zod schema
+ *
+ * @param shape ZodObject schema
+ * @param descriptions Optional parameter description overrides
+ */
+export declare function zodToParams<T extends ZodType>(shape: T, descriptions?: Record<string, string>): ParameterDef[];
+/**
+ * Convert Zod schema to OpenAPI Schema
+ *
+ * Supports all Zod types including nested objects and arrays.
+ * Compatible with Zod v3 and v4.
+ *
+ * @param schema Zod schema
+ * @returns OpenAPI Schema
+ */
+export declare function zodToOpenAPISchema(schema: ZodType): OpenAPISchema;
+/**
+ * Add metadata to Zod schema (example values, etc.)
+ *
+ * Usage:
+ * ```ts
+ * import { z } from 'zod';
+ * import { withMeta } from '@rtc-agent/component';
+ *
+ * const schema = z.object({
+ *   name: withMeta(z.string(), { example: 'John Doe' }),
+ *   age: withMeta(z.number().int(), { example: 30 }),
+ * });
+ * ```
+ */
+export declare function withMeta<T extends ZodType>(schema: T, meta: ZodMeta): T;
+export {};
+//# sourceMappingURL=zod-to-openapi.d.ts.map

package/dist/validation/zod-to-openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-to-openapi.d.ts","sourceRoot":"","sources":["../../src/validation/zod-to-openapi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAErE;;;;GAIG;AACH,UAAU,OAAO;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,OAAO,EAC3C,KAAK,EAAE,CAAC,EACR,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,YAAY,EAAE,CAkDhB;AA8ED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,aAAa,CAEjE;AAsND;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAMvE"}

package/dist/worker-bridge.d.ts

@@ -0,0 +1,152 @@
+/**
+ * WorkerBridge — Comlink bridge between the main thread and a SharedWorker.
+ *
+ * Responsibilities:
+ * 1. Create a SharedWorker instance.
+ * 2. Use Comlink.wrap() to obtain a WorkerPersistenceCore proxy.
+ * 3. Register callback: Worker's UIUpdateEvent -> main-thread UIUpdateBus.publish().
+ * 4. Register callback: Worker's token request -> AuthController.getAccessToken() (with dedup).
+ * 5. Register callback: Worker's connection state change -> main-thread listeners.
+ *
+ * Design notes:
+ * - The main thread retains the UIUpdateBus singleton (existing UI code continues to subscribe).
+ * - When the Worker broadcasts events, WorkerBridge re-publishes them on the main-thread UIUpdateBus.
+ * - Only one SharedWorker instance per page (multi-tab sharing managed by the browser).
+ * - Token request dedup: concurrent requests share the same Promise.
+ */
+import { type Remote } from 'comlink';
+import type { PersistenceConfig } from '@rtc-agent/persistence';
+import type { ConnectionState, ConnectionStateEvent } from '@rtc-agent/client';
+import type { WorkerPersistenceCore } from '@rtc-agent/worker';
+import type { AuthController } from './controllers/auth.controller.js';
+export interface WorkerBridgeConfig {
+    /**
+     * Custom SharedWorker URL.
+     *
+     * When not provided, uses Vite's factory function to determine the worker URL.
+     * This is useful when the component is loaded from NPM and the worker file
+     * needs to be served from a different location (e.g., /rtc-agent/shared-worker.js).
+     *
+     * @example
+     * ```ts
+     * new WorkerBridge(authController, {
+     *   workerUrl: '/rtc-agent/shared-worker.js'
+     * });
+     * ```
+     */
+    workerUrl?: string;
+}
+export declare class WorkerBridge {
+    private readonly _auth;
+    private _worker;
+    private _core;
+    private _callbacks;
+    /** Comlink-proxied callbacks (for cross-Worker transfer). */
+    private _proxiedCallbacks;
+    private _initialized;
+    private _config;
+    /** Connection state listeners (main-thread side). */
+    private _connectionListeners;
+    private static readonly MAX_INIT_RETRIES;
+    private static readonly INIT_RETRY_DELAY_MS;
+    /** Timeout for worker liveness verification (ping/pong). */
+    private static readonly VERIFICATION_TIMEOUT_MS;
+    /**
+     * Generate a worker name for SharedWorker construction.
+     *
+     * In dev mode, appends a timestamp suffix to avoid connecting to stale workers
+     * from previous sessions (e.g., after force-killing a tab during debugging).
+     * SharedWorkers persist across tab closures, so a stale worker in a bad state
+     * can cause verification timeouts on subsequent page loads.
+     *
+     * In production mode, uses a fixed name for predictable multi-tab sharing.
+     */
+    private static _getWorkerName;
+    constructor(_auth: AuthController, config?: WorkerBridgeConfig);
+    /**
+     * Asynchronously create a SharedWorker instance.
+     *
+     * Flow:
+     * 1. Extract the worker chunk's relative path from the Vite factory function.
+     * 2. Resolve the absolute CDN URL and fetch the compiled worker script (requires CORS).
+     * 3. Create a same-origin blob: URL via Blob + createObjectURL.
+     * 4. Construct SharedWorker with the blob: URL -> inherits page origin.
+     * 5. Verify the Worker started successfully (via ping test).
+     *
+     * Must be called before init().
+     * Supports retry: on failure, automatically retries up to MAX_INIT_RETRIES times.
+     */
+    initWorker(): Promise<void>;
+    /**
+     * Single Worker initialization attempt.
+     */
+    private _initWorkerOnce;
+    /**
+     * Verify the Worker actually started and can respond.
+     *
+     * Calls a lightweight method (ping) to verify the Worker is alive.
+     * ping() does not require init() and is suitable for startup verification.
+     * If the Worker failed to start or crashed immediately, this call will time out or throw.
+     */
+    private _verifyWorkerAlive;
+    /**
+     * Clean up a failed Worker instance.
+     */
+    private _cleanupFailedWorker;
+    /**
+     * Delay for the specified number of milliseconds.
+     */
+    private _delay;
+    /**
+     * Get the Comlink-proxied WorkerPersistenceCore.
+     *
+     * All method calls are forwarded to the Worker via postMessage.
+     * The returned object has the same interface as WorkerPersistenceCore.
+     *
+     * Must be accessed after initWorker().
+     */
+    get core(): Remote<WorkerPersistenceCore>;
+    /**
+     * Initialize the bridge.
+     *
+     * 1. Call Worker's core.init() to initialize shared state.
+     * 2. Register this tab's callbacks (onUIUpdate + requestToken + onConnectionStateChange).
+     * 3. Open the port to start communication.
+     *
+     * Idempotent: only the first call takes effect.
+     * Must call initWorker() first.
+     */
+    init(config: PersistenceConfig): Promise<void>;
+    /**
+     * Destroy the bridge.
+     *
+     * 1. Unregister callbacks.
+     * 2. Close the port.
+     * 3. Terminate the Worker (note: SharedWorker only terminates after all ports are closed).
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get the current connection state of RTCAgentClient in the Worker.
+     *
+     * Calls the Worker's getConnectionState() via Comlink.
+     */
+    getConnectionState(): Promise<ConnectionState>;
+    /**
+     * Listen for connection state changes.
+     *
+     * Returns an unsubscribe function.
+     */
+    onConnectionStateChange(listener: (event: ConnectionStateEvent) => void): () => void;
+    /**
+     * Replace the main-thread's virtualFS singleton methods with Comlink proxies.
+     *
+     * The main thread cannot directly access IndexedDB.
+     * After replacement, all operations via virtualFS (tool execution, script reading,
+     * function-registry doc writing, scenario-loader, etc.) are automatically routed
+     * to the Worker.
+     *
+     * Note: virtualFS is a module-level singleton; the replacement is global.
+     */
+    installVirtualFSProxy(): void;
+}
+//# sourceMappingURL=worker-bridge.d.ts.map

package/dist/worker-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-bridge.d.ts","sourceRoot":"","sources":["../src/worker-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAc,KAAK,MAAM,EAAC,MAAM,SAAS,CAAC;AAEjD,OAAO,KAAK,EAAC,iBAAiB,EAA4C,MAAM,wBAAwB,CAAC;AACzG,OAAO,KAAK,EAAC,eAAe,EAAE,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EAAC,qBAAqB,EAAkB,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,kCAAkC,CAAC;AAmErE,MAAM,WAAW,kBAAkB;IAC/B;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,YAAY;IAqCjB,OAAO,CAAC,QAAQ,CAAC,KAAK;IApC1B,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,UAAU,CAAkB;IACpC,6DAA6D;IAC7D,OAAO,CAAC,iBAAiB,CAAkB;IAC3C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAqB;IAEpC,qDAAqD;IACrD,OAAO,CAAC,oBAAoB,CAAoD;IAEhF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAC7C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAQ;IACnD,4DAA4D;IAC5D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAQ;IAEvD;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;gBAUR,KAAK,EAAE,cAAc,EACtC,MAAM,GAAE,kBAAuB;IAuDnC;;;;;;;;;;;;OAYG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA8BjC;;OAEG;YACW,eAAe;IAuG7B;;;;;;OAMG;YACW,kBAAkB;IA0ChC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;OAEG;IACH,OAAO,CAAC,MAAM;IAId;;;;;;;OAOG;IACH,IAAI,IAAI,IAAI,MAAM,CAAC,qBAAqB,CAAC,CAExC;IAED;;;;;;;;;OASG;IACG,IAAI,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBpD;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB9B;;;;OAIG;IACG,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;IAIpD;;;;OAIG;IACH,uBAAuB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,MAAM,IAAI;IASpF;;;;;;;;;OASG;IACH,qBAAqB,IAAI,IAAI;CAyChC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rtc-agent/component",
-  "version": "0.2.7-rc.3",
+  "version": "0.2.8-rc.0",
   "description": "RTC Agent Web Components（基于 Lit）",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,10 +32,10 @@
     "lit": "^3.1.0",
     "marked": "^18.0.11",
     "zod": "^3.23.8",
-    "@rtc-agent/protocol": "0.2.7-rc.3",
-    "@rtc-agent/client": "0.2.7-rc.3",
-    "@rtc-agent/persistence": "0.2.7-rc.3",
-    "@rtc-agent/worker": "0.2.7-rc.3"
+    "@rtc-agent/persistence": "0.2.8-rc.0",
+    "@rtc-agent/protocol": "0.2.8-rc.0",
+    "@rtc-agent/worker": "0.2.8-rc.0",
+    "@rtc-agent/client": "0.2.8-rc.0"
   },
   "devDependencies": {
     "@lit/localize-tools": "^0.8.2",
@@ -50,7 +50,7 @@
     "vitest": "^2.0.0"
   },
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && tsc --emitDeclarationOnly --declaration --declarationMap",
     "prebuild": "lit-localize build",
     "dev": "vite",
     "predev": "lit-localize build",