@metabob/minibob 0.1.2

package/src/llm.ts

@@ -0,0 +1,434 @@
+/**
+ * minibob LLM Client
+ * 
+ * Minimal LLM integration supporting Anthropic Claude.
+ * Handles tool calling loop for activity execution.
+ */
+
+import type {
+  CompletionOptions,
+  CompletionResult,
+  ToolResult,
+  ToolHandler,
+} from "./types"
+
+// =============================================================================
+// LLM CLIENT
+// =============================================================================
+
+export interface LLMClient {
+  complete(options: CompletionOptions): Promise<CompletionResult>
+  completeWithTools(
+    options: CompletionOptions,
+    toolHandlers: Record<string, ToolHandler>
+  ): Promise<{ content: string; toolsUsed: string[]; usage: { inputTokens: number; outputTokens: number } }>
+}
+
+/**
+ * Create Anthropic LLM client
+ */
+export function createAnthropicClient(apiKey: string): LLMClient {
+  const baseUrl = "https://api.anthropic.com/v1"
+
+  async function complete(options: CompletionOptions): Promise<CompletionResult> {
+    // Convert messages to Anthropic format
+    const systemMessage = options.messages.find((m) => m.role === "system")
+    const conversationMessages = options.messages
+      .filter((m) => m.role !== "system")
+      .map((m) => {
+        // Tool result message
+        if (m.role === "tool") {
+          return {
+            role: "user" as const,
+            content: [
+              {
+                type: "tool_result" as const,
+                tool_use_id: m.toolCallId!,
+                content: m.content,
+              },
+            ],
+          }
+        }
+        
+        // Assistant message with tool calls
+        if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+          const content: Array<any> = []
+          
+          // Add text content if present
+          if (m.content) {
+            content.push({ type: "text", text: m.content })
+          }
+          
+          // Add tool_use blocks
+          for (const toolCall of m.toolCalls) {
+            content.push({
+              type: "tool_use",
+              id: toolCall.id,
+              name: toolCall.name,
+              input: toolCall.arguments,
+            })
+          }
+          
+          return {
+            role: "assistant" as const,
+            content,
+          }
+        }
+        
+        // Regular message
+        return {
+          role: m.role,
+          content: m.content,
+        }
+      })
+
+    // Convert tools to Anthropic format
+    const tools = options.tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters,
+    }))
+
+    const body: Record<string, unknown> = {
+      model: options.model,
+      max_tokens: options.maxTokens ?? 4096,
+      messages: conversationMessages,
+    }
+
+    if (systemMessage) {
+      body.system = systemMessage.content
+    }
+
+    if (tools && tools.length > 0) {
+      body.tools = tools
+    }
+
+    if (options.temperature !== undefined) {
+      body.temperature = options.temperature
+    }
+
+    const response = await fetch(`${baseUrl}/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`)
+    }
+
+    const data = (await response.json()) as {
+      content: Array<{ type: string; text?: string; id?: string; name?: string; input?: Record<string, unknown> }>
+      stop_reason: string
+      usage: { input_tokens: number; output_tokens: number }
+    }
+
+    // Extract content and tool calls
+    let content = ""
+    const toolCalls: Array<{ id: string; name: string; arguments: Record<string, unknown> }> = []
+
+    for (const block of data.content) {
+      if (block.type === "text" && block.text) {
+        content += block.text
+      } else if (block.type === "tool_use" && block.id && block.name) {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input ?? {},
+        })
+      }
+    }
+
+    return {
+      content,
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      finishReason: data.stop_reason === "end_turn" ? "stop" : data.stop_reason === "tool_use" ? "tool_calls" : "stop",
+      usage: {
+        inputTokens: data.usage.input_tokens,
+        outputTokens: data.usage.output_tokens,
+      },
+    }
+  }
+
+  async function completeWithTools(
+    options: CompletionOptions,
+    toolHandlers: Record<string, ToolHandler>
+  ): Promise<{ content: string; toolsUsed: string[]; usage: { inputTokens: number; outputTokens: number } }> {
+    const messages = [...options.messages]
+    const toolsUsed: string[] = []
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+    let finalContent = ""
+    let maxIterations = 20 // Prevent infinite loops
+
+    while (maxIterations-- > 0) {
+      const result = await complete({
+        ...options,
+        messages,
+      })
+
+      totalInputTokens += result.usage.inputTokens
+      totalOutputTokens += result.usage.outputTokens
+
+      // If no tool calls, we're done
+      if (!result.toolCalls || result.toolCalls.length === 0) {
+        finalContent = result.content
+        break
+      }
+
+      // Add assistant message with tool calls
+      messages.push({
+        role: "assistant",
+        content: result.content,
+        toolCalls: result.toolCalls,
+      })
+
+      // Execute tool calls
+      for (const toolCall of result.toolCalls) {
+        const handler = toolHandlers[toolCall.name]
+        let toolResult: ToolResult
+
+        if (!handler) {
+          toolResult = {
+            success: false,
+            error: `Unknown tool: ${toolCall.name}`,
+          }
+        } else {
+          try {
+            toolResult = await handler(toolCall.arguments)
+            toolsUsed.push(toolCall.name)
+          } catch (error) {
+            toolResult = {
+              success: false,
+              error: error instanceof Error ? error.message : String(error),
+            }
+          }
+        }
+
+        // Add tool result message
+        messages.push({
+          role: "tool",
+          content: toolResult.success
+            ? toolResult.output ?? "Success"
+            : `Error: ${toolResult.error}`,
+          toolCallId: toolCall.id,
+        })
+      }
+    }
+
+    return {
+      content: finalContent,
+      toolsUsed: [...new Set(toolsUsed)],
+      usage: {
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+      },
+    }
+  }
+
+  return { complete, completeWithTools }
+}
+
+/**
+ * Create OpenAI-compatible LLM client
+ */
+export function createOpenAIClient(apiKey: string, baseUrl = "https://api.openai.com/v1"): LLMClient {
+  async function complete(options: CompletionOptions): Promise<CompletionResult> {
+    // Convert messages to OpenAI format
+    const messages = options.messages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "tool" as const,
+          tool_call_id: m.toolCallId,
+          content: m.content,
+        }
+      }
+      if (m.role === "assistant" && m.toolCalls) {
+        return {
+          role: "assistant" as const,
+          content: m.content || null,
+          tool_calls: m.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function" as const,
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.arguments),
+            },
+          })),
+        }
+      }
+      return {
+        role: m.role,
+        content: m.content,
+      }
+    })
+
+    // Convert tools to OpenAI format
+    const tools = options.tools?.map((t) => ({
+      type: "function" as const,
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+      },
+    }))
+
+    const body: Record<string, unknown> = {
+      model: options.model,
+      messages,
+      max_tokens: options.maxTokens ?? 4096,
+    }
+
+    if (tools && tools.length > 0) {
+      body.tools = tools
+    }
+
+    if (options.temperature !== undefined) {
+      body.temperature = options.temperature
+    }
+
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`)
+    }
+
+    const data = (await response.json()) as {
+      choices: Array<{
+        message: {
+          content: string | null
+          tool_calls?: Array<{
+            id: string
+            function: { name: string; arguments: string }
+          }>
+        }
+        finish_reason: string
+      }>
+      usage: { prompt_tokens: number; completion_tokens: number }
+    }
+
+    const choice = data.choices[0]
+    if (!choice) {
+      throw new Error("No response from OpenAI API")
+    }
+    const toolCalls = choice.message.tool_calls?.map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: JSON.parse(tc.function.arguments) as Record<string, unknown>,
+    }))
+
+    return {
+      content: choice.message.content ?? "",
+      toolCalls,
+      finishReason:
+        choice.finish_reason === "stop"
+          ? "stop"
+          : choice.finish_reason === "tool_calls"
+          ? "tool_calls"
+          : "stop",
+      usage: {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: data.usage.completion_tokens,
+      },
+    }
+  }
+
+  async function completeWithTools(
+    options: CompletionOptions,
+    toolHandlers: Record<string, ToolHandler>
+  ): Promise<{ content: string; toolsUsed: string[]; usage: { inputTokens: number; outputTokens: number } }> {
+    const messages = [...options.messages]
+    const toolsUsed: string[] = []
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+    let finalContent = ""
+    let maxIterations = 20
+
+    while (maxIterations-- > 0) {
+      const result = await complete({
+        ...options,
+        messages,
+      })
+
+      totalInputTokens += result.usage.inputTokens
+      totalOutputTokens += result.usage.outputTokens
+
+      if (!result.toolCalls || result.toolCalls.length === 0) {
+        finalContent = result.content
+        break
+      }
+
+      messages.push({
+        role: "assistant",
+        content: result.content,
+        toolCalls: result.toolCalls,
+      })
+
+      for (const toolCall of result.toolCalls) {
+        const handler = toolHandlers[toolCall.name]
+        let toolResult: ToolResult
+
+        if (!handler) {
+          toolResult = {
+            success: false,
+            error: `Unknown tool: ${toolCall.name}`,
+          }
+        } else {
+          try {
+            toolResult = await handler(toolCall.arguments)
+            toolsUsed.push(toolCall.name)
+          } catch (error) {
+            toolResult = {
+              success: false,
+              error: error instanceof Error ? error.message : String(error),
+            }
+          }
+        }
+
+        messages.push({
+          role: "tool",
+          content: toolResult.success ? toolResult.output ?? "Success" : `Error: ${toolResult.error}`,
+          toolCallId: toolCall.id,
+        })
+      }
+    }
+
+    return {
+      content: finalContent,
+      toolsUsed: [...new Set(toolsUsed)],
+      usage: {
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+      },
+    }
+  }
+
+  return { complete, completeWithTools }
+}
+
+/**
+ * Create LLM client based on provider
+ */
+export function createLLMClient(provider: "anthropic" | "openai", apiKey: string): LLMClient {
+  switch (provider) {
+    case "anthropic":
+      return createAnthropicClient(apiKey)
+    case "openai":
+      return createOpenAIClient(apiKey)
+    default:
+      throw new Error(`Unknown provider: ${provider}`)
+  }
+}

package/src/mcp-activity-bridge.ts

@@ -0,0 +1,158 @@
+/**
+ * MCP Activity Bridge
+ * 
+ * Bridges MiniBob's activity callbacks to Metabob MCP tools.
+ * 
+ * Architecture:
+ * - MiniBob activity.ts defines callbacks (onSearchActivities, onCreateActivity)
+ * - This bridge translates those callbacks to MCP tool calls
+ * - MCP tools (in metabob-cli Python) delegate to RPC API
+ * - RPC API handles Thompson Sampling and learning (NOT OpenCode)
+ * 
+ * Specification: minibob-trailblazing-activity-system
+ * Compliance: Activity-first constraint enforcement
+ */
+
+import { getMCPClient } from "./mcp"
+
+export namespace MCPActivityBridge {
+  /**
+   * Search activities via /v2/activities/templates endpoint.
+   *
+   * This implements the onSearchActivities callback expected by MiniBob tools.
+   *
+   * @param category Optional category filter (feature, bugfix, refactor, tool, infrastructure)
+   * @param verbose If true, return full template details; if false, return minimal info
+   * @returns Activity search results
+   */
+  export async function searchActivities(
+    category?: string,
+    _verbose?: boolean // Reserved for future use
+  ): Promise<{ count: number; activities: unknown[] }> {
+    const mcp = getMCPClient()
+    
+    if (!mcp) {
+      console.warn("[MCPActivityBridge] MCP not available, returning empty results")
+      return { count: 0, activities: [] }
+    }
+
+    try {
+      // Call the /v2/activities/templates endpoint directly
+      const params = new URLSearchParams()
+      if (category) params.set("category", category)
+      params.set("limit", "50")
+
+      const url = `/v2/activities/templates?${params.toString()}`
+      const response = await mcp["request"]("GET", url)
+
+      if (!response.ok) {
+        throw new Error(`MCP search failed: ${response.status} ${response.statusText}`)
+      }
+
+      const result = await response.json() as {
+        templates?: unknown[]
+        total?: number
+        error?: string
+        message?: string
+      }
+
+      if (result.error) {
+        console.error("[MCPActivityBridge] Search error:", result.error)
+        return { count: 0, activities: [] }
+      }
+
+      return {
+        count: result.total ?? (result.templates?.length ?? 0),
+        activities: result.templates ?? [],
+      }
+    } catch (error) {
+      console.error("[MCPActivityBridge] Search activities failed:", error)
+      return { count: 0, activities: [] }
+    }
+  }
+
+  /**
+   * Create activity via metabob_create_activity_goal_seeking MCP tool.
+   * 
+   * This implements the onCreateActivity callback expected by MiniBob tools.
+   * 
+   * Architecture Note:
+   * - This delegates to MCP tool (metabob_create_activity_goal_seeking)
+   * - MCP tool calls RPC API /v2/activities/create-goal-seeking
+   * - RPC API handles:
+   *   - Thompson Sampling initialization (NOT OpenCode)
+   *   - Goal decomposition
+   *   - Template registration
+   * 
+   * @param params Goal seeking parameters
+   * @returns Created template ID
+   */
+  export async function createActivity(params: {
+    goalDescription: string
+    templateName: string
+    category: string
+    variables: Record<string, unknown>
+    impulseRefs?: string[]
+    constraints?: {
+      maxTasks?: number
+      maxCost?: number
+      preferComposition?: boolean
+    }
+  }): Promise<{ templateId: string }> {
+    const mcp = getMCPClient()
+    
+    if (!mcp) {
+      throw new Error("MCP not available - cannot create activity template")
+    }
+
+    try {
+      // Call backend create-goal-seeking API
+      const response = await mcp["request"]("POST", "/v2/activities/create-goal-seeking", {
+        goal_description: params.goalDescription,
+        template_name: params.templateName,
+        category: params.category,
+        variables: params.variables,
+        impulse_refs: params.impulseRefs ?? [],
+        constraints: params.constraints ?? {
+          max_tasks: 7,
+          max_cost: 5.0,
+          prefer_composition: true,
+        },
+      })
+
+      if (!response.ok) {
+        throw new Error(`MCP create activity failed: ${response.status} ${response.statusText}`)
+      }
+
+      const result = await response.json() as {
+        status: string
+        template_id?: string
+        error?: string
+      }
+
+      if (result.status !== "success" || !result.template_id) {
+        throw new Error(`Failed to create activity: ${result.error ?? "Unknown error"}`)
+      }
+
+      console.log(
+        `[MCPActivityBridge] Created activity template: ${result.template_id} via goal-seeking`
+      )
+
+      return {
+        templateId: result.template_id,
+      }
+    } catch (error) {
+      console.error("[MCPActivityBridge] Create activity failed:", error)
+      throw error
+    }
+  }
+
+  /**
+   * Check if MCP activity bridge is available.
+   * 
+   * Returns true if MCP client is initialized and bridge can be used.
+   */
+  export function isAvailable(): boolean {
+    return getMCPClient() !== null
+  }
+}