sdkwork-browser-agent 1.0.0

package/dist/node/provider-Dna36xA-.d.cts

@@ -0,0 +1,105 @@
+/**
+ * LLM Provider Interface
+ * Supports various LLM providers: OpenAI, Anthropic, Google, local models, etc.
+ */
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface LLMRequest {
+    messages: LLMMessage[];
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    stream?: boolean;
+    tools?: ToolDefinition[];
+    tool_choice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface LLMResponse {
+    id: string;
+    model: string;
+    content: string;
+    role: 'assistant';
+    tool_calls?: ToolCall[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+}
+interface LLMStreamChunk {
+    id: string;
+    model: string;
+    delta: {
+        content?: string;
+        role?: 'assistant';
+        tool_calls?: ToolCall[];
+    };
+    finish_reason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+}
+interface LLMProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    defaultParams?: Partial<LLMRequest>;
+    timeout?: number;
+    retries?: number;
+}
+interface LLMProvider {
+    readonly name: string;
+    readonly supportedModels: string[];
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    validateConfig(): boolean;
+}
+type LLMProviderFactory = (config: LLMProviderConfig) => LLMProvider;
+declare class LLMProviderRegistry {
+    private providers;
+    private instances;
+    register(name: string, factory: LLMProviderFactory): void;
+    create(name: string, config: LLMProviderConfig): LLMProvider;
+    get(name: string): LLMProvider | undefined;
+    listProviders(): string[];
+    isRegistered(name: string): boolean;
+}
+declare const globalProviderRegistry: LLMProviderRegistry;
+declare class LLMManager {
+    private registry;
+    private providers;
+    private defaultProvider?;
+    constructor(registry?: LLMProviderRegistry);
+    addProvider(name: string, config: LLMProviderConfig): LLMProvider;
+    setDefaultProvider(name: string): void;
+    getProvider(name?: string): LLMProvider;
+    complete(request: LLMRequest, providerName?: string): Promise<LLMResponse>;
+    stream(request: LLMRequest, providerName?: string): AsyncIterableIterator<LLMStreamChunk>;
+    listProviders(): string[];
+}
+
+export { type LLMProvider as L, type ToolDefinition as T, type LLMMessage as a, type LLMRequest as b, type LLMResponse as c, type LLMStreamChunk as d, LLMManager as e, type LLMProviderConfig as f, type LLMProviderFactory as g, LLMProviderRegistry as h, type ToolCall as i, globalProviderRegistry as j };

package/dist/node/provider-Dna36xA-.d.ts

@@ -0,0 +1,105 @@
+/**
+ * LLM Provider Interface
+ * Supports various LLM providers: OpenAI, Anthropic, Google, local models, etc.
+ */
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface LLMRequest {
+    messages: LLMMessage[];
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    stream?: boolean;
+    tools?: ToolDefinition[];
+    tool_choice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface LLMResponse {
+    id: string;
+    model: string;
+    content: string;
+    role: 'assistant';
+    tool_calls?: ToolCall[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+}
+interface LLMStreamChunk {
+    id: string;
+    model: string;
+    delta: {
+        content?: string;
+        role?: 'assistant';
+        tool_calls?: ToolCall[];
+    };
+    finish_reason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+}
+interface LLMProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    defaultParams?: Partial<LLMRequest>;
+    timeout?: number;
+    retries?: number;
+}
+interface LLMProvider {
+    readonly name: string;
+    readonly supportedModels: string[];
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    validateConfig(): boolean;
+}
+type LLMProviderFactory = (config: LLMProviderConfig) => LLMProvider;
+declare class LLMProviderRegistry {
+    private providers;
+    private instances;
+    register(name: string, factory: LLMProviderFactory): void;
+    create(name: string, config: LLMProviderConfig): LLMProvider;
+    get(name: string): LLMProvider | undefined;
+    listProviders(): string[];
+    isRegistered(name: string): boolean;
+}
+declare const globalProviderRegistry: LLMProviderRegistry;
+declare class LLMManager {
+    private registry;
+    private providers;
+    private defaultProvider?;
+    constructor(registry?: LLMProviderRegistry);
+    addProvider(name: string, config: LLMProviderConfig): LLMProvider;
+    setDefaultProvider(name: string): void;
+    getProvider(name?: string): LLMProvider;
+    complete(request: LLMRequest, providerName?: string): Promise<LLMResponse>;
+    stream(request: LLMRequest, providerName?: string): AsyncIterableIterator<LLMStreamChunk>;
+    listProviders(): string[];
+}
+
+export { type LLMProvider as L, type ToolDefinition as T, type LLMMessage as a, type LLMRequest as b, type LLMResponse as c, type LLMStreamChunk as d, LLMManager as e, type LLMProviderConfig as f, type LLMProviderFactory as g, LLMProviderRegistry as h, type ToolCall as i, globalProviderRegistry as j };

package/dist/node/skills/index.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkYDHQCPSNcjs = require('../chunk-YDHQCPSN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EnhancedSkillExecutor = _chunkYDHQCPSNcjs.EnhancedSkillExecutor; exports.SkillRegistry = _chunkYDHQCPSNcjs.SkillRegistry; exports.SkillResourceManager = _chunkYDHQCPSNcjs.SkillResourceManager; exports.SkillScriptExecutor = _chunkYDHQCPSNcjs.SkillScriptExecutor; exports.builtInSkills = _chunkYDHQCPSNcjs.builtInSkills; exports.builtInSkillsMap = _chunkYDHQCPSNcjs.builtInSkillsMap; exports.createSkillFromManifest = _chunkYDHQCPSNcjs.createSkillFromManifest; exports.echoSkill = _chunkYDHQCPSNcjs.echoSkill; exports.listSkillsSkill = _chunkYDHQCPSNcjs.listSkillsSkill; exports.loadSkillFromDirectory = _chunkYDHQCPSNcjs.loadSkillFromDirectory; exports.mathSkill = _chunkYDHQCPSNcjs.mathSkill; exports.parseSkillMd = _chunkYDHQCPSNcjs.parseSkillMd; exports.validateManifest = _chunkYDHQCPSNcjs.validateManifest;
+//# sourceMappingURL=index.cjs.map

package/dist/node/skills/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["d:\\sdkwork-opensource\\sdkwork-browser-agent\\dist\\node\\skills\\index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,kzBAAC","file":"D:\\sdkwork-opensource\\sdkwork-browser-agent\\dist\\node\\skills\\index.cjs"}

package/dist/node/skills/index.d.cts

@@ -0,0 +1,401 @@
+import { S as Skill, E as ExecutionContext, a as SkillResult } from '../agent-kexkkI13.cjs';
+import { S as StorageAdapter } from '../types-CG5I-byI.cjs';
+import '../provider-Dna36xA-.cjs';
+
+/**
+ * Enhanced Skill Registry
+ * Advanced caching, indexing, and skill management
+ */
+
+interface RegistryConfig {
+    storage?: StorageAdapter | null;
+    enableCache?: boolean;
+    enableIndexing?: boolean;
+    maxCacheSize?: number;
+    cacheTTL?: number;
+    hotReload?: boolean;
+}
+declare class SkillRegistry {
+    private skills;
+    private index;
+    private config;
+    private storage;
+    private watchers;
+    constructor(config?: RegistryConfig);
+    /**
+     * Register a skill in the registry
+     */
+    register(skill: Skill): void;
+    /**
+     * Unregister a skill
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a skill by name
+     */
+    get(name: string): Skill | undefined;
+    /**
+     * Check if skill exists
+     */
+    has(name: string): boolean;
+    /**
+     * Find skills by category
+     */
+    findByCategory(category: string): Skill[];
+    /**
+     * Find skills by tag
+     */
+    findByTag(tag: string): Skill[];
+    /**
+     * Search skills by keyword
+     */
+    search(keyword: string): Skill[];
+    /**
+     * Get all registered skills
+     */
+    getAll(): Skill[];
+    /**
+     * Get all skill names
+     */
+    getNames(): string[];
+    /**
+     * Get skills by names
+     */
+    getMany(names: string[]): Skill[];
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        totalSkills: number;
+        totalSize: number;
+        averageAccessCount: number;
+        cacheHitRate: number;
+        categories: string[];
+        tags: string[];
+    };
+    /**
+     * Clear all skills
+     */
+    clear(): void;
+    /**
+     * Clear expired cache entries
+     */
+    clearExpired(): number;
+    /**
+     * Optimize cache by removing least recently used entries
+     */
+    optimizeCache(): void;
+    private indexSkill;
+    private removeFromIndex;
+    private clearIndex;
+    private calculateSkillSize;
+    private calculateCacheHitRate;
+    private watchSkill;
+}
+
+/**
+ * Built-in Skills - TypeScript Implementations
+ *
+ * Each skill follows the Agent Skills Specification:
+ * - SKILL.md with YAML frontmatter
+ * - Progressive disclosure pattern
+ * - Standardized parameters and responses
+ */
+
+declare const echoSkill: Skill;
+declare const mathSkill: Skill;
+declare const listSkillsSkill: Skill;
+declare const builtInSkills: Skill[];
+declare const builtInSkillsMap: Map<string, Skill>;
+
+/**
+ * Agent Skills Specification Loader
+ *
+ * Loads skills following the Agent Skills Specification:
+ * - skill-name/
+ *   └── SKILL.md (with YAML frontmatter)
+ *   └── scripts/ (optional)
+ *   └── references/ (optional)
+ *   └── assets/ (optional)
+ */
+
+interface SkillManifest {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+}
+interface ParsedSkill {
+    manifest: SkillManifest;
+    instructions: string;
+    skill: Skill;
+}
+/**
+ * Parse SKILL.md content
+ * Extracts YAML frontmatter and markdown body
+ */
+declare function parseSkillMd(content: string): {
+    manifest: SkillManifest;
+    instructions: string;
+};
+/**
+ * Convert manifest and instructions to Skill object
+ * Note: This creates a placeholder skill. Real implementation
+ * would need to load actual handler from scripts/ directory
+ */
+declare function createSkillFromManifest(manifest: SkillManifest, _instructions: string): Skill;
+/**
+ * Load skill from directory
+ */
+declare function loadSkillFromDirectory(skillPath: string): Promise<ParsedSkill>;
+/**
+ * Validate skill manifest
+ */
+declare function validateManifest(manifest: SkillManifest): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * Skill Resource Manager
+ *
+ * Manages loading and execution of skills following Agent Skills Specification
+ * Implements progressive disclosure: metadata → instructions → resources
+ */
+
+interface ScriptFile {
+    name: string;
+    path: string;
+    language: 'javascript' | 'typescript' | 'python' | 'bash';
+    content: string;
+}
+interface ReferenceFile {
+    name: string;
+    path: string;
+    content: string;
+}
+interface AssetFile {
+    name: string;
+    path: string;
+    type: 'template' | 'image' | 'data' | 'other';
+    content: string;
+}
+type DisclosureLevel = 'metadata' | 'instructions' | 'resources';
+interface LoadedSkill {
+    name: string;
+    path: string;
+    manifest: SkillManifest;
+    instructions?: string;
+    scripts: Map<string, ScriptFile>;
+    references: Map<string, ReferenceFile>;
+    assets: Map<string, AssetFile>;
+    currentLevel: DisclosureLevel;
+    loadedAt: Date;
+}
+interface SkillManagerConfig {
+    basePath?: string;
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+}
+/**
+ * Skill Resource Manager
+ * Manages loading and execution of skills following Agent Skills Specification
+ */
+declare class SkillResourceManager {
+    private config;
+    private cache;
+    private metadataCache;
+    constructor(config?: SkillManagerConfig);
+    /**
+     * Level 1: Load metadata only (~100 tokens)
+     * Loaded at startup for all skills
+     */
+    loadMetadata(skillPath: string): Promise<SkillManifest>;
+    /**
+     * Level 2: Load instructions (< 5000 tokens)
+     * Loaded when skill is activated
+     */
+    loadInstructions(skillPath: string): Promise<string>;
+    /**
+     * Level 3: Load complete skill with resources
+     * Resources loaded as needed
+     */
+    loadFullSkill(skillPath: string): Promise<LoadedSkill>;
+    /**
+     * Progressive loading - load up to specified level
+     */
+    loadProgressive(skillPath: string, level?: DisclosureLevel): Promise<LoadedSkill>;
+    /**
+     * Load a specific resource on demand
+     */
+    loadResource(skillPath: string, type: 'script' | 'reference' | 'asset', name: string): Promise<ScriptFile | ReferenceFile | AssetFile | null>;
+    /**
+     * Get reference content
+     */
+    getReference(skillPath: string, referenceName: string): Promise<string | null>;
+    /**
+     * Get asset content
+     */
+    getAsset(skillPath: string, assetName: string): Promise<string | null>;
+    private loadScripts;
+    private loadReferences;
+    private loadAssets;
+    private loadScript;
+    private loadReference;
+    private loadAsset;
+    private parseSkillMd;
+    private parseYaml;
+    private parseYamlValue;
+    /**
+     * Validate manifest according to Agent Skills Specification
+     */
+    private validateManifest;
+    private detectLanguage;
+    private detectAssetType;
+    private enforceCacheLimit;
+    private readFile;
+    private listDirectory;
+}
+
+/**
+ * Enhanced Skill Script Executor
+ *
+ * Executes scripts from Skill scripts/ directory with comprehensive sandboxing
+ * Supports JavaScript, TypeScript, Python, and Bash with security controls
+ */
+
+interface ScriptExecutionResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    executionTime: number;
+    memoryUsage?: number;
+}
+interface ScriptExecutorConfig {
+    timeout?: number;
+    allowedGlobals?: string[];
+    restrictedGlobals?: string[];
+    maxMemoryMB?: number;
+    allowedTools?: string[];
+    enableLogging?: boolean;
+}
+/**
+ * Enhanced Skill Script Executor with comprehensive sandboxing
+ */
+declare class SkillScriptExecutor {
+    private config;
+    private executionCount;
+    constructor(config?: ScriptExecutorConfig);
+    /**
+     * Execute a script with given operation and parameters
+     */
+    execute(script: ScriptFile, operation: string, params: Record<string, unknown>, context: ExecutionContext): Promise<ScriptExecutionResult>;
+    /**
+     * Check if script is allowed to execute based on allowed-tools configuration
+     */
+    private isScriptAllowed;
+    /**
+     * Execute JavaScript/TypeScript in secure sandbox
+     */
+    private executeJavaScript;
+    /**
+     * Sanitize JavaScript code to remove dangerous patterns
+     */
+    private sanitizeJavaScript;
+    /**
+     * Create sandbox context with allowed globals
+     */
+    private createSandbox;
+    /**
+     * Execute JavaScript in browser using Web Worker
+     */
+    private executeInBrowserWorker;
+    /**
+     * Execute JavaScript in Node.js using VM module
+     */
+    private executeInNodeVM;
+    /**
+     * Execute Python code (requires Python runtime)
+     */
+    private executePython;
+    /**
+     * Execute Bash script (Node.js only)
+     */
+    private executeBash;
+    /**
+     * Get executor statistics
+     */
+    getStats(): {
+        totalExecutions: number;
+        config: ScriptExecutorConfig;
+    };
+}
+
+/**
+ * Enhanced Skill Executor
+ *
+ * Integrates SkillResourceManager and SkillScriptExecutor
+ * Provides complete Skill execution with resource loading
+ */
+
+interface EnhancedSkillExecutorConfig {
+    resourceManager?: SkillResourceManager;
+    scriptExecutor?: SkillScriptExecutor;
+    defaultScriptName?: string;
+}
+/**
+ * Enhanced Skill Executor with full resource support
+ */
+declare class EnhancedSkillExecutor {
+    private resourceManager;
+    private scriptExecutor;
+    private defaultScriptName;
+    constructor(config?: EnhancedSkillExecutorConfig);
+    /**
+     * Execute a skill with full resource loading
+     *
+     * This method:
+     * 1. Loads the skill with all resources (if not cached)
+     * 2. Finds the appropriate script
+     * 3. Executes the script with the operation and parameters
+     * 4. Returns the result
+     */
+    execute(skillPath: string, operation: string, params: Record<string, unknown> | undefined, context: ExecutionContext): Promise<SkillResult>;
+    /**
+     * Execute skill with progressive loading
+     * Loads only metadata first, then instructions if needed, then resources
+     */
+    executeProgressive(skillPath: string, operation: string, params: Record<string, unknown> | undefined, context: ExecutionContext): Promise<SkillResult>;
+    /**
+     * Get skill information without loading resources
+     */
+    getSkillInfo(skillPath: string): Promise<{
+        name: string;
+        description: string;
+        hasScripts: boolean;
+        hasReferences: boolean;
+        hasAssets: boolean;
+    }>;
+    /**
+     * Get reference documentation
+     */
+    getReference(skillPath: string, referenceName: string): Promise<string | null>;
+    /**
+     * Get asset content
+     */
+    getAsset(skillPath: string, assetName: string): Promise<string | null>;
+    /**
+     * List all available skills in a directory
+     */
+    listSkills(directoryPath: string): Promise<Array<{
+        path: string;
+        name: string;
+        description: string;
+    }>>;
+    private findScript;
+    private operationSupported;
+}
+
+export { type AssetFile, type DisclosureLevel, EnhancedSkillExecutor, type EnhancedSkillExecutorConfig, type LoadedSkill, type ParsedSkill, type ReferenceFile, type RegistryConfig, type LoadedSkill as ResourceLoadedSkill, type ScriptExecutionResult, type ScriptExecutorConfig, type ScriptFile, type SkillManagerConfig, type SkillManifest, SkillRegistry, SkillResourceManager, SkillScriptExecutor, builtInSkills, builtInSkillsMap, createSkillFromManifest, echoSkill, listSkillsSkill, loadSkillFromDirectory, mathSkill, parseSkillMd, validateManifest };