profclaw 0.0.1-beta.1

package/dist/providers/core/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * AI Provider Types
+ *
+ * Core type definitions for the multi-provider AI system.
+ */
+import { z } from 'zod';
+export declare const ProviderType: z.ZodEnum<["anthropic", "openai", "azure", "google", "ollama", "openrouter", "groq", "xai", "mistral", "cohere", "perplexity", "deepseek", "together", "cerebras", "fireworks", "copilot", "bedrock", "zhipu", "moonshot", "qwen", "replicate", "github-models", "volcengine", "byteplus", "qianfan", "modelstudio", "minimax", "xiaomi", "huggingface", "nvidia-nim", "venice", "kilocode", "vercel-ai", "cloudflare-ai", "watsonx"]>;
+export type ProviderType = z.infer<typeof ProviderType>;
+export interface ProviderConfig {
+    type: ProviderType;
+    apiKey?: string;
+    baseUrl?: string;
+    resourceName?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+    defaultModel?: string;
+    enabled: boolean;
+}
+export type ProviderStatus = 'stable' | 'beta' | 'experimental';
+export declare const PROVIDER_STATUS: Record<ProviderType, ProviderStatus>;
+export interface ModelInfo {
+    id: string;
+    name: string;
+    provider: ProviderType;
+    contextWindow: number;
+    maxOutput: number;
+    supportsVision: boolean;
+    supportsStreaming: boolean;
+    supportsTools: boolean;
+    costPer1MInput: number;
+    costPer1MOutput: number;
+}
+export interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: string;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+}
+export interface ChatResponse {
+    id: string;
+    provider: ProviderType;
+    model: string;
+    content: string;
+    finishReason: 'stop' | 'length' | 'tool-calls' | 'error' | 'approval-required';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        cost: number;
+    };
+    duration: number;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolResult {
+    toolCallId: string;
+    result: unknown;
+}
+export interface ChatWithToolsRequest extends ChatRequest {
+    tools?: ToolDefinition[];
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    maxToolRoundtrips?: number;
+}
+export interface ChatWithToolsResponse extends ChatResponse {
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+}
+export interface NativeToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export interface NativeToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    approvalRequired?: boolean;
+    approvalReason?: string;
+}
+export interface NativeToolCallResponse extends ChatResponse {
+    toolCalls?: NativeToolCall[];
+    toolResults?: NativeToolResult[];
+    pendingApprovals?: NativeToolResult[];
+    steps?: number;
+    toolSupport?: {
+        requested: boolean;
+        supported: boolean;
+        used: boolean;
+        recommendation?: string;
+    };
+}
+export type AIMessage = {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/providers/core/types.js

@@ -0,0 +1,83 @@
+/**
+ * AI Provider Types
+ *
+ * Core type definitions for the multi-provider AI system.
+ */
+import { z } from 'zod';
+// Provider Types
+export const ProviderType = z.enum([
+    'anthropic',
+    'openai',
+    'azure',
+    'google',
+    'ollama',
+    'openrouter',
+    'groq',
+    'xai',
+    'mistral',
+    'cohere',
+    'perplexity',
+    'deepseek',
+    'together',
+    'cerebras',
+    'fireworks',
+    'copilot', // GitHub Copilot proxy (experimental)
+    'bedrock', // AWS Bedrock
+    'zhipu', // Zhipu AI (GLM-4 series)
+    'moonshot', // Moonshot AI (Kimi)
+    'qwen', // Qwen API (Alibaba Cloud)
+    'replicate', // Replicate (hosted open-source models)
+    'github-models', // GitHub Models (Azure-backed inference)
+    'volcengine', // Bytedance Doubao
+    'byteplus', // BytePlus (international Bytedance)
+    'qianfan', // Baidu Qianfan
+    'modelstudio', // ModelStudio (Alibaba DashScope)
+    'minimax', // Minimax Portal
+    'xiaomi', // Xiaomi MiLM
+    'huggingface', // HuggingFace Inference
+    'nvidia-nim', // NVIDIA NIM
+    'venice', // Venice AI
+    'kilocode', // Kilocode
+    'vercel-ai', // Vercel AI Gateway
+    'cloudflare-ai', // Cloudflare AI Gateway
+    'watsonx', // IBM Watsonx
+]);
+// Provider metadata with stability status
+export const PROVIDER_STATUS = {
+    anthropic: 'stable',
+    openai: 'stable',
+    azure: 'stable',
+    google: 'stable',
+    ollama: 'stable',
+    openrouter: 'stable',
+    groq: 'stable',
+    xai: 'beta', // Grok is newer
+    mistral: 'stable',
+    cohere: 'beta',
+    perplexity: 'beta', // Search-focused, unique behavior
+    deepseek: 'beta', // R1 is new
+    together: 'beta',
+    cerebras: 'experimental', // Hardware-specific
+    fireworks: 'beta',
+    copilot: 'experimental', // GitHub Copilot proxy - requires local proxy server
+    bedrock: 'stable', // AWS Bedrock - enterprise
+    zhipu: 'beta', // Zhipu AI (GLM-4 series)
+    moonshot: 'beta', // Moonshot AI (Kimi) - long context
+    qwen: 'beta', // Qwen API (Alibaba Cloud)
+    replicate: 'beta', // Replicate (hosted open-source models)
+    'github-models': 'beta', // GitHub Models (Azure-backed inference)
+    volcengine: 'beta', // Bytedance Doubao
+    byteplus: 'beta', // BytePlus (international Bytedance)
+    qianfan: 'beta', // Baidu Qianfan
+    modelstudio: 'experimental', // ModelStudio (Alibaba DashScope)
+    minimax: 'beta', // Minimax Portal
+    xiaomi: 'experimental', // Xiaomi MiLM
+    huggingface: 'beta', // HuggingFace Inference
+    'nvidia-nim': 'beta', // NVIDIA NIM
+    venice: 'experimental', // Venice AI
+    kilocode: 'experimental', // Kilocode
+    'vercel-ai': 'beta', // Vercel AI Gateway
+    'cloudflare-ai': 'beta', // Cloudflare AI Gateway
+    watsonx: 'stable', // IBM Watsonx
+};
+//# sourceMappingURL=types.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * profClaw AI Provider System
+ *
+ * Multi-provider AI chat using Vercel AI SDK.
+ */
+export { aiProvider, chat, chatStream, ProviderType, MODEL_ALIASES, MODEL_CATALOG, type ProviderConfig, type ModelInfo, type ChatMessage, type ChatRequest, type ChatResponse, type NativeToolCall, type NativeToolResult, type NativeToolDefinition, type ToolExecutionResult, } from './ai-sdk.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -0,0 +1,7 @@
+/**
+ * profClaw AI Provider System
+ *
+ * Multi-provider AI chat using Vercel AI SDK.
+ */
+export { aiProvider, chat, chatStream, ProviderType, MODEL_ALIASES, MODEL_CATALOG, } from './ai-sdk.js';
+//# sourceMappingURL=index.js.map

package/dist/providers/registry.d.ts

@@ -0,0 +1,93 @@
+/**
+ * profClaw AI Provider Registry
+ *
+ * Central registry for managing AI providers.
+ * Handles provider discovery, configuration, and routing.
+ */
+import type { AIProvider, ChatCompletionRequest, ChatCompletionResponse, ModelAlias, ModelDefinition, ProviderConfig, ProviderHealth, ProviderType } from './types.js';
+declare class ProviderRegistry {
+    private providers;
+    private configs;
+    private modelAliases;
+    private defaultProvider;
+    /**
+     * Register a provider
+     */
+    register(provider: AIProvider): void;
+    /**
+     * Get a provider by type
+     */
+    get(type: ProviderType): AIProvider | undefined;
+    /**
+     * Get all registered providers
+     */
+    getAll(): AIProvider[];
+    /**
+     * Get all registered provider types
+     */
+    getTypes(): ProviderType[];
+    /**
+     * Set the default provider
+     */
+    setDefault(type: ProviderType): void;
+    /**
+     * Get the default provider
+     */
+    getDefault(): AIProvider | undefined;
+    /**
+     * Configure a provider
+     */
+    configure(type: ProviderType, config: Partial<ProviderConfig>): void;
+    /**
+     * Get provider configuration
+     */
+    getConfig(type: ProviderType): ProviderConfig | undefined;
+    /**
+     * Add a model alias
+     */
+    addAlias(alias: ModelAlias): void;
+    /**
+     * Resolve model alias to provider/model
+     */
+    resolveAlias(aliasOrModel: string): {
+        provider: ProviderType;
+        model: string;
+    } | undefined;
+    /**
+     * Get all available models across all providers
+     */
+    listAllModels(): Promise<ModelDefinition[]>;
+    /**
+     * Health check all providers
+     */
+    healthCheckAll(): Promise<ProviderHealth[]>;
+    /**
+     * Complete a chat request
+     * Automatically routes to the appropriate provider
+     */
+    complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+}
+export declare const providerRegistry: ProviderRegistry;
+/**
+ * Get the provider registry instance
+ */
+export declare function getProviderRegistry(): ProviderRegistry;
+/**
+ * Register a provider with the registry
+ */
+export declare function registerProvider(provider: AIProvider): void;
+/**
+ * Complete a chat request using the registry
+ */
+export declare function chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+/**
+ * Quick helper for simple completions
+ */
+export declare function quickChat(prompt: string, options?: {
+    model?: string;
+    provider?: ProviderType;
+    systemPrompt?: string;
+    temperature?: number;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/providers/registry.js

@@ -0,0 +1,228 @@
+/**
+ * profClaw AI Provider Registry
+ *
+ * Central registry for managing AI providers.
+ * Handles provider discovery, configuration, and routing.
+ */
+import { randomUUID } from 'node:crypto';
+import { DEFAULT_MODEL_ALIASES } from './types.js';
+import { logger } from '../utils/logger.js';
+// === Provider Registry ===
+class ProviderRegistry {
+    providers = new Map();
+    configs = new Map();
+    modelAliases = [...DEFAULT_MODEL_ALIASES];
+    defaultProvider = 'ollama';
+    /**
+     * Register a provider
+     */
+    register(provider) {
+        this.providers.set(provider.type, provider);
+        logger.info(`[ProviderRegistry] Registered provider: ${provider.name}`);
+    }
+    /**
+     * Get a provider by type
+     */
+    get(type) {
+        return this.providers.get(type);
+    }
+    /**
+     * Get all registered providers
+     */
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * Get all registered provider types
+     */
+    getTypes() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * Set the default provider
+     */
+    setDefault(type) {
+        if (!this.providers.has(type)) {
+            throw new Error(`Provider '${type}' is not registered`);
+        }
+        this.defaultProvider = type;
+    }
+    /**
+     * Get the default provider
+     */
+    getDefault() {
+        return this.providers.get(this.defaultProvider);
+    }
+    /**
+     * Configure a provider
+     */
+    configure(type, config) {
+        const provider = this.providers.get(type);
+        if (!provider) {
+            throw new Error(`Provider '${type}' is not registered`);
+        }
+        const existing = this.configs.get(type) || provider.getConfig();
+        const merged = {
+            ...existing,
+            ...config,
+            id: existing.id,
+            type: existing.type,
+        };
+        this.configs.set(type, merged);
+        provider.configure(merged);
+    }
+    /**
+     * Get provider configuration
+     */
+    getConfig(type) {
+        return this.configs.get(type) || this.providers.get(type)?.getConfig();
+    }
+    /**
+     * Add a model alias
+     */
+    addAlias(alias) {
+        // Remove existing alias with same name
+        this.modelAliases = this.modelAliases.filter((a) => a.alias !== alias.alias);
+        this.modelAliases.push(alias);
+    }
+    /**
+     * Resolve model alias to provider/model
+     */
+    resolveAlias(aliasOrModel) {
+        // Check if it's a direct provider/model reference
+        if (aliasOrModel.includes('/')) {
+            const [provider, model] = aliasOrModel.split('/');
+            return { provider: provider, model };
+        }
+        // Check aliases
+        const alias = this.modelAliases.find((a) => a.alias.toLowerCase() === aliasOrModel.toLowerCase());
+        if (alias) {
+            return { provider: alias.provider, model: alias.model };
+        }
+        // Try to find model in any registered provider
+        for (const provider of this.providers.values()) {
+            const model = provider.getModel(aliasOrModel);
+            if (model) {
+                return { provider: provider.type, model: model.id };
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get all available models across all providers
+     */
+    async listAllModels() {
+        const models = [];
+        for (const provider of this.providers.values()) {
+            try {
+                const providerModels = await provider.listModels();
+                models.push(...providerModels);
+            }
+            catch (error) {
+                logger.warn(`[ProviderRegistry] Failed to list models for ${provider.type}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        return models;
+    }
+    /**
+     * Health check all providers
+     */
+    async healthCheckAll() {
+        const results = [];
+        for (const provider of this.providers.values()) {
+            try {
+                const health = await provider.healthCheck();
+                results.push(health);
+            }
+            catch (error) {
+                results.push({
+                    provider: provider.type,
+                    healthy: false,
+                    message: error instanceof Error ? error.message : 'Health check failed',
+                    lastChecked: new Date().toISOString(),
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Complete a chat request
+     * Automatically routes to the appropriate provider
+     */
+    async complete(request) {
+        let provider;
+        let model;
+        // Resolve provider and model
+        if (request.provider) {
+            provider = this.providers.get(request.provider);
+        }
+        else if (request.model) {
+            const resolved = this.resolveAlias(request.model);
+            if (resolved) {
+                provider = this.providers.get(resolved.provider);
+                model = resolved.model;
+            }
+        }
+        // Fall back to default provider
+        if (!provider) {
+            provider = this.getDefault();
+        }
+        if (!provider) {
+            throw new Error('No provider available for chat completion');
+        }
+        // Use resolved model or provider's default
+        const finalRequest = {
+            ...request,
+            provider: provider.type,
+            model: model || request.model,
+        };
+        if (request.stream) {
+            const response = await provider.completeStream(finalRequest, () => { });
+            return response;
+        }
+        return provider.complete(finalRequest);
+    }
+}
+// === Singleton Instance ===
+export const providerRegistry = new ProviderRegistry();
+// === Helper Functions ===
+/**
+ * Get the provider registry instance
+ */
+export function getProviderRegistry() {
+    return providerRegistry;
+}
+/**
+ * Register a provider with the registry
+ */
+export function registerProvider(provider) {
+    providerRegistry.register(provider);
+}
+/**
+ * Complete a chat request using the registry
+ */
+export async function chat(request) {
+    return providerRegistry.complete(request);
+}
+/**
+ * Quick helper for simple completions
+ */
+export async function quickChat(prompt, options = {}) {
+    const response = await providerRegistry.complete({
+        messages: [
+            {
+                id: randomUUID(),
+                role: 'user',
+                content: prompt,
+                timestamp: new Date().toISOString(),
+            },
+        ],
+        model: options.model,
+        provider: options.provider,
+        systemPrompt: options.systemPrompt,
+        temperature: options.temperature ?? 0.7,
+        stream: false,
+    });
+    return response.message.content;
+}
+//# sourceMappingURL=registry.js.map

package/dist/providers/schema-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Schema Utilities for AI Tool Calling
+ *
+ * Normalizes JSON Schema for compatibility with different AI providers.
+ * Based on OpenClaw's battle-tested schema normalization.
+ *
+ * Key requirements:
+ * - OpenAI/Azure: Top-level must be `type: "object"`
+ * - Gemini: Rejects $ref, definitions, additionalProperties, etc.
+ * - All: Avoid complex anyOf/oneOf unions at top level
+ */
+/**
+ * Clean a schema for provider compatibility
+ * Removes unsupported keywords, resolves $refs, flattens unions
+ */
+export declare function cleanSchema(schema: unknown): unknown;
+/**
+ * Normalize tool parameters for provider compatibility
+ * Ensures top-level type: "object" and cleans the schema
+ * Guarantees Azure-compatible output
+ */
+export declare function normalizeToolSchema(schema: unknown): Record<string, unknown>;
+//# sourceMappingURL=schema-utils.d.ts.map