@useconductor/conductor 1.0.0

package/src/ai/ollama.ts

@@ -0,0 +1,186 @@
+import { AIProvider, AIMessage, AIResponse } from './base.js';
+import { PluginTool } from '../plugins/manager.js';
+
+interface OllamaToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: 'object';
+      properties: Record<string, unknown>;
+      required: string[];
+    };
+  };
+}
+
+function convertToOllamaTools(tools?: PluginTool[]): OllamaToolDefinition[] {
+  if (!tools || tools.length === 0) return [];
+
+  return tools.map((t) => ({
+    type: 'function' as const,
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: {
+        type: 'object' as const,
+        properties: (t.inputSchema.properties ?? {}) as Record<string, unknown>,
+        required: (t.inputSchema.required as string[]) ?? [],
+      },
+    },
+  }));
+}
+
+export class OllamaProvider extends AIProvider {
+  private endpoint: string;
+
+  constructor(config: Record<string, unknown>) {
+    super(config);
+    this.endpoint = (config.endpoint as string) || 'http://localhost:11434';
+  }
+
+  getName(): string {
+    return 'Ollama';
+  }
+
+  async initialize(): Promise<void> {
+    const isRunning = await this.test();
+    if (!isRunning) {
+      throw new Error('Ollama is not running. Start it with: ollama serve');
+    }
+  }
+
+  async complete(messages: AIMessage[], tools?: PluginTool[]): Promise<AIResponse> {
+    const model = (this.config.model as string) || 'llama3.2';
+    const ollamaTools = convertToOllamaTools(tools);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      stream: false,
+    };
+
+    if (ollamaTools.length > 0) {
+      body.tools = ollamaTools;
+    }
+
+    const response = await fetch(`${this.endpoint}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Ollama error: ${response.statusText}`);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = (await response.json()) as any;
+
+    // Check for tool calls in the response
+    if (data.message?.tool_calls) {
+      const toolCall = data.message.tool_calls[0];
+      return {
+        content: data.message.content || '',
+        model: data.model,
+        tokens_used: data.eval_count,
+        tool_calls: [
+          {
+            id: toolCall.function?.name ?? 'unknown',
+            name: toolCall.function?.name ?? 'unknown',
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            arguments: (toolCall.function?.arguments ?? {}) as Record<string, any>,
+          },
+        ],
+      };
+    }
+
+    return {
+      content: data.message?.content ?? '',
+      model: data.model,
+      tokens_used: data.eval_count,
+    };
+  }
+
+  async *stream(messages: AIMessage[], tools?: PluginTool[]): AsyncGenerator<string> {
+    const model = (this.config.model as string) || 'llama3.2';
+    const ollamaTools = convertToOllamaTools(tools);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      stream: true,
+    };
+
+    if (ollamaTools.length > 0) {
+      body.tools = ollamaTools;
+    }
+
+    const response = await fetch(`${this.endpoint}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok || !response.body) {
+      throw new Error(`Ollama error: ${response.statusText}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n').filter((l) => l.trim());
+
+      for (const line of lines) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const json = JSON.parse(line) as any;
+          if (json.message?.content) {
+            yield json.message.content;
+          }
+        } catch {
+          // Skip invalid JSON fragments
+        }
+      }
+    }
+  }
+
+  async test(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.endpoint}/api/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /** List available models. */
+  async listModels(): Promise<string[]> {
+    try {
+      const response = await fetch(`${this.endpoint}/api/tags`);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const data = (await response.json()) as any;
+      return (data.models ?? []).map((m: { name: string }) => m.name);
+    } catch {
+      return [];
+    }
+  }
+
+  /** Pull a model. */
+  async pullModel(model: string): Promise<void> {
+    const response = await fetch(`${this.endpoint}/api/pull`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: model, stream: false }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to pull model: ${response.statusText}`);
+    }
+  }
+}

package/src/ai/openai.ts

@@ -0,0 +1,147 @@
+import { AIProvider, AIMessage, AIResponse } from './base.js';
+import { PluginTool } from '../plugins/manager.js';
+import OpenAI from 'openai';
+import { ChatCompletionMessageParam, ChatCompletionTool } from 'openai/resources/chat/completions.js';
+
+export class OpenAIProvider extends AIProvider {
+  private client: OpenAI | null = null;
+
+  async initialize(apiKey: string): Promise<void> {
+    this.client = new OpenAI({ apiKey });
+  }
+
+  getName(): string {
+    return 'OpenAI';
+  }
+
+  async complete(messages: AIMessage[], tools?: PluginTool[]): Promise<AIResponse> {
+    if (!this.client) throw new Error('OpenAI not initialized');
+
+    const model = this.config.model || 'gpt-4o';
+
+    const requestTools: ChatCompletionTool[] | undefined = tools?.length
+      ? tools.map((t) => ({
+          type: 'function',
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema as any,
+          },
+        }))
+      : undefined;
+
+    const formattedMessages: ChatCompletionMessageParam[] = messages.map((m) => {
+      if (m.role === 'tool') {
+        return {
+          role: 'tool',
+          content: m.content,
+          tool_call_id: m.tool_call_id!,
+        };
+      } else if (m.role === 'assistant' && m.tool_calls) {
+        return {
+          role: 'assistant',
+          content: m.content || null,
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+          })),
+        };
+      }
+
+      return {
+        role: m.role as 'user' | 'assistant' | 'system',
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+      };
+    });
+
+    const response = await this.client.chat.completions.create({
+      model,
+      messages: formattedMessages,
+      max_tokens: this.config.maxTokens || 4096,
+      tools: requestTools,
+    });
+
+    const choice = response.choices[0];
+
+    return {
+      content: choice.message.content || '',
+      model: response.model,
+      tokens_used: response.usage?.total_tokens,
+      finish_reason: choice.finish_reason || undefined,
+      tool_calls: choice.message.tool_calls?.map((tc: any) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments || '{}'),
+      })),
+    };
+  }
+
+  async *stream(messages: AIMessage[], tools?: PluginTool[]): AsyncGenerator<string> {
+    if (!this.client) throw new Error('OpenAI not initialized');
+
+    const model = this.config.model || 'gpt-4o';
+
+    const formattedMessages: ChatCompletionMessageParam[] = messages.map((m) => {
+      if (m.role === 'tool') {
+        return {
+          role: 'tool',
+          content: m.content,
+          tool_call_id: m.tool_call_id!,
+        };
+      } else if (m.role === 'assistant' && m.tool_calls) {
+        return {
+          role: 'assistant',
+          content: m.content || null,
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+          })),
+        };
+      }
+
+      return {
+        role: m.role as 'user' | 'assistant' | 'system',
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+      };
+    });
+
+    const requestTools: ChatCompletionTool[] | undefined = tools?.length
+      ? tools.map((t) => ({
+          type: 'function',
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema as any,
+          },
+        }))
+      : undefined;
+
+    const stream = await this.client.chat.completions.create({
+      model,
+      messages: formattedMessages,
+      max_tokens: this.config.maxTokens || 4096,
+      stream: true,
+      tools: requestTools,
+    });
+
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) {
+        yield content;
+      }
+    }
+  }
+
+  async test(): Promise<boolean> {
+    try {
+      await this.complete([{ role: 'user', content: 'Say "OK"' }]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/ai/openrouter.ts

@@ -0,0 +1,152 @@
+import OpenAI from 'openai';
+import { AIProvider, AIMessage, AIResponse } from './base.js';
+import { PluginTool } from '../plugins/manager.js';
+import { ChatCompletionMessageParam, ChatCompletionTool } from 'openai/resources/chat/completions.js';
+
+export class OpenRouterProvider extends AIProvider {
+  private client: OpenAI | null = null;
+
+  async initialize(apiKey: string): Promise<void> {
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: 'https://openrouter.ai/api/v1',
+      defaultHeaders: {
+        'HTTP-Referer': 'https://github.com/thealxlabs/conductor',
+        'X-Title': 'Conductor',
+      },
+    });
+  }
+
+  getName(): string {
+    return 'OpenRouter';
+  }
+
+  async complete(messages: AIMessage[], tools?: PluginTool[]): Promise<AIResponse> {
+    if (!this.client) throw new Error('OpenRouter not initialized');
+
+    const model = this.config.model || 'openai/gpt-4o';
+
+    const requestTools: ChatCompletionTool[] | undefined = tools?.length
+      ? tools.map((t) => ({
+          type: 'function',
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema as any,
+          },
+        }))
+      : undefined;
+
+    const formattedMessages: ChatCompletionMessageParam[] = messages.map((m) => {
+      if (m.role === 'tool') {
+        return {
+          role: 'tool',
+          content: m.content,
+          tool_call_id: m.tool_call_id!,
+        };
+      } else if (m.role === 'assistant' && m.tool_calls) {
+        return {
+          role: 'assistant',
+          content: m.content || null,
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+          })),
+        };
+      }
+      return {
+        role: m.role as 'user' | 'assistant' | 'system',
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+      };
+    });
+
+    const response = await this.client.chat.completions.create({
+      model,
+      messages: formattedMessages,
+      max_tokens: this.config.maxTokens || 4096,
+      tools: requestTools,
+    });
+
+    const choice = response.choices[0];
+
+    return {
+      content: choice.message.content || '',
+      model: response.model,
+      tokens_used: response.usage?.total_tokens,
+      finish_reason: choice.finish_reason || undefined,
+      tool_calls: choice.message.tool_calls?.map((tc: any) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments || '{}'),
+      })),
+    };
+  }
+
+  async *stream(messages: AIMessage[], tools?: PluginTool[]): AsyncGenerator<string> {
+    if (!this.client) throw new Error('OpenRouter not initialized');
+
+    const model = this.config.model || 'openai/gpt-4o';
+
+    const requestTools: ChatCompletionTool[] | undefined = tools?.length
+      ? tools.map((t) => ({
+          type: 'function',
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema as any,
+          },
+        }))
+      : undefined;
+
+    const formattedMessages: ChatCompletionMessageParam[] = messages.map((m) => {
+      if (m.role === 'tool') {
+        return {
+          role: 'tool',
+          content: m.content,
+          tool_call_id: m.tool_call_id!,
+        };
+      } else if (m.role === 'assistant' && m.tool_calls) {
+        return {
+          role: 'assistant',
+          content: m.content || null,
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+          })),
+        };
+      }
+      return {
+        role: m.role as 'user' | 'assistant' | 'system',
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+      };
+    });
+
+    const stream = await this.client.chat.completions.create({
+      model,
+      messages: formattedMessages,
+      max_tokens: this.config.maxTokens || 4096,
+      stream: true,
+      tools: requestTools,
+    });
+
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) {
+        yield content;
+      }
+    }
+  }
+
+  async test(): Promise<boolean> {
+    try {
+      await this.complete([{ role: 'user', content: 'Say "OK"' }]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/bot/README.md

@@ -0,0 +1,12 @@
+# src/bot
+
+Bot integrations for Conductor — Telegram bot and Slack Bolt app.
+
+## Contents
+
+- `telegram.ts` - Telegram bot integration
+- `slack.ts` - Slack Bolt integration
+
+## Architecture
+
+Both integrations share the same `Conductor` instance, giving them access to all plugins, AI providers, and tools. The proactive reasoning cycle runs on a timer, calling `plugin.getContext()` on each enabled plugin and feeding results to the AI manager for intelligent responses.

package/src/bot/slack.ts

@@ -0,0 +1,164 @@
+import bolt from '@slack/bolt';
+const { App } = bolt;
+import { Conductor } from '../core/conductor.js';
+import { Keychain } from '../security/keychain.js';
+import { AIManager } from '../ai/manager.js';
+
+export class SlackBot {
+  private conductor: Conductor;
+  private keychain: Keychain;
+  private app: bolt.App | null = null;
+  private aiManager: AIManager;
+
+  constructor(conductor: Conductor) {
+    this.conductor = conductor;
+    this.keychain = new Keychain(conductor.getConfig().getConfigDir());
+    this.aiManager = new AIManager(conductor);
+  }
+
+  /** Start the Slack bot. */
+  async start(): Promise<void> {
+    const botToken = await this.keychain.get('slack', 'bot_token');
+    const appToken = await this.keychain.get('slack', 'app_token');
+
+    if (!botToken || !appToken) {
+      throw new Error(
+        'Slack tokens not found. Set them in keychain (slack.bot_token, slack.app_token) or run installer.',
+      );
+    }
+
+    this.app = new App({
+      token: botToken,
+      appToken: appToken,
+      socketMode: true,
+    });
+
+    this.registerHandlers();
+
+    process.stderr.write('Slack bot starting (Socket Mode)...\n');
+    await this.app.start();
+  }
+
+  /** Register message handlers. */
+  private registerHandlers(): void {
+    if (!this.app) return;
+
+    // Default: route text messages through AI
+    this.app.message(async ({ message, say }) => {
+      // Only respond to text messages
+      if (!('text' in message) || !message.text) return;
+
+      try {
+        const userId = 'user' in message ? String(message.user) : 'unknown-slack-user';
+        const agentResponse = await this.aiManager.handleConversation(userId, message.text);
+
+        await this.sendAgentResponse(say, agentResponse);
+      } catch (error: any) {
+        process.stderr.write(`Slack AI error: ${error.message}\n`);
+        await say(`❌ Error: ${error.message}`);
+      }
+    });
+
+    // Handle approvals
+    this.app.action('approve_action', async ({ body, ack, say, respond }: any) => {
+      await ack();
+      await respond({ text: '⏳ Executing approved action...', blocks: [] });
+
+      const action = (body as any).actions[0];
+      const toolCallId = action.value;
+      const userId = body.user.id;
+
+      try {
+        const agentResponse = await this.aiManager.executeApprovedTool(userId, toolCallId);
+        await this.sendAgentResponse(say, agentResponse);
+      } catch (error: any) {
+        process.stderr.write(`Slack execute error: ${error.message}\n`);
+        await say(`❌ Error: ${error.message}`);
+      }
+    });
+
+    // Handle denials
+    this.app.action('deny_action', async ({ body, ack, say, respond }: any) => {
+      await ack();
+      await respond({ text: '🛑 Action denied. Informing AI...', blocks: [] });
+
+      const action = (body as any).actions[0];
+      const toolCallId = action.value;
+      const userId = body.user.id;
+
+      try {
+        const agentResponse = await this.aiManager.denyTool(userId, toolCallId);
+        await this.sendAgentResponse(say, agentResponse);
+      } catch (error: any) {
+        process.stderr.write(`Slack deny error: ${error.message}\n`);
+        await say(`❌ Error: ${error.message}`);
+      }
+    });
+
+    // Handle commands (Slash commands can be added here)
+    this.app.command('/conductor-status', async ({ command: _command, ack, say }) => {
+      await ack();
+      const config = this.conductor.getConfig();
+      const provider = config.get<string>('ai.provider') || 'none';
+      const plugins = config.get<string[]>('plugins.enabled') || [];
+
+      await say(
+        `📊 Status:\n` +
+          `AI: ${provider}\n` +
+          `Plugins: ${plugins.length > 0 ? plugins.join(', ') : 'none'}\n` +
+          `User: ${config.get<string>('user.name') || 'not set'}`,
+      );
+    });
+  }
+
+  private async sendAgentResponse(say: any, res: any): Promise<void> {
+    if (res.approvalRequired) {
+      const { toolCallId, toolName, arguments: args } = res.approvalRequired;
+      const text = `*⚠️ Action Requires Approval*\n\nThe AI wants to use the \`${toolName}\` tool.\n\n*Arguments:*\n\`\`\`json\n${JSON.stringify(args, null, 2)}\n\`\`\`\n\n${res.text || 'Do you approve?'}`;
+
+      await say({
+        text: 'Action Requires Approval',
+        blocks: [
+          {
+            type: 'section',
+            text: { type: 'mrkdwn', text },
+          },
+          {
+            type: 'actions',
+            elements: [
+              {
+                type: 'button',
+                text: { type: 'plain_text', text: '✅ Approve' },
+                style: 'primary',
+                value: toolCallId,
+                action_id: 'approve_action',
+              },
+              {
+                type: 'button',
+                text: { type: 'plain_text', text: '❌ Deny' },
+                style: 'danger',
+                value: toolCallId,
+                action_id: 'deny_action',
+              },
+            ],
+          },
+        ],
+      });
+    } else {
+      await say(res.text);
+    }
+  }
+
+  /** Send a proactive message to a specific channel or user. */
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    if (!this.app) throw new Error('Slack app not started');
+    await this.app.client.chat.postMessage({
+      channel: channelId,
+      text: text,
+    });
+  }
+
+  async stop(): Promise<void> {
+    await this.app?.stop();
+  }
+}