sdkwork-browser-agent 1.0.0

package/dist/llm/index.d.ts

@@ -0,0 +1,235 @@
+import { f as LLMProviderConfig, L as LLMProvider, b as LLMRequest, c as LLMResponse, d as LLMStreamChunk } from '../provider-Dna36xA-.js';
+export { e as LLMManager, a as LLMMessage, g as LLMProviderFactory, h as LLMProviderRegistry, i as ToolCall, T as ToolDefinition, j as globalProviderRegistry } from '../provider-Dna36xA-.js';
+
+/**
+ * OpenAI Provider Implementation
+ * Updated with latest GPT-5 series models (2025)
+ */
+
+interface OpenAIConfig extends LLMProviderConfig {
+    organization?: string;
+    project?: string;
+}
+declare class OpenAIProvider implements LLMProvider {
+    readonly name = "openai";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    private _organization?;
+    private _project?;
+    constructor(config: OpenAIConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private formatMessages;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * Anthropic Claude Provider Implementation
+ * Updated with Claude 4.5 series models (2025)
+ */
+
+interface AnthropicConfig extends LLMProviderConfig {
+    anthropicVersion?: string;
+}
+declare class AnthropicProvider implements LLMProvider {
+    readonly name = "anthropic";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    private _anthropicVersion;
+    constructor(config: AnthropicConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * Google Gemini Provider Implementation
+ * Updated with Gemini 2.0/3.0 series models (2025)
+ */
+
+interface GeminiConfig extends LLMProviderConfig {
+    apiVersion?: string;
+}
+declare class GeminiProvider implements LLMProvider {
+    readonly name = "gemini";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    private _apiVersion;
+    constructor(config: GeminiConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * Moonshot (月之暗面) Provider Implementation
+ * API: https://platform.moonshot.cn
+ */
+
+interface MoonshotConfig extends LLMProviderConfig {
+}
+declare class MoonshotProvider implements LLMProvider {
+    readonly name = "moonshot";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    constructor(config: MoonshotConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * MiniMax Provider Implementation
+ * API: https://platform.minimaxi.com
+ */
+
+interface MiniMaxConfig extends LLMProviderConfig {
+    groupId?: string;
+}
+declare class MiniMaxProvider implements LLMProvider {
+    readonly name = "minimax";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _groupId;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    constructor(config: MiniMaxConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * Zhipu AI (智谱AI) Provider Implementation
+ * API: https://open.bigmodel.cn
+ */
+
+interface ZhipuConfig extends LLMProviderConfig {
+}
+declare class ZhipuProvider implements LLMProvider {
+    readonly name = "zhipu";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    constructor(config: ZhipuConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * Qwen (通义千问) Provider Implementation
+ * API: https://dashscope.aliyun.com
+ * Updated with latest Qwen3 series models (2025)
+ */
+
+interface QwenConfig extends LLMProviderConfig {
+}
+declare class QwenProvider implements LLMProvider {
+    readonly name = "qwen";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    constructor(config: QwenConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * DeepSeek Provider Implementation
+ * API: https://platform.deepseek.com
+ * Updated with latest DeepSeek-V3.2 models (2025)
+ */
+
+interface DeepSeekConfig extends LLMProviderConfig {
+}
+declare class DeepSeekProvider implements LLMProvider {
+    readonly name = "deepseek";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    constructor(config: DeepSeekConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+/**
+ * Doubao (豆包) Provider Implementation
+ * API: https://console.volcengine.com/ark
+ * Updated with latest Doubao 1.8 series models (2025)
+ */
+
+interface DoubaoConfig extends LLMProviderConfig {
+    region?: string;
+}
+declare class DoubaoProvider implements LLMProvider {
+    readonly name = "doubao";
+    readonly supportedModels: string[];
+    private _apiKey;
+    private _baseUrl;
+    private _defaultParams;
+    private _timeout;
+    constructor(config: DoubaoConfig);
+    validateConfig(): boolean;
+    private makeRequest;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream(request: LLMRequest): AsyncIterableIterator<LLMStreamChunk>;
+    private buildRequestBody;
+    private parseResponse;
+    private parseStreamChunk;
+}
+
+export { type AnthropicConfig, AnthropicProvider, type DeepSeekConfig, DeepSeekProvider, type DoubaoConfig, DoubaoProvider, type GeminiConfig, GeminiProvider, LLMProvider, LLMProviderConfig, LLMRequest, LLMResponse, LLMStreamChunk, type MiniMaxConfig, MiniMaxProvider, type MoonshotConfig, MoonshotProvider, type OpenAIConfig, OpenAIProvider, type QwenConfig, QwenProvider, type ZhipuConfig, ZhipuProvider };

package/dist/llm/index.js

@@ -0,0 +1,29 @@
+import {
+  AnthropicProvider,
+  DeepSeekProvider,
+  DoubaoProvider,
+  GeminiProvider,
+  LLMManager,
+  LLMProviderRegistry,
+  MiniMaxProvider,
+  MoonshotProvider,
+  OpenAIProvider,
+  QwenProvider,
+  ZhipuProvider,
+  globalProviderRegistry
+} from "../chunk-5XTVS5MB.js";
+export {
+  AnthropicProvider,
+  DeepSeekProvider,
+  DoubaoProvider,
+  GeminiProvider,
+  LLMManager,
+  LLMProviderRegistry,
+  MiniMaxProvider,
+  MoonshotProvider,
+  OpenAIProvider,
+  QwenProvider,
+  ZhipuProvider,
+  globalProviderRegistry
+};
+//# sourceMappingURL=index.js.map

package/dist/llm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/mcp/index.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkKZNZ6CGDcjs = require('../chunk-KZNZ6CGD.cjs');
+
+
+
+exports.MCPClient = _chunkKZNZ6CGDcjs.MCPClient; exports.MCPServer = _chunkKZNZ6CGDcjs.MCPServer;
+//# sourceMappingURL=index.cjs.map

package/dist/mcp/index.cjs.map

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

package/dist/mcp/index.d.cts

@@ -0,0 +1,63 @@
+import { M as MCPResource, h as MCPTool, f as MCPResourceContent, i as MCPToolResult } from '../agent-kexkkI13.cjs';
+import '../provider-Dna36xA-.cjs';
+
+/**
+ * MCP (Model Context Protocol) Implementation
+ * https://modelcontextprotocol.io
+ */
+
+interface MCPServerConfig {
+    name: string;
+    version: string;
+    resources?: MCPResource[];
+    tools?: MCPTool[];
+}
+interface MCPClientConfig {
+    url: string;
+    auth?: {
+        type: 'bearer' | 'apiKey';
+        token: string;
+    };
+}
+declare class MCPClient {
+    private config;
+    private resources;
+    private tools;
+    constructor(config: MCPClientConfig);
+    connect(): Promise<void>;
+    private createRemoteResource;
+    private createRemoteTool;
+    getResources(): MCPResource[];
+    getTools(): MCPTool[];
+    getResource(uri: string): MCPResource | undefined;
+    getTool(name: string): MCPTool | undefined;
+}
+declare class MCPServer {
+    private config;
+    private resources;
+    private tools;
+    constructor(config: MCPServerConfig);
+    registerResource(resource: MCPResource): void;
+    registerTool(tool: MCPTool): void;
+    unregisterResource(uri: string): boolean;
+    unregisterTool(name: string): boolean;
+    getCapabilities(): {
+        name: string;
+        version: string;
+        resources: Array<{
+            uri: string;
+            name: string;
+            description?: string;
+            mimeType?: string;
+        }>;
+        tools: Array<{
+            name: string;
+            description: string;
+            inputSchema: unknown;
+        }>;
+    };
+    readResource(uri: string): Promise<MCPResourceContent | null>;
+    executeTool(name: string, args: unknown): Promise<MCPToolResult | null>;
+}
+
+export { MCPClient, type MCPClientConfig, MCPServer, type MCPServerConfig };

package/dist/mcp/index.d.ts

@@ -0,0 +1,63 @@
+import { M as MCPResource, h as MCPTool, f as MCPResourceContent, i as MCPToolResult } from '../agent-Bpxmkz8W.js';
+import '../provider-Dna36xA-.js';
+
+/**
+ * MCP (Model Context Protocol) Implementation
+ * https://modelcontextprotocol.io
+ */
+
+interface MCPServerConfig {
+    name: string;
+    version: string;
+    resources?: MCPResource[];
+    tools?: MCPTool[];
+}
+interface MCPClientConfig {
+    url: string;
+    auth?: {
+        type: 'bearer' | 'apiKey';
+        token: string;
+    };
+}
+declare class MCPClient {
+    private config;
+    private resources;
+    private tools;
+    constructor(config: MCPClientConfig);
+    connect(): Promise<void>;
+    private createRemoteResource;
+    private createRemoteTool;
+    getResources(): MCPResource[];
+    getTools(): MCPTool[];
+    getResource(uri: string): MCPResource | undefined;
+    getTool(name: string): MCPTool | undefined;
+}
+declare class MCPServer {
+    private config;
+    private resources;
+    private tools;
+    constructor(config: MCPServerConfig);
+    registerResource(resource: MCPResource): void;
+    registerTool(tool: MCPTool): void;
+    unregisterResource(uri: string): boolean;
+    unregisterTool(name: string): boolean;
+    getCapabilities(): {
+        name: string;
+        version: string;
+        resources: Array<{
+            uri: string;
+            name: string;
+            description?: string;
+            mimeType?: string;
+        }>;
+        tools: Array<{
+            name: string;
+            description: string;
+            inputSchema: unknown;
+        }>;
+    };
+    readResource(uri: string): Promise<MCPResourceContent | null>;
+    executeTool(name: string, args: unknown): Promise<MCPToolResult | null>;
+}
+
+export { MCPClient, type MCPClientConfig, MCPServer, type MCPServerConfig };

package/dist/mcp/index.js

@@ -0,0 +1,9 @@
+import {
+  MCPClient,
+  MCPServer
+} from "../chunk-56J3IBXZ.js";
+export {
+  MCPClient,
+  MCPServer
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/node/agent-Bpxmkz8W.d.ts

@@ -0,0 +1,197 @@
+import { L as LLMProvider, a as LLMMessage, b as LLMRequest, c as LLMResponse, d as LLMStreamChunk, T as ToolDefinition } from './provider-Dna36xA-.js';
+
+/**
+ * Core Agent Architecture
+ * High cohesion, low coupling design
+ * Compatible with https://agentskills.io/specification
+ */
+
+interface Skill {
+    name: string;
+    description: string;
+    parameters: ParameterSchema;
+    handler: SkillHandler;
+    metadata?: SkillMetadata;
+}
+interface ParameterSchema {
+    type: 'object';
+    properties: Record<string, ParameterProperty>;
+    required?: string[];
+}
+interface ParameterProperty {
+    type: string;
+    description: string;
+    enum?: string[];
+    default?: unknown;
+}
+interface SkillMetadata {
+    category?: string;
+    tags?: string[];
+    version?: string;
+    author?: string;
+    deprecated?: boolean;
+}
+type SkillHandler = (params: Record<string, unknown>, context: ExecutionContext) => Promise<SkillResult>;
+interface ExecutionContext {
+    agent: Agent;
+    skillName: string;
+    timestamp: Date;
+    metadata?: Record<string, unknown>;
+}
+interface SkillResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface Tool {
+    name: string;
+    description: string;
+    parameters?: ParameterSchema;
+    execute: ToolExecutor;
+    metadata?: ToolMetadata;
+}
+interface ToolMetadata {
+    category?: string;
+    tags?: string[];
+    version?: string;
+    requiresConfirmation?: boolean;
+}
+type ToolExecutor = (input: unknown, context: ExecutionContext) => Promise<ToolOutput>;
+interface ToolOutput {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: unknown;
+    }>;
+    isError?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    read: () => Promise<MCPResourceContent>;
+    metadata?: MCPResourceMetadata;
+}
+interface MCPResourceContent {
+    uri: string;
+    mimeType: string;
+    text?: string;
+    blob?: string;
+    metadata?: Record<string, unknown>;
+}
+interface MCPResourceMetadata {
+    size?: number;
+    lastModified?: Date;
+    etag?: string;
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: unknown;
+    execute: (args: unknown, context: ExecutionContext) => Promise<MCPToolResult>;
+    metadata?: ToolMetadata;
+}
+interface MCPToolResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: unknown;
+    }>;
+    isError?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface Plugin {
+    name: string;
+    version: string;
+    description?: string;
+    initialize: (context: PluginContext) => Promise<void>;
+    destroy?: () => Promise<void>;
+    metadata?: PluginMetadata;
+}
+interface PluginMetadata {
+    author?: string;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    dependencies?: string[];
+}
+interface PluginContext {
+    agent: Agent;
+    registerSkill: (skill: Skill) => void;
+    registerTool: (tool: Tool) => void;
+    registerMCPResource: (resource: MCPResource) => void;
+    registerMCPTool: (tool: MCPTool) => void;
+    getLLMProvider: () => LLMProvider | undefined;
+    config: Record<string, unknown>;
+}
+interface AgentConfig {
+    name: string;
+    description?: string;
+    version?: string;
+    llmProvider?: LLMProvider;
+    systemPrompt?: string;
+    maxIterations?: number;
+    skills?: Skill[];
+    tools?: Tool[];
+    plugins?: Plugin[];
+    mcpResources?: MCPResource[];
+    mcpTools?: MCPTool[];
+    middlewares?: AgentMiddleware[];
+    hooks?: AgentHooks;
+}
+interface AgentHooks {
+    beforeSkillExecution?: (skillName: string, params: Record<string, unknown>) => Promise<void>;
+    afterSkillExecution?: (skillName: string, result: SkillResult) => Promise<void>;
+    onError?: (error: Error, context: ExecutionContext) => Promise<void>;
+    onToolCall?: (toolName: string, args: unknown) => Promise<void>;
+}
+type AgentMiddleware = (context: ExecutionContext, next: () => Promise<SkillResult>) => Promise<SkillResult>;
+declare class Agent {
+    private config;
+    private _skills;
+    private _tools;
+    private _plugins;
+    private _mcpResources;
+    private _mcpTools;
+    private _middlewares;
+    private _initialized;
+    readonly name: string;
+    readonly description?: string;
+    readonly version?: string;
+    llmProvider?: LLMProvider;
+    systemPrompt?: string;
+    maxIterations: number;
+    hooks?: AgentHooks;
+    constructor(config: AgentConfig);
+    initialize(): Promise<void>;
+    registerSkill(skill: Skill): void;
+    registerTool(tool: Tool): void;
+    registerMCPResource(resource: MCPResource): void;
+    registerMCPTool(tool: MCPTool): void;
+    use(middleware: AgentMiddleware): void;
+    executeSkill(name: string, params?: Record<string, unknown>): Promise<SkillResult>;
+    executeTool(name: string, input: unknown): Promise<ToolOutput>;
+    readMCPResource(uri: string): Promise<MCPResourceContent | null>;
+    executeMCPTool(name: string, args: unknown): Promise<MCPToolResult>;
+    chat(messages: LLMMessage[], options?: Partial<LLMRequest>): Promise<LLMResponse>;
+    streamChat(messages: LLMMessage[], options?: Partial<LLMRequest>): AsyncIterableIterator<LLMStreamChunk>;
+    executeWithTools(messages: LLMMessage[], tools?: ToolDefinition[]): Promise<LLMResponse>;
+    getSkill(name: string): Skill | undefined;
+    getTool(name: string): Tool | undefined;
+    getMCPResource(uri: string): MCPResource | undefined;
+    getMCPTool(name: string): MCPTool | undefined;
+    getPlugin(name: string): Plugin | undefined;
+    getSkillNames(): string[];
+    getToolNames(): string[];
+    getMCPResourceURIs(): string[];
+    getMCPToolNames(): string[];
+    getPluginNames(): string[];
+    getAllSkills(): Skill[];
+    getAllTools(): Tool[];
+    destroy(): Promise<void>;
+}
+
+export { Agent as A, type ExecutionContext as E, type MCPResource as M, type Plugin as P, type Skill as S, type Tool as T, type SkillResult as a, type AgentConfig as b, type PluginContext as c, type AgentHooks as d, type AgentMiddleware as e, type MCPResourceContent as f, type MCPResourceMetadata as g, type MCPTool as h, type MCPToolResult as i, type ParameterProperty as j, type ParameterSchema as k, type PluginMetadata as l, type SkillHandler as m, type SkillMetadata as n, type ToolExecutor as o, type ToolMetadata as p, type ToolOutput as q };