@codeany/open-agent-sdk 0.1.0

package/src/mcp/client.ts

@@ -0,0 +1,150 @@
+/**
+ * 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/sdk-mcp-server.ts

@@ -0,0 +1,78 @@
+/**
+ * In-Process MCP Server
+ *
+ * createSdkMcpServer() creates an in-process MCP server from tool() definitions.
+ * Compatible with open-agent-sdk's createSdkMcpServer().
+ *
+ * Usage:
+ *   import { tool, createSdkMcpServer } from 'open-agent-sdk'
+ *   import { z } from 'zod'
+ *
+ *   const weatherTool = tool('get_weather', 'Get weather', { city: z.string() },
+ *     async ({ city }) => ({ content: [{ type: 'text', text: `22°C in ${city}` }] })
+ *   )
+ *
+ *   const server = createSdkMcpServer({
+ *     name: 'weather',
+ *     tools: [weatherTool],
+ *   })
+ *
+ *   // Use as MCP server config:
+ *   const agent = createAgent({
+ *     mcpServers: { weather: server },
+ *   })
+ */
+
+import type { SdkMcpToolDefinition } from './tool-helper.js'
+import { sdkToolToToolDefinition } from './tool-helper.js'
+import type { ToolDefinition, McpServerConfig } from './types.js'
+
+/**
+ * SDK MCP server config that includes the in-process server instance.
+ */
+export interface McpSdkServerConfig {
+  type: 'sdk'
+  name: string
+  version: string
+  tools: ToolDefinition[]
+  _sdkTools: SdkMcpToolDefinition<any>[]
+}
+
+/**
+ * Create an in-process MCP server from tool definitions.
+ *
+ * The server runs in the same process as the agent, avoiding
+ * subprocess overhead. Tools are directly callable.
+ */
+export function createSdkMcpServer(options: {
+  name: string
+  version?: string
+  tools?: SdkMcpToolDefinition<any>[]
+}): McpSdkServerConfig {
+  const sdkTools = options.tools || []
+
+  // Convert SDK tools to engine-compatible tool definitions
+  // Prefix tool names with mcp__{server_name}__ for namespace isolation
+  const toolDefinitions: ToolDefinition[] = sdkTools.map((sdkTool) => {
+    const toolDef = sdkToolToToolDefinition(sdkTool)
+    return {
+      ...toolDef,
+      name: `mcp__${options.name}__${sdkTool.name}`,
+    }
+  })
+
+  return {
+    type: 'sdk',
+    name: options.name,
+    version: options.version || '1.0.0',
+    tools: toolDefinitions,
+    _sdkTools: sdkTools,
+  }
+}
+
+/**
+ * Check if a server config is an in-process SDK server.
+ */
+export function isSdkServerConfig(config: any): config is McpSdkServerConfig {
+  return config?.type === 'sdk' && Array.isArray(config.tools)
+}

package/src/session.ts

@@ -0,0 +1,227 @@
+/**
+ * Session Storage & Management
+ *
+ * Persists conversation transcripts to disk for resumption.
+ * Manages session lifecycle (create, resume, list, fork).
+ */
+
+import { readFile, writeFile, mkdir, readdir, stat } from 'fs/promises'
+import { join } from 'path'
+import type { Message } from './types.js'
+import type Anthropic from '@anthropic-ai/sdk'
+
+/**
+ * Session metadata.
+ */
+export interface SessionMetadata {
+  id: string
+  cwd: string
+  model: string
+  createdAt: string
+  updatedAt: string
+  messageCount: number
+  summary?: string
+}
+
+/**
+ * Session data on disk.
+ */
+export interface SessionData {
+  metadata: SessionMetadata
+  messages: Anthropic.MessageParam[]
+}
+
+/**
+ * Get the sessions directory path.
+ */
+function getSessionsDir(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || '/tmp'
+  return join(home, '.open-agent-sdk', 'sessions')
+}
+
+/**
+ * Get the path for a specific session.
+ */
+function getSessionPath(sessionId: string): string {
+  return join(getSessionsDir(), sessionId)
+}
+
+/**
+ * Save session to disk.
+ */
+export async function saveSession(
+  sessionId: string,
+  messages: Anthropic.MessageParam[],
+  metadata: Partial<SessionMetadata>,
+): Promise<void> {
+  const dir = getSessionPath(sessionId)
+  await mkdir(dir, { recursive: true })
+
+  const data: SessionData = {
+    metadata: {
+      id: sessionId,
+      cwd: metadata.cwd || process.cwd(),
+      model: metadata.model || 'claude-sonnet-4-6',
+      createdAt: metadata.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      messageCount: messages.length,
+      summary: metadata.summary,
+    },
+    messages,
+  }
+
+  await writeFile(
+    join(dir, 'transcript.json'),
+    JSON.stringify(data, null, 2),
+    'utf-8',
+  )
+}
+
+/**
+ * Load session from disk.
+ */
+export async function loadSession(sessionId: string): Promise<SessionData | null> {
+  try {
+    const filePath = join(getSessionPath(sessionId), 'transcript.json')
+    const content = await readFile(filePath, 'utf-8')
+    return JSON.parse(content) as SessionData
+  } catch {
+    return null
+  }
+}
+
+/**
+ * List all sessions.
+ */
+export async function listSessions(): Promise<SessionMetadata[]> {
+  try {
+    const dir = getSessionsDir()
+    const entries = await readdir(dir)
+    const sessions: SessionMetadata[] = []
+
+    for (const entry of entries) {
+      try {
+        const data = await loadSession(entry)
+        if (data?.metadata) {
+          sessions.push(data.metadata)
+        }
+      } catch {
+        // Skip invalid sessions
+      }
+    }
+
+    // Sort by updatedAt descending
+    sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+
+    return sessions
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Fork a session (create a copy with a new ID).
+ */
+export async function forkSession(
+  sourceSessionId: string,
+  newSessionId?: string,
+): Promise<string | null> {
+  const data = await loadSession(sourceSessionId)
+  if (!data) return null
+
+  const forkId = newSessionId || crypto.randomUUID()
+
+  await saveSession(forkId, data.messages, {
+    ...data.metadata,
+    id: forkId,
+    createdAt: new Date().toISOString(),
+    summary: `Forked from session ${sourceSessionId}`,
+  })
+
+  return forkId
+}
+
+/**
+ * Get session messages.
+ */
+export async function getSessionMessages(
+  sessionId: string,
+): Promise<Anthropic.MessageParam[]> {
+  const data = await loadSession(sessionId)
+  return data?.messages || []
+}
+
+/**
+ * Append a message to a session transcript.
+ */
+export async function appendToSession(
+  sessionId: string,
+  message: Anthropic.MessageParam,
+): Promise<void> {
+  const data = await loadSession(sessionId)
+  if (!data) return
+
+  data.messages.push(message)
+  data.metadata.updatedAt = new Date().toISOString()
+  data.metadata.messageCount = data.messages.length
+
+  await saveSession(sessionId, data.messages, data.metadata)
+}
+
+/**
+ * Delete a session.
+ */
+export async function deleteSession(sessionId: string): Promise<boolean> {
+  try {
+    const { rm } = await import('fs/promises')
+    await rm(getSessionPath(sessionId), { recursive: true, force: true })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get info about a specific session.
+ */
+export async function getSessionInfo(
+  sessionId: string,
+  options?: { dir?: string },
+): Promise<SessionMetadata | null> {
+  const data = await loadSession(sessionId)
+  return data?.metadata || null
+}
+
+/**
+ * Rename a session.
+ */
+export async function renameSession(
+  sessionId: string,
+  title: string,
+  options?: { dir?: string },
+): Promise<void> {
+  const data = await loadSession(sessionId)
+  if (!data) return
+
+  data.metadata.summary = title
+  data.metadata.updatedAt = new Date().toISOString()
+
+  await saveSession(sessionId, data.messages, data.metadata)
+}
+
+/**
+ * Tag a session.
+ */
+export async function tagSession(
+  sessionId: string,
+  tag: string | null,
+  options?: { dir?: string },
+): Promise<void> {
+  const data = await loadSession(sessionId)
+  if (!data) return
+
+  ;(data.metadata as any).tag = tag
+  data.metadata.updatedAt = new Date().toISOString()
+
+  await saveSession(sessionId, data.messages, data.metadata)
+}

package/src/tool-helper.ts

@@ -0,0 +1,127 @@
+/**
+ * tool() helper - Create tools using Zod schemas
+ *
+ * Compatible with open-agent-sdk's tool() function.
+ *
+ * Usage:
+ *   import { tool } from 'open-agent-sdk'
+ *   import { z } from 'zod'
+ *
+ *   const weatherTool = tool(
+ *     'get_weather',
+ *     'Get weather for a city',
+ *     { city: z.string().describe('City name') },
+ *     async ({ city }) => {
+ *       return { content: [{ type: 'text', text: `Weather in ${city}: 22°C` }] }
+ *     }
+ *   )
+ */
+
+import { z, type ZodRawShape, type ZodObject } from 'zod'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import type { ToolDefinition, ToolResult, ToolContext } from './types.js'
+
+/**
+ * Tool annotations (MCP standard).
+ */
+export interface ToolAnnotations {
+  readOnlyHint?: boolean
+  destructiveHint?: boolean
+  idempotentHint?: boolean
+  openWorldHint?: boolean
+}
+
+/**
+ * Tool call result (MCP-compatible).
+ */
+export interface CallToolResult {
+  content: Array<
+    | { type: 'text'; text: string }
+    | { type: 'image'; data: string; mimeType: string }
+    | { type: 'resource'; resource: { uri: string; text?: string; blob?: string } }
+  >
+  isError?: boolean
+}
+
+/**
+ * SDK MCP tool definition.
+ */
+export interface SdkMcpToolDefinition<T extends ZodRawShape = ZodRawShape> {
+  name: string
+  description: string
+  inputSchema: ZodObject<T>
+  handler: (args: z.infer<ZodObject<T>>, extra: unknown) => Promise<CallToolResult>
+  annotations?: ToolAnnotations
+}
+
+/**
+ * Create a tool using Zod schema.
+ *
+ * Compatible with open-agent-sdk's tool() function.
+ */
+export function tool<T extends ZodRawShape>(
+  name: string,
+  description: string,
+  inputSchema: T,
+  handler: (args: z.infer<ZodObject<T>>, extra: unknown) => Promise<CallToolResult>,
+  extras?: { annotations?: ToolAnnotations },
+): SdkMcpToolDefinition<T> {
+  return {
+    name,
+    description,
+    inputSchema: z.object(inputSchema),
+    handler,
+    annotations: extras?.annotations,
+  }
+}
+
+/**
+ * Convert an SdkMcpToolDefinition to a ToolDefinition for the engine.
+ */
+export function sdkToolToToolDefinition(sdkTool: SdkMcpToolDefinition<any>): ToolDefinition {
+  const jsonSchema = zodToJsonSchema(sdkTool.inputSchema, { target: 'openApi3' }) as any
+
+  return {
+    name: sdkTool.name,
+    description: sdkTool.description,
+    inputSchema: {
+      type: 'object',
+      properties: jsonSchema.properties || {},
+      required: jsonSchema.required || [],
+    },
+    isReadOnly: () => sdkTool.annotations?.readOnlyHint ?? false,
+    isConcurrencySafe: () => sdkTool.annotations?.readOnlyHint ?? false,
+    isEnabled: () => true,
+    async prompt() { return sdkTool.description },
+    async call(input: any, _context: ToolContext): Promise<ToolResult> {
+      try {
+        const parsed = sdkTool.inputSchema.parse(input)
+        const result = await sdkTool.handler(parsed, {})
+
+        // Convert MCP content blocks to string
+        const text = result.content
+          .map((block) => {
+            if (block.type === 'text') return block.text
+            if (block.type === 'image') return `[Image: ${block.mimeType}]`
+            if (block.type === 'resource') return block.resource.text || `[Resource: ${block.resource.uri}]`
+            return JSON.stringify(block)
+          })
+          .join('\n')
+
+        return {
+          type: 'tool_result',
+          tool_use_id: '',
+          content: text,
+          is_error: result.isError || false,
+        }
+      } catch (err: any) {
+        return {
+          type: 'tool_result',
+          tool_use_id: '',
+          content: `Error: ${err.message}`,
+          is_error: true,
+        }
+      }
+    },
+  }
+}