@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.74

package/dist/esm/facade/Crewx.browser.js

@@ -0,0 +1,310 @@
+/**
+ * Browser-safe Crewx facade.
+ *
+ * Stripped of all Node.js dependencies (path, fs, child_process, crypto, events).
+ * Supports: fromConfig(), query(), execute(), registerTool(), agents, tools.
+ *
+ * Built-in providers (e.g. api/webllm) are auto-initialised when detected
+ * in the agents list — no manual registerProviderFactory required.
+ */
+import { resolveAgent, AgentNotFoundError } from '../agent/resolver.js';
+import { createProvider, registerProviderFactory, ProviderError, } from '../provider/bridge.browser.js';
+/** Dynamic import that bypasses TypeScript module resolution for CDN URLs. */
+const _cdnImport = new Function('u', 'return import(u)');
+export class Crewx {
+    _agents;
+    _config;
+    _tools = new Map();
+    _apiProviders = new Map();
+    constructor(agents, config) {
+        this._agents = new Map(agents.map(a => [a.id, a]));
+        this._config = config;
+    }
+    /**
+     * Create a Crewx instance from an already-parsed config object.
+     *
+     * Built-in browser providers (api/webllm, api/openrouter) are auto-initialised
+     * when detected in the agents list — no manual registerProviderFactory required.
+     */
+    static async fromConfig(config, options) {
+        const instance = new Crewx(config.agents ?? [], config);
+        const agents = config.agents ?? [];
+        const providerOf = (a) => Array.isArray(a.provider) ? a.provider[0] : a.provider;
+        const webllmAgents = agents.filter(a => providerOf(a) === 'api/webllm');
+        const openrouterAgents = agents.filter(a => providerOf(a) === 'api/openrouter');
+        if (webllmAgents.length > 0) {
+            await instance._initWebLLM(webllmAgents, options?.onProgress);
+        }
+        if (openrouterAgents.length > 0) {
+            if (!options?.openrouterApiKey) {
+                throw new Error('openrouterApiKey is required when using api/openrouter provider');
+            }
+            instance._initOpenRouter(openrouterAgents, options.openrouterApiKey);
+        }
+        // Register unified api factory dispatching to initialised sub-providers
+        if (instance._apiProviders.size > 0) {
+            registerProviderFactory('api', (id, providerStr) => {
+                const provider = instance._apiProviders.get(id);
+                if (!provider) {
+                    throw new ProviderError(`Unknown api provider: ${id}`, providerStr);
+                }
+                return provider;
+            });
+        }
+        return instance;
+    }
+    // ── web-llm auto-init ──────────────────────────────────────────────────────
+    /**
+     * Load web-llm from CDN, create the inference engine, and store
+     * the provider runtime.  Called automatically by fromConfig().
+     */
+    async _initWebLLM(agents, onProgress) {
+        if (typeof navigator === 'undefined' || !navigator.gpu) {
+            throw new Error('WebGPU is not available. Chrome 113+ or Edge 113+ required.');
+        }
+        const webllm = await _cdnImport('https://esm.run/@mlc-ai/web-llm');
+        const modelId = agents[0]?.inline?.model ?? 'gemma-2-2b-it-q4f16_1-MLC';
+        const engine = await webllm.CreateMLCEngine(modelId, {
+            initProgressCallback: onProgress
+                ? (report) => onProgress(report)
+                : undefined,
+        });
+        const history = [];
+        this._apiProviders.set('webllm', {
+            async query(message, options) {
+                const messages = [];
+                if (options?.systemPrompt) {
+                    messages.push({ role: 'system', content: options.systemPrompt });
+                }
+                messages.push(...history);
+                messages.push({ role: 'user', content: message });
+                let fullReply = '';
+                const stream = await engine.chat.completions.create({
+                    messages,
+                    stream: true,
+                    temperature: 0.7,
+                    max_tokens: 4096,
+                });
+                for await (const chunk of stream) {
+                    const delta = chunk.choices?.[0]?.delta?.content ?? '';
+                    fullReply += delta;
+                    if (options?.onOutput) {
+                        options.onOutput(fullReply, 'stdout');
+                    }
+                }
+                history.push({ role: 'user', content: message });
+                history.push({ role: 'assistant', content: fullReply });
+                return fullReply;
+            },
+            async execute(message, options) {
+                return this.query(message, options);
+            },
+        });
+    }
+    /**
+     * Initialise the OpenRouter API provider.
+     * Uses fetch + SSE streaming against the OpenAI-compatible endpoint.
+     */
+    _initOpenRouter(agents, apiKey) {
+        const defaultModel = agents[0]?.inline?.model ?? 'google/gemma-2-2b-it';
+        const history = [];
+        this._apiProviders.set('openrouter', {
+            async query(message, options) {
+                const messages = [];
+                if (options?.systemPrompt) {
+                    messages.push({ role: 'system', content: options.systemPrompt });
+                }
+                messages.push(...history);
+                messages.push({ role: 'user', content: message });
+                const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        model: options?.model || defaultModel,
+                        messages,
+                        stream: true,
+                    }),
+                });
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    throw new Error(`OpenRouter API error (${response.status}): ${errorBody}`);
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let fullReply = '';
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop();
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || !trimmed.startsWith('data: '))
+                            continue;
+                        const data = trimmed.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const parsed = JSON.parse(data);
+                            const delta = parsed.choices?.[0]?.delta?.content ?? '';
+                            fullReply += delta;
+                            if (delta && options?.onOutput) {
+                                options.onOutput(fullReply, 'stdout');
+                            }
+                        }
+                        catch {
+                            // skip malformed SSE chunks
+                        }
+                    }
+                }
+                history.push({ role: 'user', content: message });
+                history.push({ role: 'assistant', content: fullReply });
+                return fullReply;
+            },
+            async execute(message, options) {
+                return this.query(message, options);
+            },
+        });
+    }
+    get agents() {
+        return this._agents;
+    }
+    get config() {
+        return this._config;
+    }
+    get tools() {
+        return this._tools;
+    }
+    registerTool(name, definition) {
+        this._tools.set(name, { name, ...definition });
+    }
+    /**
+     * Query an agent with a message.
+     * Browser version — delegates directly to the registered provider factory.
+     * Passes onOutput through for streaming support.
+     */
+    async query(agentRef, message, options) {
+        const startMs = Date.now();
+        let agent;
+        try {
+            agent = resolveAgent(agentRef, Array.from(this._agents.values()));
+        }
+        catch (err) {
+            if (err instanceof AgentNotFoundError) {
+                return {
+                    ok: false,
+                    data: '',
+                    error: { code: 'AGENT_NOT_FOUND', message: err.message },
+                    meta: { agentId: agentRef.replace(/^@/, ''), provider: '', durationMs: Date.now() - startMs },
+                };
+            }
+            throw err;
+        }
+        const providerStr = Array.isArray(agent.provider)
+            ? agent.provider[0] ?? 'api/default'
+            : agent.provider;
+        const effectiveProviderStr = options?.provider ?? providerStr;
+        const effectiveModel = options?.model ?? agent.inline?.model;
+        let provider;
+        try {
+            provider = createProvider(effectiveProviderStr);
+        }
+        catch (err) {
+            return {
+                ok: false,
+                data: '',
+                error: { code: 'PROVIDER_ERROR', message: err.message },
+                meta: { agentId: agent.id, provider: effectiveProviderStr, model: effectiveModel, durationMs: Date.now() - startMs },
+            };
+        }
+        try {
+            const response = await provider.query(message, {
+                model: effectiveModel,
+                context: options?.context,
+                systemPrompt: agent.inline?.system_prompt ?? agent.inline?.prompt,
+                onOutput: options?.onOutput
+                    ? (line) => options.onOutput(line)
+                    : undefined,
+            });
+            return {
+                ok: true,
+                data: response,
+                meta: { agentId: agent.id, provider: effectiveProviderStr, model: effectiveModel, durationMs: Date.now() - startMs },
+            };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                data: '',
+                error: { code: 'QUERY_FAILED', message: err.message },
+                meta: { agentId: agent.id, provider: effectiveProviderStr, model: effectiveModel, durationMs: Date.now() - startMs },
+            };
+        }
+    }
+    /**
+     * Execute a task with an agent.
+     * Browser version — same delegation pattern as query().
+     */
+    async execute(agentRef, message, options) {
+        const startMs = Date.now();
+        let agent;
+        try {
+            agent = resolveAgent(agentRef, Array.from(this._agents.values()));
+        }
+        catch (err) {
+            if (err instanceof AgentNotFoundError) {
+                return {
+                    ok: false,
+                    data: '',
+                    error: { code: 'AGENT_NOT_FOUND', message: err.message },
+                    meta: { agentId: agentRef.replace(/^@/, ''), provider: '', durationMs: Date.now() - startMs },
+                };
+            }
+            throw err;
+        }
+        const providerStr = Array.isArray(agent.provider)
+            ? agent.provider[0] ?? 'api/default'
+            : agent.provider;
+        const effectiveProviderStr = options?.provider ?? providerStr;
+        const effectiveModel = options?.model ?? agent.inline?.model;
+        let provider;
+        try {
+            provider = createProvider(effectiveProviderStr);
+        }
+        catch (err) {
+            return {
+                ok: false,
+                data: '',
+                error: { code: 'PROVIDER_ERROR', message: err.message },
+                meta: { agentId: agent.id, provider: effectiveProviderStr, model: effectiveModel, durationMs: Date.now() - startMs },
+            };
+        }
+        try {
+            const response = await provider.execute(message, {
+                model: effectiveModel,
+                context: options?.context,
+                systemPrompt: agent.inline?.system_prompt ?? agent.inline?.prompt,
+            });
+            return {
+                ok: true,
+                data: response,
+                meta: { agentId: agent.id, provider: effectiveProviderStr, model: effectiveModel, durationMs: Date.now() - startMs },
+            };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                data: '',
+                error: { code: 'EXECUTE_FAILED', message: err.message },
+                meta: { agentId: agent.id, provider: effectiveProviderStr, model: effectiveModel, durationMs: Date.now() - startMs },
+            };
+        }
+    }
+}
+//# sourceMappingURL=Crewx.browser.js.map