ydc-agent 1.0.0

package/lib/advanced-versions.js

@@ -0,0 +1,113 @@
+/**
+ * Advanced Agent Version System
+ * Provides specialized configurations for different use cases
+ */
+
+export const ADVANCED_VERSIONS = {
+  'advanced-1.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 1,
+    timeout: 120000,
+    tools: []
+  },
+  'advanced-1.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 1,
+    timeout: 120000,
+    tools: []
+  },
+  'advanced-2.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 2,
+    timeout: 180000,
+    tools: []
+  },
+  'advanced-2.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 2,
+    timeout: 180000,
+    tools: []
+  },
+  'advanced-3.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 5,
+    timeout: 180000,
+    tools: [{ type: 'compute' }]
+  },
+  'advanced-3.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 5,
+    timeout: 180000,
+    tools: [{ type: 'compute' }]
+  },
+  'advanced-4.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 6,
+    timeout: 180000,
+    tools: [{ type: 'research', search_effort: 'medium', report_verbosity: 'medium' }]
+  },
+  'advanced-4.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 6,
+    timeout: 180000,
+    tools: [{ type: 'research', search_effort: 'high', report_verbosity: 'high' }]
+  },
+  'advanced-4.5-medium-research': {
+    verbosity: 'medium',
+    max_workflow_steps: 9,
+    timeout: 300000,
+    tools: [
+      { type: 'compute' },
+      { type: 'research', search_effort: 'medium', report_verbosity: 'medium' }
+    ]
+  },
+  'advanced-4.5-high-research': {
+    verbosity: 'high',
+    max_workflow_steps: 9,
+    timeout: 300000,
+    tools: [
+      { type: 'compute' },
+      { type: 'research', search_effort: 'high', report_verbosity: 'high' }
+    ]
+  }
+};
+
+export function getAdvancedVersion(versionName) {
+  return ADVANCED_VERSIONS[versionName] || null;
+}
+
+export function isAdvancedVersion(modelName) {
+  return modelName in ADVANCED_VERSIONS;
+}
+
+export function getDefaultAdvancedVersion(temperature = 0.7) {
+  return temperature <= 0.5 ? 'advanced-3.0-medium' : 'advanced-3.0-high';
+}
+
+export function adjustWorkflowSteps(baseSteps, temperature) {
+  const adjustment = Math.round((temperature - 0.5) * 4);
+  return Math.max(1, Math.min(20, baseSteps + adjustment));
+}
+
+export function listAdvancedVersions() {
+  return Object.keys(ADVANCED_VERSIONS);
+}
+
+export function getVersionInfo(versionName) {
+  const config = ADVANCED_VERSIONS[versionName];
+  if (!config) return null;
+  
+  const toolNames = config.tools.map(t => {
+    if (t.type === 'research') return `research(${t.search_effort})`;
+    return t.type;
+  }).join(', ') || 'none';
+
+  return {
+    name: versionName,
+    verbosity: config.verbosity,
+    max_workflow_steps: config.max_workflow_steps,
+    timeout_seconds: config.timeout / 1000,
+    tools: toolNames,
+    description: `${config.verbosity} verbosity, ${config.max_workflow_steps} steps, ${config.timeout/1000}s timeout`
+  };
+}

package/lib/anthropic-mapper.js

@@ -0,0 +1,255 @@
+/**
+ * Anthropic/Claude Parameter Mapper Module
+ * Maps Anthropic API parameters to You.com API parameters
+ */
+
+import { 
+  getAdvancedVersion, 
+  isAdvancedVersion, 
+  getDefaultAdvancedVersion,
+  adjustWorkflowSteps
+} from './advanced-versions.js';
+
+/**
+ * Map Anthropic request parameters to You.com parameters
+ */
+export function mapAnthropicToYouParams(anthropicRequest) {
+  const {
+    model = 'advanced-3.0-high',
+    messages,
+    system,
+    temperature = 0.7,
+    max_tokens = 1024,
+    stream = false
+  } = anthropicRequest;
+
+  let input = '';
+  const conversationHistory = [];
+  
+  // Handle system prompt
+  if (system) {
+    input = `[System Instructions]\n${system}\n\n`;
+  }
+  
+  // Process messages
+  messages.forEach(msg => {
+    if (msg.role === 'user') {
+      // Handle content as string or array
+      const content = typeof msg.content === 'string' 
+        ? msg.content 
+        : msg.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+      conversationHistory.push(`User: ${content}`);
+    } else if (msg.role === 'assistant') {
+      const content = typeof msg.content === 'string'
+        ? msg.content
+        : msg.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+      conversationHistory.push(`Assistant: ${content}`);
+    }
+  });
+  
+  if (conversationHistory.length > 1) {
+    input += `[Conversation History]\n${conversationHistory.slice(0, -1).join('\n\n')}\n\n`;
+    input += `[Current Message]\n${conversationHistory[conversationHistory.length - 1].replace(/^User: /, '')}`;
+  } else if (conversationHistory.length === 1) {
+    input += conversationHistory[0].replace(/^User: /, '');
+  }
+
+  // Map model to You.com agent
+  const modelMapping = {
+    'claude-3-opus-20240229': 'advanced-3.0-high',
+    'claude-3-sonnet-20240229': 'advanced-3.0-medium',
+    'claude-3-haiku-20240307': 'express',
+    'claude-3-5-sonnet-20240620': 'advanced-3.0-high',
+    'claude-3-5-sonnet-20241022': 'advanced-3.0-high',
+    'claude-sonnet-4-20250514': 'advanced-3.0-high',
+    'claude-sonnet-4-5-20250929': 'advanced-4.5-research'
+  };
+
+  const mappedModel = modelMapping[model] || model;
+
+  // Check if it's an advanced version model
+  if (isAdvancedVersion(mappedModel)) {
+    const versionConfig = getAdvancedVersion(mappedModel);
+    if (versionConfig) {
+      const adjustedSteps = adjustWorkflowSteps(versionConfig.max_workflow_steps, temperature);
+      
+      return {
+        agent: 'advanced',
+        input,
+        stream,
+        verbosity: versionConfig.verbosity,
+        tools: versionConfig.tools,
+        workflow_config: {
+          max_workflow_steps: adjustedSteps
+        },
+        timeout: versionConfig.timeout
+      };
+    }
+  }
+
+  // Default handling
+  let agent = mappedModel;
+  let verbosity = 'medium';
+  let timeout = 300000;
+
+  if (temperature <= 0.3) verbosity = 'medium';
+  else if (temperature >= 0.8) verbosity = 'high';
+
+  const max_workflow_steps = Math.min(Math.max(Math.floor(max_tokens / 100), 1), 20);
+
+  const knownAgents = ['express', 'research', 'advanced'];
+  if (!knownAgents.includes(agent)) {
+    agent = 'advanced';
+  }
+
+  if (agent === 'advanced') {
+    timeout = 3000000;
+  }
+
+  return {
+    agent,
+    input,
+    stream,
+    verbosity,
+    tools: [
+      { type: 'research', search_effort: 'auto', report_verbosity: 'medium' },
+      { type: 'compute' }
+    ],
+    workflow_config: {
+      max_workflow_steps
+    },
+    timeout
+  };
+}
+
+/**
+ * Convert You.com response to Anthropic format
+ */
+export function convertToAnthropicResponse(youResponse, model, inputTokens = 100) {
+  const content = youResponse.output && Array.isArray(youResponse.output)
+    ? youResponse.output
+        .filter(item => item.type === 'message.answer')
+        .map(item => item.text)
+        .join('\n\n')
+    : 'No response content';
+
+  const outputTokens = Math.floor(content.length / 4);
+
+  return {
+    id: `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    content: [
+      {
+        type: 'text',
+        text: content
+      }
+    ],
+    model: model,
+    stop_reason: 'end_turn',
+    stop_sequence: null,
+    usage: {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens
+    }
+  };
+}
+
+/**
+ * Create streaming event in Anthropic format
+ */
+export function createAnthropicStreamEvent(eventType, data) {
+  return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+/**
+ * Create message_start event
+ */
+export function createMessageStartEvent(model, conversationId = null) {
+  const message = {
+    id: `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    content: [],
+    model: model,
+    stop_reason: null,
+    stop_sequence: null,
+    usage: {
+      input_tokens: 0,
+      output_tokens: 0
+    }
+  };
+  
+  // Add conversation_id in metadata if provided
+  if (conversationId) {
+    message.metadata = { conversation_id: conversationId };
+  }
+  
+  return createAnthropicStreamEvent('message_start', {
+    type: 'message_start',
+    message
+  });
+}
+
+/**
+ * Create content_block_start event
+ */
+export function createContentBlockStartEvent(index = 0) {
+  return createAnthropicStreamEvent('content_block_start', {
+    type: 'content_block_start',
+    index: index,
+    content_block: {
+      type: 'text',
+      text: ''
+    }
+  });
+}
+
+/**
+ * Create content_block_delta event
+ */
+export function createContentBlockDeltaEvent(text, index = 0) {
+  return createAnthropicStreamEvent('content_block_delta', {
+    type: 'content_block_delta',
+    index: index,
+    delta: {
+      type: 'text_delta',
+      text: text
+    }
+  });
+}
+
+/**
+ * Create content_block_stop event
+ */
+export function createContentBlockStopEvent(index = 0) {
+  return createAnthropicStreamEvent('content_block_stop', {
+    type: 'content_block_stop',
+    index: index
+  });
+}
+
+/**
+ * Create message_delta event
+ */
+export function createMessageDeltaEvent(outputTokens = 0) {
+  return createAnthropicStreamEvent('message_delta', {
+    type: 'message_delta',
+    delta: {
+      stop_reason: 'end_turn',
+      stop_sequence: null
+    },
+    usage: {
+      output_tokens: outputTokens
+    }
+  });
+}
+
+/**
+ * Create message_stop event
+ */
+export function createMessageStopEvent() {
+  return createAnthropicStreamEvent('message_stop', {
+    type: 'message_stop'
+  });
+}

package/lib/api-client.js

@@ -0,0 +1,140 @@
+/**
+ * You.com API Client Module
+ * Shared API calling logic for MCP and OpenAI servers
+ */
+
+const API_BASE = 'https://api.you.com/v1/agents/runs';
+
+// Agent type configurations
+export const AGENT_TYPES = {
+  'express': { agent: 'express', description: 'Fast AI answers with web search (~2s, GPT-3 level)' },
+  'research': { agent: 'research', description: 'In-depth research and analysis' },
+  'advanced': { agent: 'advanced', description: 'Complex reasoning without tools (~10s, GPT-3.5 level)', tools: [] },
+  'advanced-3.0-high': { agent: 'advanced', verbosity: 'high', max_workflow_steps: 15, tools: [] },
+  'advanced-3.0-medium': { agent: 'advanced', verbosity: 'medium', max_workflow_steps: 10, tools: [] },
+  'advanced-4.0-high': { agent: 'advanced', verbosity: 'high', max_workflow_steps: 20, tools: [{ type: 'compute' }] },
+  'advanced-4.5-research': { 
+    agent: 'advanced', 
+    verbosity: 'high', 
+    max_workflow_steps: 20, 
+    tools: [{ type: 'research', search_effort: 'high', report_verbosity: 'high' }, { type: 'compute' }] 
+  }
+};
+
+/**
+ * Call You.com API
+ */
+export async function callYouApi(apiKey, requestBody, options = {}) {
+  const { timeout = 300000 } = options;
+  
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(API_BASE, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} ${errorText}`);
+    }
+
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+
+/**
+ * Extract text from You.com response
+ */
+export function extractText(data) {
+  if (data.output && Array.isArray(data.output)) {
+    return data.output
+      .filter(item => item.type === 'message.answer')
+      .map(item => item.text)
+      .join('\n\n');
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+/**
+ * Build conversation input from messages
+ */
+export function buildConversationInput(messages) {
+  let input = '';
+  let systemPrompt = '';
+  const conversationHistory = [];
+  
+  messages.forEach(msg => {
+    if (msg.role === 'system') {
+      systemPrompt = msg.content;
+    } else if (msg.role === 'user') {
+      conversationHistory.push(`User: ${msg.content}`);
+    } else if (msg.role === 'assistant') {
+      conversationHistory.push(`Assistant: ${msg.content}`);
+    }
+  });
+  
+  if (systemPrompt) {
+    input = `[System Instructions]\n${systemPrompt}\n\n`;
+  }
+  
+  if (conversationHistory.length > 1) {
+    input += `[Conversation History]\n${conversationHistory.slice(0, -1).join('\n\n')}\n\n`;
+    input += `[Current Message]\n${conversationHistory[conversationHistory.length - 1].replace(/^User: /, '')}`;
+  } else if (conversationHistory.length === 1) {
+    input += conversationHistory[0].replace(/^User: /, '');
+  }
+
+  return input;
+}
+
+/**
+ * Build request body for agent call
+ */
+export function buildAgentRequest(agentType, input, options = {}) {
+  const { tools, verbosity, max_workflow_steps, stream = false } = options;
+  const agentConfig = AGENT_TYPES[agentType] || AGENT_TYPES['advanced-3.0-high'];
+  const isExpressAgent = agentType === 'express' || agentConfig.agent === 'express';
+
+  if (isExpressAgent) {
+    return {
+      agent: 'express',
+      input,
+      stream,
+    };
+  }
+
+  // Use tools from options > agentConfig > empty array (no default tools)
+  const finalTools = tools !== undefined ? tools : (agentConfig.tools !== undefined ? agentConfig.tools : []);
+
+  const request = {
+    agent: agentConfig.agent || 'advanced',
+    input,
+    stream,
+    verbosity: verbosity || agentConfig.verbosity || 'high',
+    workflow_config: {
+      max_workflow_steps: max_workflow_steps || agentConfig.max_workflow_steps || 15
+    },
+  };
+
+  // Only add tools if not empty
+  if (finalTools.length > 0) {
+    request.tools = finalTools;
+  }
+
+  return request;
+}
+
+export { API_BASE };

package/lib/auth-middleware.js

@@ -0,0 +1,44 @@
+/**
+ * Authentication Middleware Module
+ */
+
+// Access token configuration
+const ACCESS_TOKENS_RAW = process.env.YDC_OPENAI_ACCESS_TOKENS || '';
+const ACCESS_TOKENS = ACCESS_TOKENS_RAW.split(',').map(t => t.trim()).filter(t => t);
+const REQUIRE_TOKEN_AUTH = ACCESS_TOKENS.length > 0;
+
+/**
+ * Authentication middleware for Express
+ */
+export function authenticate(req, res, next) {
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({
+      error: {
+        message: 'Invalid authentication credentials',
+        type: 'invalid_request_error',
+        code: 'invalid_api_key'
+      }
+    });
+  }
+
+  if (REQUIRE_TOKEN_AUTH) {
+    const token = authHeader.slice(7);
+    if (!ACCESS_TOKENS.includes(token)) {
+      return res.status(401).json({
+        error: {
+          message: 'Invalid access token',
+          type: 'invalid_request_error',
+          code: 'invalid_access_token'
+        }
+      });
+    }
+  }
+
+  next();
+}
+
+export const authConfig = {
+  REQUIRE_TOKEN_AUTH,
+  ACCESS_TOKENS_COUNT: ACCESS_TOKENS.length
+};