@cpujia/codex-mcp-server 2.0.1 → 2.1.0

package/dist/codex-client.d.ts

@@ -17,10 +17,15 @@ interface CodexRequestOptions {
     jsonSchema?: JsonSchemaFormat;
     reasoningEffort?: ReasoningEffort;
     maxTokens?: number;
+    previousResponseId?: string;
+}
+interface CodexRequestResult {
+    text: string;
+    responseId: string;
 }
 export declare class CodexClient {
     private config;
     constructor(config: CodexClientConfig);
-    request(options: CodexRequestOptions): Promise<string>;
+    request(options: CodexRequestOptions): Promise<CodexRequestResult>;
 }
-export type { CodexClientConfig, CodexRequestOptions, JsonSchemaFormat, ReasoningEffort, };
+export type { CodexClientConfig, CodexRequestOptions, CodexRequestResult, JsonSchemaFormat, ReasoningEffort, };

package/dist/codex-client.js

@@ -17,8 +17,11 @@ export class CodexClient {
                 model: this.config.model,
                 input: [{ role: "user", content: userContent }],
                 max_output_tokens: maxTokens,
-                store: false,
+                store: true, // 启用存储以支持 previous_response_id
             };
+            if (options.previousResponseId) {
+                requestBody.previous_response_id = options.previousResponseId;
+            }
             if (effort) {
                 requestBody.reasoning = { effort };
             }
@@ -56,7 +59,10 @@ export class CodexClient {
             if (!textContent?.text) {
                 throw new Error("No text content in response");
             }
-            return textContent.text;
+            return {
+                text: textContent.text,
+                responseId: data.id,
+            };
         }
         catch (error) {
             clearTimeout(timeoutId);

package/dist/index.js

@@ -137,38 +137,271 @@ const TEST_SCHEMA = {
         additionalProperties: false,
     },
 };
+const CONVERT_SCHEMA = {
+    name: "convert_result",
+    schema: {
+        type: "object",
+        properties: {
+            converted_code: {
+                type: "string",
+                description: "Converted code in target language/framework",
+            },
+            target_language: {
+                type: "string",
+                description: "Target language/framework",
+            },
+            conversion_notes: {
+                type: "string",
+                description: "Key decisions and idioms used in conversion",
+            },
+            breaking_changes: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of breaking changes or manual steps required",
+            },
+        },
+        required: [
+            "converted_code",
+            "target_language",
+            "conversion_notes",
+            "breaking_changes",
+        ],
+        additionalProperties: false,
+    },
+};
+const ARCHITECT_SCHEMA = {
+    name: "architect_result",
+    schema: {
+        type: "object",
+        properties: {
+            design: {
+                type: "string",
+                description: "Proposed system design or architecture",
+            },
+            rationale: {
+                type: "string",
+                description: "Why this design was chosen",
+            },
+            tradeoffs: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        aspect: { type: "string", description: "What is being traded off" },
+                        chosen: { type: "string", description: "What was chosen" },
+                        alternative: { type: "string", description: "What was rejected" },
+                        reason: { type: "string", description: "Why this tradeoff" },
+                    },
+                    required: ["aspect", "chosen", "alternative", "reason"],
+                    additionalProperties: false,
+                },
+            },
+            implementation_steps: {
+                type: "array",
+                items: { type: "string" },
+                description: "High-level implementation roadmap",
+            },
+            risks: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        risk: { type: "string", description: "What could go wrong" },
+                        severity: {
+                            type: "string",
+                            enum: ["critical", "high", "medium", "low"],
+                        },
+                        mitigation: { type: "string", description: "How to address it" },
+                    },
+                    required: ["risk", "severity", "mitigation"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: [
+            "design",
+            "rationale",
+            "tradeoffs",
+            "implementation_steps",
+            "risks",
+        ],
+        additionalProperties: false,
+    },
+};
 // --- Developer 指令（per-tool） ---
 const INSTRUCTIONS = {
     generate: [
-        "You are a senior software engineer. Generate production-quality code.",
+        "You are an expert software engineer with deep knowledge across multiple programming languages and paradigms.",
+        "",
+        "# Your Task",
+        "Generate production-ready, complete, and runnable code based on the user's requirements.",
         "",
-        "Rules:",
-        "- Write complete, runnable code — no placeholders, no TODOs",
-        "- Include necessary imports and type definitions",
-        "- Follow language-specific conventions and idioms",
-        "- If project context is provided, follow its conventions strictly",
-        "- Optimize for readability first, performance second",
+        "# Critical Requirements",
+        "- Output ONLY valid, executable code with NO placeholders, TODOs, or comments like '// rest of implementation'",
+        "- Include ALL necessary imports, type definitions, and dependencies",
+        "- Follow the target language's idioms, conventions, and best practices",
+        "- If project context is provided, strictly adhere to its conventions and patterns",
+        "",
+        "# Code Quality Standards",
+        "- Prioritize: correctness > readability > performance",
+        "- Use descriptive variable/function names that reveal intent",
+        "- Handle edge cases and error conditions explicitly",
+        "- Prefer composition over inheritance, immutability over mutation",
+        "- Write self-documenting code; add comments ONLY for non-obvious logic",
+        "",
+        "# Output Format",
+        "Return a JSON object with these exact fields:",
+        "- code: Complete, runnable implementation",
+        "- language: Programming language used",
+        "- explanation: Brief rationale for key design decisions (2-3 sentences)",
+        "- dependencies: Array of required packages/imports (empty array if none)",
     ].join("\n"),
     review: [
-        "You are a security-focused code reviewer. Provide independent, critical analysis.",
+        "You are a senior security engineer and code reviewer with expertise in identifying vulnerabilities, performance issues, and maintainability problems.",
+        "",
+        "# Your Task",
+        "Perform an independent, critical code review. Your goal is to find real issues that could cause problems in production.",
         "",
-        "Rules:",
-        "- Reference exact locations in the code (line numbers or function names)",
-        "- Prioritize: critical > high > medium > low > info",
-        "- For each finding, provide a concrete, actionable fix",
-        "- Score fairly: 90+ excellent, 70-89 good, 50-69 needs work, <50 concerning",
-        "- Be honest — don't inflate scores. Empty findings array is fine for clean code",
+        "# Review Focus Areas",
+        "1. **Security**: SQL injection, XSS, CSRF, auth bypasses, insecure crypto, input validation",
+        "2. **Performance**: N+1 queries, memory leaks, inefficient algorithms, blocking operations",
+        "3. **Correctness**: Race conditions, off-by-one errors, null/undefined handling, edge cases",
+        "4. **Maintainability**: Code smells, tight coupling, poor naming, missing error handling",
+        "",
+        "# Severity Guidelines",
+        "- **critical**: Exploitable security vulnerability or data loss risk",
+        "- **high**: Likely production failure, significant performance degradation, or security weakness",
+        "- **medium**: Code smell that will cause maintenance burden or minor performance issue",
+        "- **low**: Style inconsistency or minor improvement opportunity",
+        "- **info**: Suggestion for enhancement, no actual problem",
+        "",
+        "# Scoring Rubric (0-100)",
+        "- 90-100: Production-ready, minimal issues",
+        "- 70-89: Good quality, minor improvements needed",
+        "- 50-69: Significant issues, needs refactoring before production",
+        "- 0-49: Critical flaws, unsafe for production",
+        "",
+        "# Critical Instructions",
+        "- Reference EXACT locations: line numbers, function names, or code snippets",
+        "- For each finding, provide a CONCRETE, actionable fix (not vague advice)",
+        "- Be honest: if code is clean, return empty findings array and high score",
+        "- Do NOT inflate scores or find issues that don't exist",
+        "- Prioritize findings by severity (critical first)",
+        "",
+        "# Output Format",
+        "Return a JSON object with these exact fields:",
+        "- findings: Array of {severity, category, location, issue, suggestion}",
+        "- summary: 1-2 sentence overall assessment",
+        "- score: Integer 0-100",
     ].join("\n"),
     test: [
-        "You are a testing expert. Write comprehensive test suites that catch real bugs.",
+        "You are a testing expert who writes comprehensive test suites that catch real bugs before they reach production.",
+        "",
+        "# Your Task",
+        "Generate a complete, runnable test file that thoroughly validates the provided code.",
+        "",
+        "# Test Coverage Requirements",
+        "1. **Happy path**: Normal inputs, expected behavior",
+        "2. **Edge cases**: Boundary values (0, -1, MAX_INT, empty arrays, null/undefined)",
+        "3. **Error handling**: Invalid inputs, exceptions, network failures",
+        "4. **Integration**: Interactions with dependencies, side effects",
+        "",
+        "# Test Quality Standards",
+        "- Each test should verify ONE specific behavior",
+        "- Test names must clearly describe what is being tested and expected outcome",
+        "- Use the specified framework's idioms (describe/it, test(), etc.)",
+        "- Mock external dependencies (APIs, databases, file system)",
+        "- Include setup/teardown if needed for test isolation",
+        "- Think: 'What would break in production?' and test that",
+        "",
+        "# Critical Instructions",
+        "- Generate a COMPLETE test file that can be run immediately",
+        "- Include ALL necessary imports and setup",
+        "- Follow the project's testing conventions if provided",
+        "- Cover at least 80% of code paths",
+        "- Identify any gaps in coverage explicitly",
         "",
-        "Rules:",
-        "- Generate a complete, runnable test file",
-        "- Cover: happy path, edge cases, error handling, boundary conditions",
-        "- Use the specified framework's idioms and best practices",
-        "- Include descriptive test names explaining expected behavior",
-        "- Mock external dependencies appropriately",
-        "- Think about what would break in production and test that",
+        "# Output Format",
+        "Return a JSON object with these exact fields:",
+        "- test_code: Complete, runnable test file",
+        "- language: Programming language",
+        "- framework: Test framework used",
+        "- test_cases: Array of {name, description, type} for each test",
+        "- coverage_notes: What is covered and what gaps remain (be honest)",
+    ].join("\n"),
+    convert: [
+        "You are a polyglot engineer expert in cross-language/framework migrations, with deep knowledge of idioms and best practices across ecosystems.",
+        "",
+        "# Your Task",
+        "Convert code from source to target language/framework while preserving semantics and following target idioms.",
+        "",
+        "# Conversion Principles",
+        "1. **Semantic equivalence**: Preserve ALL functionality, edge cases, and error handling",
+        "2. **Idiomatic target code**: Use target language's standard library, patterns, and conventions",
+        "3. **No direct translation**: Don't just transliterate syntax; rethink using target paradigms",
+        "4. **Explicit tradeoffs**: If conversion goal conflicts with idioms, prioritize the goal",
+        "",
+        "# Common Pitfalls to Avoid",
+        "- Bringing source language patterns to target (e.g., Java-style classes in Python)",
+        "- Missing target language features (e.g., pattern matching, async/await)",
+        "- Ignoring target ecosystem conventions (e.g., PEP 8, Go error handling)",
+        "- Incomplete error handling translation",
+        "",
+        "# Breaking Changes",
+        "Document ANY changes that require manual intervention:",
+        "- API signature changes",
+        "- Dependency updates needed",
+        "- Configuration changes",
+        "- Data migration steps",
+        "",
+        "# Output Format",
+        "Return a JSON object with these exact fields:",
+        "- converted_code: Complete, idiomatic implementation in target language",
+        "- target_language: Target language/framework",
+        "- conversion_notes: Key decisions, idioms used, tradeoffs made (2-4 sentences)",
+        "- breaking_changes: Array of manual steps required (empty if none)",
+    ].join("\n"),
+    architect: [
+        "You are a principal architect with 15+ years designing large-scale distributed systems. You make pragmatic decisions based on real-world constraints.",
+        "",
+        "# Your Task",
+        "Design a system architecture that balances competing requirements: scalability, reliability, cost, maintainability, and team capabilities.",
+        "",
+        "# Design Principles",
+        "1. **Start simple**: Choose the simplest design that meets requirements; add complexity only when justified",
+        "2. **Explicit tradeoffs**: Every architectural decision sacrifices something; state what you're optimizing for and what you're giving up",
+        "3. **Concrete over abstract**: Provide specific technologies, patterns, and implementation approaches",
+        "4. **Risk-aware**: Identify what could go wrong and how to mitigate it",
+        "5. **Implementable**: Design must be achievable by the team with stated constraints",
+        "",
+        "# Tradeoff Analysis Framework",
+        "For each major decision, explicitly state:",
+        "- What you chose and why",
+        "- What you rejected and why",
+        "- What you're optimizing for (e.g., developer velocity, cost, reliability)",
+        "- What you're sacrificing (e.g., consistency, simplicity, performance)",
+        "",
+        "# Risk Assessment",
+        "Identify risks with:",
+        "- **critical**: System failure, data loss, security breach",
+        "- **high**: Significant downtime, performance degradation, cost overrun",
+        "- **medium**: Maintenance burden, technical debt, team friction",
+        "- **low**: Minor inconvenience, future refactoring needed",
+        "",
+        "# Critical Instructions",
+        "- Provide CONCRETE design: specific technologies, not 'use a database'",
+        "- Break implementation into logical phases (MVP → iteration)",
+        "- Consider team size, budget, and existing infrastructure",
+        "- If requirements conflict, state which takes priority and why",
+        "- Be honest about limitations and unknowns",
+        "",
+        "# Output Format",
+        "Return a JSON object with these exact fields:",
+        "- design: Detailed system architecture (components, data flow, technologies)",
+        "- rationale: Why this design over alternatives (2-4 sentences)",
+        "- tradeoffs: Array of {aspect, chosen, alternative, reason}",
+        "- implementation_steps: Ordered list of phases/milestones",
+        "- risks: Array of {risk, severity, mitigation}",
     ].join("\n"),
 };
 // --- 输入构建 ---
@@ -211,6 +444,26 @@ function formatTestOutput(parsed) {
         .join("\n");
     return `\`\`\`${parsed.language}\n${parsed.test_code}\n\`\`\`\n\n**Framework:** ${parsed.framework}\n**Test Cases (${parsed.test_cases.length}):**\n${cases}\n\n**Coverage:** ${parsed.coverage_notes}`;
 }
+function formatConvertOutput(parsed) {
+    let text = `\`\`\`${parsed.target_language}\n${parsed.converted_code}\n\`\`\``;
+    text += `\n\n**Conversion Notes:** ${parsed.conversion_notes}`;
+    if (parsed.breaking_changes.length > 0) {
+        text += `\n\n**Breaking Changes:**\n${parsed.breaking_changes.map((c) => `- ${c}`).join("\n")}`;
+    }
+    return text;
+}
+function formatArchitectOutput(parsed) {
+    const tradeoffs = parsed.tradeoffs
+        .map((t) => `**${t.aspect}:** Chose "${t.chosen}" over "${t.alternative}"\n  Reason: ${t.reason}`)
+        .join("\n\n");
+    const steps = parsed.implementation_steps
+        .map((s, i) => `${i + 1}. ${s}`)
+        .join("\n");
+    const risks = parsed.risks
+        .map((r) => `- **[${r.severity.toUpperCase()}]** ${r.risk}\n  Mitigation: ${r.mitigation}`)
+        .join("\n\n");
+    return `## Design\n\n${parsed.design}\n\n## Rationale\n\n${parsed.rationale}\n\n## Tradeoffs\n\n${tradeoffs}\n\n## Implementation Steps\n\n${steps}\n\n## Risks\n\n${risks}`;
+}
 // --- MCP Server ---
 const server = new Server({ name: "codex-mcp-server", version: "2.0.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -229,12 +482,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     "Reference Files": files,
                     "Conversation Context": conversation_context,
                 });
-                const raw = await codexClient.request({
+                const result = await codexClient.request({
                     instructions: INSTRUCTIONS.generate,
                     input,
                     jsonSchema: GENERATE_SCHEMA,
                 });
-                const parsed = safeJsonParse(raw);
+                const parsed = safeJsonParse(result.text);
                 if (parsed && typeof parsed.code === "string") {
                     return {
                         content: [
@@ -246,7 +499,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 // Fallback：API 不支持结构化输出时直接返回原文
-                return { content: [{ type: "text", text: raw }] };
+                return { content: [{ type: "text", text: result.text }] };
             }
             case "codex_review": {
                 const { code, language, focus, project_context, conversation_context } = args;
@@ -257,13 +510,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     "Project Context": project_context,
                     "Review Context": conversation_context,
                 });
-                const raw = await codexClient.request({
+                const result = await codexClient.request({
                     instructions: INSTRUCTIONS.review,
                     input,
                     jsonSchema: REVIEW_SCHEMA,
                     reasoningEffort: "high",
                 });
-                const parsed = safeJsonParse(raw);
+                const parsed = safeJsonParse(result.text);
                 if (parsed && Array.isArray(parsed.findings)) {
                     return {
                         content: [
@@ -274,7 +527,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         ],
                     };
                 }
-                return { content: [{ type: "text", text: raw }] };
+                return { content: [{ type: "text", text: result.text }] };
             }
             case "codex_test": {
                 const { code, language, framework, project_context, conversation_context, } = args;
@@ -285,13 +538,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     "Project Context": project_context,
                     Context: conversation_context,
                 });
-                const raw = await codexClient.request({
+                const result = await codexClient.request({
                     instructions: INSTRUCTIONS.test,
                     input,
                     jsonSchema: TEST_SCHEMA,
                     reasoningEffort: "high",
                 });
-                const parsed = safeJsonParse(raw);
+                const parsed = safeJsonParse(result.text);
                 if (parsed && typeof parsed.test_code === "string") {
                     return {
                         content: [
@@ -302,7 +555,64 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         ],
                     };
                 }
-                return { content: [{ type: "text", text: raw }] };
+                return { content: [{ type: "text", text: result.text }] };
+            }
+            case "codex_convert": {
+                const { code, source_language, target_language, conversion_goal, project_context, conversation_context, } = args;
+                const input = buildInput({
+                    "Source Code": `\`\`\`${source_language}\n${code}\n\`\`\``,
+                    "Source Language": source_language,
+                    "Target Language": target_language,
+                    "Conversion Goal": conversion_goal,
+                    "Project Context": project_context,
+                    "Conversion Context": conversation_context,
+                });
+                const result = await codexClient.request({
+                    instructions: INSTRUCTIONS.convert,
+                    input,
+                    jsonSchema: CONVERT_SCHEMA,
+                    reasoningEffort: "high",
+                });
+                const parsed = safeJsonParse(result.text);
+                if (parsed && typeof parsed.converted_code === "string") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: formatConvertOutput(parsed),
+                            },
+                        ],
+                    };
+                }
+                return { content: [{ type: "text", text: result.text }] };
+            }
+            case "codex_architect": {
+                const { requirements, constraints, design_question, existing_system, conversation_context, } = args;
+                const input = buildInput({
+                    Requirements: requirements,
+                    Constraints: constraints,
+                    "Design Question": design_question,
+                    "Existing System": existing_system,
+                    Context: conversation_context,
+                });
+                const result = await codexClient.request({
+                    instructions: INSTRUCTIONS.architect,
+                    input,
+                    jsonSchema: ARCHITECT_SCHEMA,
+                    reasoningEffort: "xhigh",
+                });
+                const parsed = safeJsonParse(result.text);
+                if (parsed && typeof parsed.design === "string") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: formatArchitectOutput(parsed),
+                            },
+                        ],
+                    };
+                }
+                return { content: [{ type: "text", text: result.text }] };
             }
             default:
                 throw new Error(`Unknown tool: ${name}`);

package/dist/tools.d.ts

@@ -27,6 +27,13 @@ export declare const tools: ({
             code?: undefined;
             focus?: undefined;
             framework?: undefined;
+            source_language?: undefined;
+            target_language?: undefined;
+            conversion_goal?: undefined;
+            requirements?: undefined;
+            constraints?: undefined;
+            design_question?: undefined;
+            existing_system?: undefined;
         };
         required: string[];
     };
@@ -60,6 +67,13 @@ export declare const tools: ({
             prompt?: undefined;
             files?: undefined;
             framework?: undefined;
+            source_language?: undefined;
+            target_language?: undefined;
+            conversion_goal?: undefined;
+            requirements?: undefined;
+            constraints?: undefined;
+            design_question?: undefined;
+            existing_system?: undefined;
         };
         required: string[];
     };
@@ -92,6 +106,94 @@ export declare const tools: ({
             prompt?: undefined;
             files?: undefined;
             focus?: undefined;
+            source_language?: undefined;
+            target_language?: undefined;
+            conversion_goal?: undefined;
+            requirements?: undefined;
+            constraints?: undefined;
+            design_question?: undefined;
+            existing_system?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            code: {
+                type: string;
+                description: string;
+            };
+            source_language: {
+                type: string;
+                description: string;
+            };
+            target_language: {
+                type: string;
+                description: string;
+            };
+            conversion_goal: {
+                type: string;
+                description: string;
+            };
+            project_context: {
+                type: string;
+                description: string;
+            };
+            conversation_context: {
+                type: string;
+                description: string;
+            };
+            prompt?: undefined;
+            language?: undefined;
+            files?: undefined;
+            focus?: undefined;
+            framework?: undefined;
+            requirements?: undefined;
+            constraints?: undefined;
+            design_question?: undefined;
+            existing_system?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            requirements: {
+                type: string;
+                description: string;
+            };
+            constraints: {
+                type: string;
+                description: string;
+            };
+            design_question: {
+                type: string;
+                description: string;
+            };
+            existing_system: {
+                type: string;
+                description: string;
+            };
+            conversation_context: {
+                type: string;
+                description: string;
+            };
+            prompt?: undefined;
+            language?: undefined;
+            project_context?: undefined;
+            files?: undefined;
+            code?: undefined;
+            focus?: undefined;
+            framework?: undefined;
+            source_language?: undefined;
+            target_language?: undefined;
+            conversion_goal?: undefined;
         };
         required: string[];
     };

package/dist/tools.js

@@ -127,4 +127,93 @@ export const tools = [
             required: ["code"],
         },
     },
+    {
+        name: "codex_convert",
+        description: [
+            "Convert code between languages, frameworks, or architectural patterns using deep reasoning.",
+            "",
+            "Returns structured JSON: { converted_code, target_language, conversion_notes, breaking_changes }",
+            "",
+            "When to use:",
+            "- Language migration (Python→Rust, JavaScript→TypeScript, Go→Zig)",
+            "- Framework migration (REST→GraphQL, React→Vue, Express→Fastify)",
+            "- Pattern migration (callbacks→async/await, class→functional)",
+            "- API version upgrades with breaking changes",
+            "",
+            "Do NOT use for simple syntax translation — use native tools or simple prompts.",
+        ].join("\n"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "Source code to convert.",
+                },
+                source_language: {
+                    type: "string",
+                    description: "Source language/framework (e.g., python, react, rest-api).",
+                },
+                target_language: {
+                    type: "string",
+                    description: "Target language/framework (e.g., rust, vue, graphql).",
+                },
+                conversion_goal: {
+                    type: "string",
+                    description: "What to preserve/optimize during conversion (e.g., 'maintain API compatibility', 'optimize for performance', 'idiomatic target language').",
+                },
+                project_context: {
+                    type: "string",
+                    description: "Target project conventions, dependencies, constraints.",
+                },
+                conversation_context: {
+                    type: "string",
+                    description: "Why this conversion is needed, migration strategy.",
+                },
+            },
+            required: ["code", "source_language", "target_language"],
+        },
+    },
+    {
+        name: "codex_architect",
+        description: [
+            "System design and architectural decision-making with deep reasoning.",
+            "",
+            "Returns structured JSON: { design, rationale, tradeoffs, implementation_steps, risks }",
+            "",
+            "When to use:",
+            "- Designing system architecture from requirements",
+            "- Choosing between architectural patterns (microservices vs monolith, event-driven vs request-response)",
+            "- Data modeling and schema design",
+            "- Technology stack selection with tradeoff analysis",
+            "- Scalability and performance architecture",
+            "",
+            "Do NOT use for implementation details — use codex_generate for that.",
+        ].join("\n"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                requirements: {
+                    type: "string",
+                    description: "System requirements: functional requirements, non-functional requirements (scale, performance, reliability).",
+                },
+                constraints: {
+                    type: "string",
+                    description: "Technical constraints: budget, team size, existing infrastructure, compliance requirements.",
+                },
+                design_question: {
+                    type: "string",
+                    description: "Specific architectural question or decision to make (e.g., 'Should we use microservices?', 'How to handle real-time updates?').",
+                },
+                existing_system: {
+                    type: "string",
+                    description: "Current system architecture if this is a migration or evolution.",
+                },
+                conversation_context: {
+                    type: "string",
+                    description: "Previous architectural discussions, decisions made, options considered.",
+                },
+            },
+            required: ["requirements"],
+        },
+    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cpujia/codex-mcp-server",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "MCP Server for OpenAI Codex /v1/responses API integration with Claude Code",
   "type": "module",
   "main": "dist/index.js",