IdeaLift MCP Server

Instructions

Implementation Reference

• src/mcp/tools/proxyTools.ts:20-56 (schema)

  Definition of the 'list_ideas' tool, including its input schema and metadata.

  {
    name: 'list_ideas',
    description: 'List ideas in the workspace with optional filters. Returns paginated results.',
    inputSchema: {
      type: 'object' as const,
      properties: {
        status: {
          type: 'string',
          enum: ['new', 'accepted', 'rejected', 'snoozed', 'expired'],
          description: 'Filter by idea status',
        },
        source: {
          type: 'string',
          enum: ['discord', 'slack', 'teams', 'zapier', 'api', 'chrome', 'vscode', 'extension', 'sentry', 'fireflies', 'email', 'outlook', 'meeting', 'mcp'],
          description: 'Filter by source',
        },
        destination: {
          type: 'string',
          enum: ['github', 'linear', 'jira', 'azure-devops', 'zendesk'],
          description: 'Filter by destination',
        },
        limit: {
          type: 'number',
          description: 'Number of ideas to return (max 100)',
          default: 20,
        },
        offset: {
          type: 'number',
          description: 'Offset for pagination',
          default: 0,
        },
      },
      required: [],
    },
    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
    _meta: { 'openai/visibility': 'public' },
  },

• src/mcp/tools/proxyTools.ts:369-410 (handler)

  The 'handleProxyTool' function acts as a generic handler that proxies tool requests, including 'list_ideas', to the main IdeaLift app's MCP handler.

  export async function handleProxyTool(
    toolName: string,
    args: Record<string, unknown>,
    chatgptSubjectId: string
  ): Promise<{ content: Array<{ type: string; text: string }>; isError: boolean }> {
    try {
      const response = await idealiftClient.mcpProxy(
        chatgptSubjectId,
        'tools/call',
        { name: toolName, arguments: args }
      );
  
      if (response.error) {
        return {
          content: [{ type: 'text', text: `Error: ${response.error.message}` }],
          isError: true,
        };
      }
  
      // The result from handleJsonRpcRequest for tools/call is { content: [...], isError?: boolean }
      const result = response.result as { content?: Array<{ type: string; text: string }>; isError?: boolean } | undefined;
  
      if (result?.content) {
        return {
          content: result.content,
          isError: result.isError || false,
        };
      }
  
      // Fallback: wrap the result as text
      return {
        content: [{ type: 'text', text: JSON.stringify(response.result, null, 2) }],
        isError: false,
      };
    } catch (error) {
      console.error(`[ProxyTool] Error calling ${toolName}:`, error);
      return {
        content: [{ type: 'text', text: `Proxy error: ${(error as Error).message}` }],
        isError: true,
      };
    }
  }