@codeany/open-agent-sdk 0.2.2 → 0.2.4

package/src/mcp/client.ts

@@ -1,150 +0,0 @@
-/**
- * MCP Client - Connect to Model Context Protocol servers
- */
-
-import type { ToolDefinition, McpServerConfig, ToolContext, ToolResult } from '../types.js'
-
-export interface MCPConnection {
-  name: string
-  status: 'connected' | 'disconnected' | 'error'
-  tools: ToolDefinition[]
-  close: () => Promise<void>
-}
-
-/**
- * Connect to an MCP server and fetch its tools.
- */
-export async function connectMCPServer(
-  name: string,
-  config: McpServerConfig,
-): Promise<MCPConnection> {
-  try {
-    const { Client } = await import('@modelcontextprotocol/sdk/client/index.js')
-
-    let transport: any
-
-    if (!config.type || config.type === 'stdio') {
-      const stdioConfig = config as { command: string; args?: string[]; env?: Record<string, string> }
-      const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js')
-      transport = new StdioClientTransport({
-        command: stdioConfig.command,
-        args: stdioConfig.args || [],
-        env: { ...process.env, ...stdioConfig.env } as Record<string, string>,
-      })
-    } else if (config.type === 'sse') {
-      const sseConfig = config as { url: string; headers?: Record<string, string> }
-      const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js')
-      transport = new SSEClientTransport(new URL(sseConfig.url), {
-        requestInit: sseConfig.headers ? { headers: sseConfig.headers } : undefined,
-      } as any)
-    } else if (config.type === 'http') {
-      const httpConfig = config as { url: string; headers?: Record<string, string> }
-      const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js')
-      transport = new StreamableHTTPClientTransport(new URL(httpConfig.url), {
-        requestInit: httpConfig.headers ? { headers: httpConfig.headers } : undefined,
-      } as any)
-    } else {
-      throw new Error(`Unsupported MCP transport type: ${(config as any).type}`)
-    }
-
-    const client = new Client(
-      { name: `agent-sdk-${name}`, version: '1.0.0' },
-      { capabilities: {} },
-    )
-
-    await client.connect(transport)
-
-    // Fetch available tools
-    const toolList = await client.listTools()
-    const tools: ToolDefinition[] = (toolList.tools || []).map((mcpTool: any) =>
-      createMCPToolDefinition(name, mcpTool, client),
-    )
-
-    return {
-      name,
-      status: 'connected',
-      tools,
-      async close() {
-        try {
-          await client.close()
-        } catch {
-          // ignore close errors
-        }
-      },
-    }
-  } catch (err: any) {
-    console.error(`[MCP] Failed to connect to "${name}": ${err.message}`)
-    return {
-      name,
-      status: 'error',
-      tools: [],
-      async close() {},
-    }
-  }
-}
-
-/**
- * Create a ToolDefinition wrapping an MCP server tool.
- */
-function createMCPToolDefinition(
-  serverName: string,
-  mcpTool: { name: string; description?: string; inputSchema?: any },
-  client: any,
-): ToolDefinition {
-  const toolName = `mcp__${serverName}__${mcpTool.name}`
-
-  return {
-    name: toolName,
-    description: mcpTool.description || `MCP tool: ${mcpTool.name} from ${serverName}`,
-    inputSchema: mcpTool.inputSchema || { type: 'object', properties: {} },
-    isReadOnly: () => false,
-    isConcurrencySafe: () => false,
-    isEnabled: () => true,
-    async prompt() {
-      return mcpTool.description || ''
-    },
-    async call(input: any): Promise<ToolResult> {
-      try {
-        const result = await client.callTool({
-          name: mcpTool.name,
-          arguments: input,
-        })
-
-        // Extract text content from MCP result
-        let output = ''
-        if (result.content) {
-          for (const block of result.content) {
-            if (block.type === 'text') {
-              output += block.text
-            } else {
-              output += JSON.stringify(block)
-            }
-          }
-        } else {
-          output = JSON.stringify(result)
-        }
-
-        return {
-          type: 'tool_result',
-          tool_use_id: '',
-          content: output,
-          is_error: result.isError || false,
-        }
-      } catch (err: any) {
-        return {
-          type: 'tool_result',
-          tool_use_id: '',
-          content: `MCP tool error: ${err.message}`,
-          is_error: true,
-        }
-      }
-    },
-  }
-}
-
-/**
- * Close all MCP connections.
- */
-export async function closeAllConnections(connections: MCPConnection[]): Promise<void> {
-  await Promise.allSettled(connections.map((c) => c.close()))
-}

package/src/providers/anthropic.ts

@@ -1,60 +0,0 @@
-/**
- * Anthropic Messages API Provider
- *
- * Wraps the @anthropic-ai/sdk client. Since our internal format is
- * Anthropic-like, this is mostly a thin pass-through.
- */
-
-import Anthropic from '@anthropic-ai/sdk'
-import type {
-  LLMProvider,
-  CreateMessageParams,
-  CreateMessageResponse,
-} from './types.js'
-
-export class AnthropicProvider implements LLMProvider {
-  readonly apiType = 'anthropic-messages' as const
-  private client: Anthropic
-
-  constructor(opts: { apiKey?: string; baseURL?: string }) {
-    this.client = new Anthropic({
-      apiKey: opts.apiKey,
-      baseURL: opts.baseURL,
-    })
-  }
-
-  async createMessage(params: CreateMessageParams): Promise<CreateMessageResponse> {
-    const requestParams: Anthropic.MessageCreateParamsNonStreaming = {
-      model: params.model,
-      max_tokens: params.maxTokens,
-      system: params.system,
-      messages: params.messages as Anthropic.MessageParam[],
-      tools: params.tools
-        ? (params.tools as Anthropic.Tool[])
-        : undefined,
-    }
-
-    // Add extended thinking if configured
-    if (params.thinking?.type === 'enabled' && params.thinking.budget_tokens) {
-      (requestParams as any).thinking = {
-        type: 'enabled',
-        budget_tokens: params.thinking.budget_tokens,
-      }
-    }
-
-    const response = await this.client.messages.create(requestParams)
-
-    return {
-      content: response.content as CreateMessageResponse['content'],
-      stopReason: response.stop_reason || 'end_turn',
-      usage: {
-        input_tokens: response.usage.input_tokens,
-        output_tokens: response.usage.output_tokens,
-        cache_creation_input_tokens:
-          (response.usage as any).cache_creation_input_tokens,
-        cache_read_input_tokens:
-          (response.usage as any).cache_read_input_tokens,
-      },
-    }
-  }
-}

package/src/providers/index.ts

@@ -1,34 +0,0 @@
-/**
- * LLM Provider Factory
- *
- * Creates the appropriate provider based on API type configuration.
- */
-
-export type { ApiType, LLMProvider, CreateMessageParams, CreateMessageResponse, NormalizedMessageParam, NormalizedContentBlock, NormalizedTool, NormalizedResponseBlock } from './types.js'
-
-export { AnthropicProvider } from './anthropic.js'
-export { OpenAIProvider } from './openai.js'
-
-import type { ApiType, LLMProvider } from './types.js'
-import { AnthropicProvider } from './anthropic.js'
-import { OpenAIProvider } from './openai.js'
-
-/**
- * Create an LLM provider based on the API type.
- *
- * @param apiType - 'anthropic-messages' or 'openai-completions'
- * @param opts - API credentials
- */
-export function createProvider(
-  apiType: ApiType,
-  opts: { apiKey?: string; baseURL?: string },
-): LLMProvider {
-  switch (apiType) {
-    case 'anthropic-messages':
-      return new AnthropicProvider(opts)
-    case 'openai-completions':
-      return new OpenAIProvider(opts)
-    default:
-      throw new Error(`Unsupported API type: ${apiType}. Use 'anthropic-messages' or 'openai-completions'.`)
-  }
-}

package/src/providers/openai.ts

@@ -1,315 +0,0 @@
-/**
- * OpenAI Chat Completions API Provider
- *
- * Converts between the SDK's internal Anthropic-like message format
- * and OpenAI's Chat Completions API format.
- *
- * Uses native fetch (no openai SDK dependency required).
- */
-
-import type {
-  LLMProvider,
-  CreateMessageParams,
-  CreateMessageResponse,
-  NormalizedMessageParam,
-  NormalizedContentBlock,
-  NormalizedTool,
-  NormalizedResponseBlock,
-} from './types.js'
-
-// --------------------------------------------------------------------------
-// OpenAI-specific types (minimal, just what we need)
-// --------------------------------------------------------------------------
-
-interface OpenAIChatMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool'
-  content?: string | null
-  tool_calls?: OpenAIToolCall[]
-  tool_call_id?: string
-}
-
-interface OpenAIToolCall {
-  id: string
-  type: 'function'
-  function: {
-    name: string
-    arguments: string
-  }
-}
-
-interface OpenAITool {
-  type: 'function'
-  function: {
-    name: string
-    description: string
-    parameters: Record<string, any>
-  }
-}
-
-interface OpenAIChatResponse {
-  id: string
-  choices: Array<{
-    index: number
-    message: {
-      role: 'assistant'
-      content: string | null
-      tool_calls?: OpenAIToolCall[]
-    }
-    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | string
-  }>
-  usage?: {
-    prompt_tokens: number
-    completion_tokens: number
-    total_tokens: number
-  }
-}
-
-// --------------------------------------------------------------------------
-// Provider
-// --------------------------------------------------------------------------
-
-export class OpenAIProvider implements LLMProvider {
-  readonly apiType = 'openai-completions' as const
-  private apiKey: string
-  private baseURL: string
-
-  constructor(opts: { apiKey?: string; baseURL?: string }) {
-    this.apiKey = opts.apiKey || ''
-    this.baseURL = (opts.baseURL || 'https://api.openai.com/v1').replace(/\/$/, '')
-  }
-
-  async createMessage(params: CreateMessageParams): Promise<CreateMessageResponse> {
-    // Convert to OpenAI format
-    const messages = this.convertMessages(params.system, params.messages)
-    const tools = params.tools ? this.convertTools(params.tools) : undefined
-
-    const body: Record<string, any> = {
-      model: params.model,
-      max_tokens: params.maxTokens,
-      messages,
-    }
-
-    if (tools && tools.length > 0) {
-      body.tools = tools
-    }
-
-    // Make API call
-    const response = await fetch(`${this.baseURL}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    })
-
-    if (!response.ok) {
-      const errBody = await response.text().catch(() => '')
-      const err: any = new Error(
-        `OpenAI API error: ${response.status} ${response.statusText}: ${errBody}`,
-      )
-      err.status = response.status
-      throw err
-    }
-
-    const data = (await response.json()) as OpenAIChatResponse
-
-    // Convert response back to normalized format
-    return this.convertResponse(data)
-  }
-
-  // --------------------------------------------------------------------------
-  // Message Conversion: Internal → OpenAI
-  // --------------------------------------------------------------------------
-
-  private convertMessages(
-    system: string,
-    messages: NormalizedMessageParam[],
-  ): OpenAIChatMessage[] {
-    const result: OpenAIChatMessage[] = []
-
-    // System prompt as first message
-    if (system) {
-      result.push({ role: 'system', content: system })
-    }
-
-    for (const msg of messages) {
-      if (msg.role === 'user') {
-        this.convertUserMessage(msg, result)
-      } else if (msg.role === 'assistant') {
-        this.convertAssistantMessage(msg, result)
-      }
-    }
-
-    return result
-  }
-
-  private convertUserMessage(
-    msg: NormalizedMessageParam,
-    result: OpenAIChatMessage[],
-  ): void {
-    if (typeof msg.content === 'string') {
-      result.push({ role: 'user', content: msg.content })
-      return
-    }
-
-    // Content blocks may contain text and/or tool_result blocks
-    const textParts: string[] = []
-    const toolResults: Array<{ tool_use_id: string; content: string }> = []
-
-    for (const block of msg.content) {
-      if (block.type === 'text') {
-        textParts.push(block.text)
-      } else if (block.type === 'tool_result') {
-        toolResults.push({
-          tool_use_id: block.tool_use_id,
-          content: block.content,
-        })
-      }
-    }
-
-    // Tool results become separate tool messages
-    for (const tr of toolResults) {
-      result.push({
-        role: 'tool',
-        tool_call_id: tr.tool_use_id,
-        content: tr.content,
-      })
-    }
-
-    // Text parts become a user message
-    if (textParts.length > 0) {
-      result.push({ role: 'user', content: textParts.join('\n') })
-    }
-  }
-
-  private convertAssistantMessage(
-    msg: NormalizedMessageParam,
-    result: OpenAIChatMessage[],
-  ): void {
-    if (typeof msg.content === 'string') {
-      result.push({ role: 'assistant', content: msg.content })
-      return
-    }
-
-    // Extract text and tool_use blocks
-    const textParts: string[] = []
-    const toolCalls: OpenAIToolCall[] = []
-
-    for (const block of msg.content) {
-      if (block.type === 'text') {
-        textParts.push(block.text)
-      } else if (block.type === 'tool_use') {
-        toolCalls.push({
-          id: block.id,
-          type: 'function',
-          function: {
-            name: block.name,
-            arguments: typeof block.input === 'string'
-              ? block.input
-              : JSON.stringify(block.input),
-          },
-        })
-      }
-    }
-
-    const assistantMsg: OpenAIChatMessage = {
-      role: 'assistant',
-      content: textParts.length > 0 ? textParts.join('\n') : null,
-    }
-
-    if (toolCalls.length > 0) {
-      assistantMsg.tool_calls = toolCalls
-    }
-
-    result.push(assistantMsg)
-  }
-
-  // --------------------------------------------------------------------------
-  // Tool Conversion: Internal → OpenAI
-  // --------------------------------------------------------------------------
-
-  private convertTools(tools: NormalizedTool[]): OpenAITool[] {
-    return tools.map((t) => ({
-      type: 'function' as const,
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.input_schema,
-      },
-    }))
-  }
-
-  // --------------------------------------------------------------------------
-  // Response Conversion: OpenAI → Internal
-  // --------------------------------------------------------------------------
-
-  private convertResponse(data: OpenAIChatResponse): CreateMessageResponse {
-    const choice = data.choices[0]
-    if (!choice) {
-      return {
-        content: [{ type: 'text', text: '' }],
-        stopReason: 'end_turn',
-        usage: { input_tokens: 0, output_tokens: 0 },
-      }
-    }
-
-    const content: NormalizedResponseBlock[] = []
-
-    // Add text content
-    if (choice.message.content) {
-      content.push({ type: 'text', text: choice.message.content })
-    }
-
-    // Add tool calls
-    if (choice.message.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
-        let input: any
-        try {
-          input = JSON.parse(tc.function.arguments)
-        } catch {
-          input = tc.function.arguments
-        }
-
-        content.push({
-          type: 'tool_use',
-          id: tc.id,
-          name: tc.function.name,
-          input,
-        })
-      }
-    }
-
-    // If no content at all, add empty text
-    if (content.length === 0) {
-      content.push({ type: 'text', text: '' })
-    }
-
-    // Map finish_reason to our normalized stop reasons
-    const stopReason = this.mapFinishReason(choice.finish_reason)
-
-    return {
-      content,
-      stopReason,
-      usage: {
-        input_tokens: data.usage?.prompt_tokens || 0,
-        output_tokens: data.usage?.completion_tokens || 0,
-      },
-    }
-  }
-
-  private mapFinishReason(
-    reason: string,
-  ): 'end_turn' | 'max_tokens' | 'tool_use' | string {
-    switch (reason) {
-      case 'stop':
-        return 'end_turn'
-      case 'length':
-        return 'max_tokens'
-      case 'tool_calls':
-        return 'tool_use'
-      default:
-        return reason
-    }
-  }
-}

package/src/providers/types.ts

@@ -1,85 +0,0 @@
-/**
- * LLM Provider Abstraction Types
- *
- * Defines a provider interface that normalizes API differences between
- * Anthropic Messages API and OpenAI Chat Completions API.
- *
- * Internally the SDK uses Anthropic-like message format as the canonical
- * representation. Providers convert to/from their native API format.
- */
-
-// --------------------------------------------------------------------------
-// API Type
-// --------------------------------------------------------------------------
-
-export type ApiType = 'anthropic-messages' | 'openai-completions'
-
-// --------------------------------------------------------------------------
-// Normalized Request
-// --------------------------------------------------------------------------
-
-export interface CreateMessageParams {
-  model: string
-  maxTokens: number
-  system: string
-  messages: NormalizedMessageParam[]
-  tools?: NormalizedTool[]
-  thinking?: { type: string; budget_tokens?: number }
-}
-
-/**
- * Normalized message format (Anthropic-like).
- * This is the internal representation used throughout the SDK.
- */
-export interface NormalizedMessageParam {
-  role: 'user' | 'assistant'
-  content: string | NormalizedContentBlock[]
-}
-
-export type NormalizedContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'tool_use'; id: string; name: string; input: any }
-  | { type: 'tool_result'; tool_use_id: string; content: string; is_error?: boolean }
-  | { type: 'image'; source: any }
-  | { type: 'thinking'; thinking: string }
-
-export interface NormalizedTool {
-  name: string
-  description: string
-  input_schema: {
-    type: 'object'
-    properties: Record<string, any>
-    required?: string[]
-  }
-}
-
-// --------------------------------------------------------------------------
-// Normalized Response
-// --------------------------------------------------------------------------
-
-export interface CreateMessageResponse {
-  content: NormalizedResponseBlock[]
-  stopReason: 'end_turn' | 'max_tokens' | 'tool_use' | string
-  usage: {
-    input_tokens: number
-    output_tokens: number
-    cache_creation_input_tokens?: number
-    cache_read_input_tokens?: number
-  }
-}
-
-export type NormalizedResponseBlock =
-  | { type: 'text'; text: string }
-  | { type: 'tool_use'; id: string; name: string; input: any }
-
-// --------------------------------------------------------------------------
-// Provider Interface
-// --------------------------------------------------------------------------
-
-export interface LLMProvider {
-  /** The API type this provider implements. */
-  readonly apiType: ApiType
-
-  /** Send a message and get a response. */
-  createMessage(params: CreateMessageParams): Promise<CreateMessageResponse>
-}