@mmmbuto/zai-codex-bridge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davide A. Guglielmi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,294 @@
+# 🌉 Z.AI Codex Bridge
+
+> **Local proxy that translates OpenAI Responses API format to Z.AI Chat Completions format**
+
+[![npm](https://img.shields.io/npm/v/@mmmbuto/zai-codex-bridge?style=flat-square&logo=npm)](https://www.npmjs.com/package/@mmmbuto/zai-codex-bridge)
+[![node](https://img.shields.io/node/v/@mmmbuto/zai-codex-bridge?style=flat-square&logo=node.js)](https://github.com/mmmbuto/zai-codex-bridge)
+[![license](https://img.shields.io/npm/l/@mmmbuto/zai-codex-bridge?style=flat-square)](LICENSE)
+
+---
+
+## What It Solves
+
+Codex uses the newer OpenAI **Responses API** format (with `instructions` and `input` fields), but Z.AI only supports the legacy **Chat Completions** format (with `messages` array).
+
+This proxy:
+1. Accepts Codex requests in **Responses format**
+2. Translates them to **Chat format**
+3. Forwards to Z.AI
+4. Translates the response back to **Responses format**
+5. Returns to Codex
+
+**Without this proxy**, Codex fails with error from Z.AI:
+```json
+{"error":{"code":"1214","message":"Incorrect role information"}}
+```
+
+---
+
+## Features
+
+✅ **Transparent translation** between Responses and Chat formats
+✅ **Streaming support** with SSE (Server-Sent Events)
+✅ **Zero dependencies** - uses Node.js built-ins only
+✅ **Auto-starting ZSH functions** - proxy runs only when Codex runs
+✅ **Health checks** at `/health` endpoint
+✅ **Configurable** via CLI flags and environment variables
+
+---
+
+## Requirements
+
+- **Node.js**: 18.0.0 or higher (for native `fetch`)
+- **Platform**: Linux, macOS, Windows (WSL), Termux (ARM64)
+- **Port**: 31415 (default, configurable)
+
+---
+
+## Installation
+
+### Global Install (Recommended)
+
+```bash
+npm install -g @mmmbuto/zai-codex-bridge
+```
+
+### Local Install
+
+```bash
+npm install @mmmbuto/zai-codex-bridge
+npx zai-codex-bridge
+```
+
+### From Source
+
+```bash
+git clone https://github.com/DioNanos/zai-codex-bridge.git
+cd zai-codex-bridge
+npm install
+npm link
+```
+
+---
+
+## Quick Start
+
+### 1. Configure Codex
+
+Add to `~/.codex/config.toml`:
+
+```toml
+[model_providers.zai_glm_proxy]
+name = "ZAI GLM via local proxy"
+base_url = "http://127.0.0.1:31415/v1"
+env_key = "OPENAI_API_KEY"
+wire_api = "responses"
+stream_idle_timeout_ms = 3000000
+```
+
+### 2. Add ZSH Functions
+
+Add to `~/.zshrc`:
+
+```bash
+_codex_glm_with_proxy () {
+  local KEY="$1"; shift
+  local HOST="127.0.0.1"
+  local PORT="31415"
+  local HEALTH="http://${HOST}:${PORT}/health"
+  local LOGFILE="${TMPDIR:-/tmp}/zai-codex-bridge.log"
+  local PROXY_PID=""
+
+  # Start proxy only if not responding
+  if ! curl -fsS "$HEALTH" >/dev/null 2>&1; then
+    zai-codex-bridge --host "$HOST" --port "$PORT" --log-level info >"$LOGFILE" 2>&1 &
+    PROXY_PID=$!
+    trap '[[ -n "$PROXY_PID" ]] && kill "$PROXY_PID" 2>/dev/null' EXIT INT TERM
+    for i in {1..40}; do
+      curl -fsS "$HEALTH" >/dev/null 2>&1 && break
+      sleep 0.05
+    done
+  fi
+
+  OPENAI_API_KEY="$KEY" codex -m "GLM-4.7" -c model_provider="zai_glm_proxy" "$@"
+}
+
+codex-glm-a () { _codex_glm_with_proxy "$ZAI_API_KEY_A" "$@"; }
+codex-glm-p () { _codex_glm_with_proxy "$ZAI_API_KEY_P" "$@"; }
+```
+
+### 3. Set API Keys
+
+```bash
+export ZAI_API_KEY_A="sk-your-key-here"
+export ZAI_API_KEY_P="sk-your-key-here"
+```
+
+### 4. Use It
+
+```bash
+source ~/.zshrc
+codex-glm-a
+```
+
+---
+
+## CLI Usage
+
+```bash
+# Start with defaults (http://127.0.0.1:31415)
+zai-codex-bridge
+
+# Custom port
+zai-codex-bridge --port 8080
+
+# Enable debug logging
+zai-codex-bridge --log-level debug
+
+# Custom Z.AI endpoint
+zai-codex-bridge --zai-base-url https://custom.z.ai/v1
+
+# Show help
+zai-codex-bridge --help
+```
+
+### Environment Variables
+
+```bash
+export PORT=31415
+export HOST=127.0.0.1
+export ZAI_BASE_URL=https://api.z.ai/api/coding/paas/v4
+export LOG_LEVEL=info
+```
+
+---
+
+## API Endpoints
+
+### `POST /responses`
+Accepts OpenAI Responses API format, translates to Chat, returns Responses format.
+
+### `POST /v1/responses`
+Same as `/responses` (for compatibility with Codex's path structure).
+
+### `GET /health`
+Health check endpoint.
+
+---
+
+## Testing
+
+```bash
+# Set your Z.AI API key
+export ZAI_API_KEY="sk-your-key"
+
+# Run test suite
+npm run test:curl
+```
+
+### Manual Test
+
+```bash
+# Start proxy
+zai-codex-bridge &
+
+# Test health
+curl http://127.0.0.1:31415/health
+
+# Test Responses API
+curl -X POST http://127.0.0.1:31415/v1/responses \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $ZAI_API_KEY" \
+  -d '{
+    "model": "GLM-4.7",
+    "instructions": "Be brief",
+    "input": [{"role": "user", "content": "What is 2+2?"}],
+    "stream": false
+  }'
+```
+
+---
+
+## Architecture
+
+```
+Codex (Responses API)
+    ↓
+Proxy (localhost:31415)
+    ↓
+Translation: Responses → Chat
+    ↓
+Z.AI (Chat Completions)
+    ↓
+Translation: Chat → Responses
+    ↓
+Codex
+```
+
+---
+
+## Documentation
+
+📚 **Complete Guide**: [docs/guide.md](docs/guide.md)
+
+The guide includes:
+- Detailed setup instructions
+- Usage examples
+- Troubleshooting
+- Function reference
+- Advanced configuration
+
+---
+
+## Troubleshooting
+
+### Port Already in Use
+
+```bash
+lsof -i :31415
+kill -9 <PID>
+```
+
+### Connection Refused
+
+```bash
+curl http://127.0.0.1:31415/health
+zai-codex-bridge --log-level debug
+```
+
+### Z.AI Errors
+
+Verify API key and test Z.AI directly:
+```bash
+curl -X POST https://api.z.ai/api/coding/paas/v4/chat/completions \
+  -H "Authorization: Bearer $ZAI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model":"GLM-4.7","messages":[{"role":"user","content":"test"}]}'
+```
+
+---
+
+## Development
+
+```bash
+# Clone repo
+git clone https://github.com/DioNanos/zai-codex-bridge.git
+cd zai-codex-bridge
+
+# Run in development
+npm start
+
+# Run tests
+npm run test:curl
+
+# Link globally
+npm link
+```
+
+---
+
+## License
+
+MIT License - Copyright (c) 2026 Davide A. Guglielmi
+
+See [LICENSE](LICENSE) for details.

package/bin/zai-codex-bridge

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+/**
+ * zai-codex-bridge CLI
+ *
+ * Usage: zai-codex-bridge [options]
+ *
+ * Options:
+ *   --port <number>     Port to listen on (default: 31415)
+ *   --host <string>     Host to bind to (default: 127.0.0.1)
+ *   --zai-base-url <url>  Z.AI base URL (default: https://api.z.ai/api/coding/paas/v4)
+ *   --log-level <level>  Log level: debug|info (default: info)
+ *   -h, --help          Show this help
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Parse CLI arguments
+function parseArgs(argv) {
+  const args = {
+    port: null,
+    host: null,
+    zaiBaseUrl: null,
+    logLevel: null,
+    help: false
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === '-h' || arg === '--help') {
+      args.help = true;
+      continue;
+    }
+
+    if (arg === '--port' && i + 1 < argv.length) {
+      args.port = parseInt(argv[++i], 10);
+      continue;
+    }
+
+    if (arg === '--host' && i + 1 < argv.length) {
+      args.host = argv[++i];
+      continue;
+    }
+
+    if (arg === '--zai-base-url' && i + 1 < argv.length) {
+      args.zaiBaseUrl = argv[++i];
+      continue;
+    }
+
+    if (arg === '--log-level' && i + 1 < argv.length) {
+      args.logLevel = argv[++i];
+      continue;
+    }
+  }
+
+  return args;
+}
+
+// Show help
+function showHelp() {
+  console.log(`
+zai-codex-bridge - Proxy for Codex to use Z.AI GLM models
+
+USAGE:
+  zai-codex-bridge [options]
+
+OPTIONS:
+  --port <number>         Port to listen on (default: 31415)
+  --host <string>         Host to bind to (default: 127.0.0.1)
+  --zai-base-url <url>    Z.AI base URL
+                          (default: https://api.z.ai/api/coding/paas/v4)
+  --log-level <level>     Log level: debug|info (default: info)
+  -h, --help              Show this help
+
+ENVIRONMENT VARIABLES:
+  PORT                    Override default port
+  HOST                    Override default host
+  ZAI_BASE_URL           Override Z.AI base URL
+  LOG_LEVEL              Override log level
+
+EXAMPLES:
+  # Start with defaults
+  zai-codex-bridge
+
+  # Start on custom port
+  zai-codex-bridge --port 8080
+
+  # Enable debug logging
+  zai-codex-bridge --log-level debug
+
+  # Point to different Z.AI endpoint
+  zai-codex-bridge --zai-base-url https://custom.z.ai/v1
+
+HEALTH CHECK:
+  curl http://127.0.0.1:31415/health
+
+For more information, see: https://github.com/mmmbuto/zai-codex-bridge
+`);
+}
+
+// Main
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Set environment variables from CLI args
+  if (args.port) process.env.PORT = String(args.port);
+  if (args.host) process.env.HOST = args.host;
+  if (args.zaiBaseUrl) process.env.ZAI_BASE_URL = args.zaiBaseUrl;
+  if (args.logLevel) process.env.LOG_LEVEL = args.logLevel;
+
+  // Start the server
+  const serverPath = path.join(__dirname, '..', 'src', 'server.js');
+
+  if (!fs.existsSync(serverPath)) {
+    console.error('Error: server.js not found at', serverPath);
+    process.exit(1);
+  }
+
+  require(serverPath);
+}
+
+main();

package/docs/guide.md

@@ -0,0 +1,405 @@
+# Z.AI GLM Proxy - Complete Guide
+
+**Purpose**: Practical guide for using GLM-4.7 via Z.AI with Codex CLI through the `zai-codex-bridge` proxy.
+
+---
+
+## Quick Start
+
+### First Time Setup
+
+```bash
+# 1. Install the proxy globally
+cd ~/Dev/zai-codex-bridge
+npm install -g .
+
+# 2. Reload .zshrc for the new functions
+source ~/.zshrc
+
+# 3. Start Codex with GLM-4.7
+codex-glm-a
+```
+
+### Daily Usage
+
+```bash
+# Start with account A
+codex-glm-a
+
+# Start with account P
+codex-glm-p
+
+# Exit Codex
+Ctrl+D
+# Proxy is automatically terminated
+```
+
+---
+
+## Prerequisites
+
+### 1. Environment Variables
+
+Ensure you have API keys in your `.zshrc` or `.zshenv`:
+
+```bash
+# Z.AI API Keys
+export ZAI_API_KEY_A="sk-your-key-account-a"
+export ZAI_API_KEY_P="sk-your-key-account-p"
+```
+
+### 2. Proxy Installed
+
+```bash
+# Global installation (recommended)
+cd ~/Dev/zai-codex-bridge
+npm install -g .
+
+# Verify installation
+which zai-codex-bridge
+```
+
+### 3. Codex Configuration
+
+The file `~/.codex/config.toml` must contain:
+
+```toml
+[model_providers.zai_glm_proxy]
+name = "ZAI GLM via local proxy"
+base_url = "http://127.0.0.1:31415/v1"
+env_key = "OPENAI_API_KEY"
+wire_api = "responses"
+stream_idle_timeout_ms = 3000000
+```
+
+---
+
+## How It Works
+
+### Architecture
+
+```
+.zshrc → _codex_glm_with_proxy() → Codex → Proxy (port 31415) → Z.AI API
+                                            ↓
+                                    Translates:
+                                    Responses → Chat
+                                    Chat → Responses
+```
+
+### Execution Flow
+
+1. User runs `codex-glm-a`
+2. Function checks if proxy is active on port 31415
+3. If NO:
+   - Starts proxy in background
+   - Saves PID
+   - Sets trap for cleanup
+   - Waits up to 2 seconds for proxy to be ready
+4. Codex starts with provider `zai_glm_proxy`
+5. Request: Codex → Proxy → Translated to Chat → Z.AI
+6. Response: Z.AI → Chat → Proxy → Translated to Responses → Codex
+7. User exits Codex (Ctrl+D)
+8. Trap kills the proxy (only if this function started it)
+
+---
+
+## Usage Examples
+
+### Example 1: Simple Conversation
+
+```bash
+# Start
+codex-glm-a
+
+# In Codex prompt:
+> What is 23 * 47?
+
+# GLM-4.7 responds:
+> The result of 23 * 47 is 1081.
+
+# Exit
+Ctrl+D
+# Proxy automatically terminated
+```
+
+### Example 2: Code Analysis
+
+```bash
+# Start with additional arguments
+codex-glm-a -s workspace-write
+
+# In Codex prompt:
+> Read main.py and tell me what it does
+
+# Codex will read the file and GLM-4.7 will analyze the code
+```
+
+### Example 3: Multi-Session
+
+```bash
+# Terminal 1
+codex-glm-a
+# Proxy starts (PID 12345)
+
+# Terminal 2 (while terminal 1 is still open)
+codex-glm-a
+# Proxy ALREADY ACTIVE, gets reused
+# No new process spawned
+
+# Terminal 1: Ctrl+D
+# Codex exits but proxy STAYS active (for terminal 2)
+
+# Terminal 2: Ctrl+D
+# Codex exits but proxy STAYS active (didn't start it)
+```
+
+### Example 4: Debug Proxy
+
+```bash
+# Start proxy manually with debug
+zai-codex-bridge --log-level debug --port 31415
+
+# In another terminal, test
+curl http://127.0.0.1:31415/health
+# {"ok":true}
+
+# Now start codex manually
+OPENAI_API_KEY="$ZAI_API_KEY_A" \
+  codex -m "GLM-4.7" -c model_provider="zai_glm_proxy"
+```
+
+---
+
+## Troubleshooting
+
+### Proxy Won't Start
+
+**Symptom**: `codex-glm-a` hangs or errors
+
+**Solution**:
+```bash
+# Verify installation
+which zai-codex-bridge
+
+# If not found, reinstall
+cd ~/Dev/zai-codex-bridge
+npm install -g .
+```
+
+### Port Already in Use
+
+**Symptom**: `Error: listen EADDRINUSE: address already in use :::31415`
+
+**Solution**:
+```bash
+# Find process
+lsof -i :31415
+# or
+netstat -tulpn | grep 31415
+
+# If it's an old proxy, kill it
+kill -9 <PID>
+
+# Or use different port - just use:
+codex-glm-a  # will use existing proxy
+```
+
+### Z.AI Error 1214
+
+**Symptom**: `{"error":{"code":"1214","message":"Incorrect role information"}}`
+
+**Cause**: Using wrong provider
+
+**Solution**:
+```bash
+# VERIFY in ~/.codex/config.toml
+# You must use: model_provider="zai_glm_proxy"
+# NOT: model_provider="zai"
+```
+
+### Proxy Won't Stop
+
+**Symptom**: Proxy remains active after closing Codex
+
+**Solution**:
+```bash
+# Find and kill manually
+ps aux | grep zai-codex-bridge
+kill <PID>
+
+# Or use dedicated command
+pkill -f zai-codex-bridge
+```
+
+### Debug Logging
+
+```bash
+# Proxy logs are in:
+cat /tmp/zai-codex-bridge.log
+
+# For real-time logs:
+tail -f /tmp/zai-codex-bridge.log
+
+# Restart with debug:
+codex-glm-a  # proxy will write detailed logs
+```
+
+---
+
+## Health Checks
+
+### Health Check
+
+```bash
+# Verify proxy is active
+curl http://127.0.0.1:31415/health
+# Expected: {"ok":true}
+```
+
+### Verify Configuration
+
+```bash
+# Check provider in config
+grep -A 5 "zai_glm_proxy" ~/.codex/config.toml
+
+# Check functions in .zshrc
+grep -A 30 "_codex_glm_with_proxy" ~/.zshrc
+```
+
+### Full Test
+
+```bash
+# 1. Test proxy
+zai-codex-bridge --help
+
+# 2. Test health
+curl http://127.0.0.1:31415/health
+
+# 3. Test Codex
+codex-glm-a --help
+
+# 4. Interactive test
+codex-glm-a
+# > Tell me 2+2
+# Ctrl+D
+```
+
+---
+
+## Function Reference
+
+### `_codex_glm_with_proxy()`
+
+**Parameters**:
+- `$1` - API key to use (`$ZAI_API_KEY_A` or `$ZAI_API_KEY_P`)
+- `$@` - Additional arguments passed to Codex
+
+**Behavior**:
+1. Checks health at `http://127.0.0.1:31415/health`
+2. If fails:
+   - Starts `zai-codex-bridge` in background
+   - Redirects log to `/tmp/zai-codex-bridge.log`
+   - Saves PID in `$PROXY_PID`
+   - Sets trap to kill proxy on EXIT
+   - Waits up to 2 seconds for proxy to be ready
+3. Executes `codex` with provider `zai_glm_proxy`
+
+### `codex-glm-a()`
+
+**Usage**: Account A
+```bash
+codex-glm-a [codex options]
+```
+
+**Example**:
+```bash
+codex-glm-a -s workspace-write
+codex-glm-a --help
+```
+
+### `codex-glm-p()`
+
+**Usage**: Account P
+```bash
+codex-glm-p [codex options]
+```
+
+---
+
+## Advanced Configuration
+
+### Change Port
+
+Modify the function in `~/.zshrc`:
+
+```bash
+_codex_glm_with_proxy () {
+  local KEY="$1"; shift
+  local HOST="127.0.0.1"
+  local PORT="8080"  # ← Change here
+  # ...
+}
+```
+
+And update `~/.codex/config.toml`:
+
+```toml
+[model_providers.zai_glm_proxy]
+base_url = "http://127.0.0.1:8080/v1"
+```
+
+### Verbose Logging
+
+Modify the log level in the proxy command:
+
+```bash
+zai-codex-bridge --host "$HOST" --port "$PORT" --log-level debug >"$LOGFILE" 2>&1 &
+```
+
+---
+
+## Performance
+
+### Startup Times
+
+| Operation | Time |
+|-----------|------|
+| Health check (proxy running) | ~50ms |
+| Health check (proxy not running) | ~2s |
+| Proxy startup | ~500ms |
+| Codex startup | ~1s |
+| **Total (first time)** | **~3.5s** |
+| **Total (proxy already up)** | **~1.5s** |
+
+### Memory
+
+| Process | RAM |
+|----------|-----|
+| zai-codex-bridge | ~30-50MB |
+| codex CLI | ~100-200MB |
+| **Total** | **~130-250MB** |
+
+---
+
+## Setup Checklist
+
+- [ ] Proxy installed: `npm install -g @mmmbuto/zai-codex-bridge`
+- [ ] API keys set: `export ZAI_API_KEY_A=...`
+- [ ] Provider configured: `[model_providers.zai_glm_proxy]` in config.toml
+- [ ] Functions updated: `source ~/.zshrc`
+- [ ] Test health: `curl http://127.0.0.1:31415/health`
+- [ ] Full test: `codex-glm-a`
+
+---
+
+## Related Files
+
+- **Proxy Code**: `~/Dev/zai-codex-bridge/`
+- **Codex Config**: `~/.codex/config.toml`
+- **ZSH Functions**: `~/.zshrc`
+
+---
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@mmmbuto/zai-codex-bridge",
+  "version": "0.1.0",
+  "description": "Local proxy that translates OpenAI Responses API format to Z.AI Chat Completions format for Codex",
+  "main": "src/server.js",
+  "bin": {
+    "zai-codex-bridge": "./bin/zai-codex-bridge"
+  },
+  "scripts": {
+    "start": "node src/server.js",
+    "test:curl": "node scripts/test-curl.js"
+  },
+  "keywords": [
+    "codex",
+    "zai",
+    "glm",
+    "proxy",
+    "openai",
+    "responses-api",
+    "chat-completions"
+  ],
+  "author": "Davide A. Guglielmi",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DioNanos/zai-codex-bridge.git"
+  }
+}

package/scripts/test-curl.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+/**
+ * Manual test script for zai-codex-bridge
+ *
+ * Tests the proxy with a minimal Responses API payload.
+ */
+
+const http = require('http');
+
+const PROXY_HOST = process.env.PROXY_HOST || '127.0.0.1';
+const PROXY_PORT = process.env.PROXY_PORT || '31415';
+const ZAI_API_KEY = process.env.ZAI_API_KEY || process.env.OPENAI_API_KEY || '';
+
+async function testHealth() {
+  console.log('\n=== Testing Health Endpoint ===\n');
+
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: PROXY_HOST,
+      port: PROXY_PORT,
+      path: '/health',
+      method: 'GET'
+    };
+
+    const req = http.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        console.log('Status:', res.statusCode);
+        console.log('Response:', body);
+        resolve();
+      });
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function testResponsesFormat() {
+  console.log('\n=== Testing POST /v1/responses (Non-Streaming) ===\n');
+
+  const payload = {
+    model: 'GLM-4.7',
+    instructions: 'You are a helpful assistant. Be brief.',
+    input: [
+      {
+        role: 'user',
+        content: 'What is 2+2? Answer with just the number.'
+      }
+    ],
+    stream: false
+  };
+
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: PROXY_HOST,
+      port: PROXY_PORT,
+      path: '/v1/responses',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${ZAI_API_KEY}`
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        console.log('Status:', res.statusCode);
+        console.log('Response:', body);
+        try {
+          const parsed = JSON.parse(body);
+          console.log('\nParsed output:', parsed.output?.[0]?.value);
+        } catch (e) {
+          console.log('\nFailed to parse response');
+        }
+        resolve();
+      });
+    });
+
+    req.on('error', reject);
+    req.write(JSON.stringify(payload, null, 2));
+    req.end();
+  });
+}
+
+async function testStreamingFormat() {
+  console.log('\n=== Testing POST /v1/responses (Streaming) ===\n');
+
+  const payload = {
+    model: 'GLM-4.7',
+    instructions: 'You are a helpful assistant.',
+    input: [
+      {
+        role: 'user',
+        content: 'Count from 1 to 3.'
+      }
+    ],
+    stream: true
+  };
+
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: PROXY_HOST,
+      port: PROXY_PORT,
+      path: '/v1/responses',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${ZAI_API_KEY}`
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      console.log('Status:', res.statusCode);
+      console.log('Headers:', JSON.stringify(res.headers, null, 2));
+      console.log('\nStreaming response:');
+
+      res.on('data', (chunk) => {
+        process.stdout.write(chunk);
+      });
+
+      res.on('end', () => {
+        console.log('\n\n=== Stream Complete ===');
+        resolve();
+      });
+    });
+
+    req.on('error', reject);
+    req.write(JSON.stringify(payload, null, 2));
+    req.end();
+  });
+}
+
+async function main() {
+  console.log('zai-codex-bridge Manual Test');
+  console.log('================================');
+  console.log('Proxy:', `http://${PROXY_HOST}:${PROXY_PORT}`);
+  console.log('API Key:', ZAI_API_KEY ? 'Set' : 'NOT SET - set ZAI_API_KEY or OPENAI_API_KEY');
+
+  if (!ZAI_API_KEY) {
+    console.error('\nError: No API key found. Set ZAI_API_KEY or OPENAI_API_KEY environment variable.');
+    process.exit(1);
+  }
+
+  try {
+    await testHealth();
+    await testResponsesFormat();
+    await testStreamingFormat();
+
+    console.log('\n=== All Tests Complete ===\n');
+  } catch (error) {
+    console.error('\nError:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/src/server.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+
+/**
+ * zai-codex-bridge
+ *
+ * Local proxy that translates OpenAI Responses API format to Z.AI Chat Completions format.
+ * Allows Codex to use Z.AI GLM models through the /responses endpoint.
+ *
+ * Author: Davide A. Guglielmi
+ * License: MIT
+ */
+
+const http = require('http');
+
+// Configuration from environment
+const PORT = parseInt(process.env.PORT || '31415', 10);
+const HOST = process.env.HOST || '127.0.0.1';
+const ZAI_BASE_URL = process.env.ZAI_BASE_URL || 'https://api.z.ai/api/coding/paas/v4';
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+
+/**
+ * Logger
+ */
+function log(level, ...args) {
+  const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  if (levels[level] >= levels[LOG_LEVEL]) {
+    console.error(`[${level.toUpperCase()}]`, new Date().toISOString(), ...args);
+  }
+}
+
+/**
+ * Detect if request body is Responses format or Chat format
+ */
+function detectFormat(body) {
+  if (body.instructions !== undefined || body.input !== undefined) {
+    return 'responses';
+  }
+  if (body.messages !== undefined) {
+    return 'chat';
+  }
+  return 'unknown';
+}
+
+/**
+ * Flatten content parts to string
+ */
+function flattenContent(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const textParts = content
+      .filter(part => part.type === 'text' && part.text)
+      .map(part => part.text);
+    return textParts.length > 0 ? textParts.join('\n') : JSON.stringify(content);
+  }
+  return String(content);
+}
+
+/**
+ * Translate Responses format to Chat Completions format
+ */
+function translateResponsesToChat(request) {
+  const messages = [];
+
+  // Add system message from instructions
+  if (request.instructions) {
+    messages.push({
+      role: 'system',
+      content: request.instructions
+    });
+  }
+
+  // Add messages from input array
+  if (request.input && Array.isArray(request.input)) {
+    for (const item of request.input) {
+      const msg = {
+        role: item.role,
+        content: flattenContent(item.content)
+      };
+
+      // Handle tool calls if present
+      if (item.tool_calls && Array.isArray(item.tool_calls)) {
+        msg.tool_calls = item.tool_calls;
+      }
+
+      // Handle tool call ID for tool responses
+      if (item.tool_call_id) {
+        msg.tool_call_id = item.tool_call_id;
+      }
+
+      messages.push(msg);
+    }
+  }
+
+  // Build chat request
+  const chatRequest = {
+    model: request.model,
+    messages: messages,
+    stream: request.stream !== false // default true
+  };
+
+  // Map optional fields
+  if (request.max_output_tokens) {
+    chatRequest.max_tokens = request.max_output_tokens;
+  } else if (request.max_tokens) {
+    chatRequest.max_tokens = request.max_tokens;
+  }
+
+  if (request.temperature !== undefined) {
+    chatRequest.temperature = request.temperature;
+  }
+
+  if (request.top_p !== undefined) {
+    chatRequest.top_p = request.top_p;
+  }
+
+  if (request.tools && Array.isArray(request.tools)) {
+    chatRequest.tools = request.tools;
+  }
+
+  if (request.tool_choice) {
+    chatRequest.tool_choice = request.tool_choice;
+  }
+
+  log('debug', 'Translated Responses->Chat:', {
+    messagesCount: messages.length,
+    model: chatRequest.model,
+    stream: chatRequest.stream
+  });
+
+  return chatRequest;
+}
+
+/**
+ * Translate Chat Completions response to Responses format
+ */
+function translateChatToResponses(chatResponse) {
+  let text = '';
+
+  // Extract content from Chat format
+  if (chatResponse.choices && chatResponse.choices.length > 0) {
+    const choice = chatResponse.choices[0];
+    if (choice.message && choice.message.content) {
+      text = choice.message.content;
+    }
+  }
+
+  // Map usage
+  const usage = {};
+  if (chatResponse.usage) {
+    if (chatResponse.usage.prompt_tokens) {
+      usage.input_tokens = chatResponse.usage.prompt_tokens;
+    }
+    if (chatResponse.usage.completion_tokens) {
+      usage.output_tokens = chatResponse.usage.completion_tokens;
+    }
+    if (chatResponse.usage.total_tokens) {
+      usage.total_tokens = chatResponse.usage.total_tokens;
+    }
+  }
+
+  const response = {
+    output: [{
+      value: text,
+      content_type: 'text'
+    }],
+    status: 'completed',
+    usage: Object.keys(usage).length > 0 ? usage : undefined
+  };
+
+  log('debug', 'Translated Chat->Responses:', {
+    outputLength: text.length,
+    status: response.status
+  });
+
+  return response;
+}
+
+/**
+ * Make upstream request to Z.AI
+ */
+async function makeUpstreamRequest(path, body, headers) {
+  const url = new URL(path, ZAI_BASE_URL);
+
+  const upstreamHeaders = {
+    'Content-Type': 'application/json',
+    'Authorization': headers['authorization'] || headers['Authorization'] || ''
+  };
+
+  log('debug', 'Upstream request:', {
+    url: url.href,
+    hasAuth: !!upstreamHeaders.Authorization
+  });
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: upstreamHeaders,
+    body: JSON.stringify(body)
+  });
+
+  return response;
+}
+
+/**
+ * Handle streaming response from Z.AI
+ */
+async function* streamChatToResponses(stream, res) {
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  for await (const chunk of stream) {
+    buffer += decoder.decode(chunk, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim() || !line.startsWith('data: ')) continue;
+
+      const data = line.slice(6).trim();
+
+      // Check for stream end
+      if (data === '[DONE]') {
+        res.write(`event: completed\n`);
+        res.write(`data: ${JSON.stringify({ status: 'completed' })}\n\n`);
+        return;
+      }
+
+      try {
+        const parsed = JSON.parse(data);
+        const delta = parsed.choices?.[0]?.delta;
+
+        if (delta?.content) {
+          res.write(`event: output.text.delta\n`);
+          res.write(`data: ${JSON.stringify({ value: delta.content })}\n\n`);
+        }
+      } catch (e) {
+        log('warn', 'Failed to parse SSE chunk:', e.message);
+      }
+    }
+  }
+}
+
+/**
+ * Handle POST requests
+ */
+async function handlePostRequest(req, res) {
+  const path = req.url;
+
+  // Only handle /responses and /v1/responses
+  if (!path.endsWith('/responses') && !path.endsWith('/v1/responses')) {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not Found', path }));
+    return;
+  }
+
+  let body = '';
+  for await (const chunk of req) {
+    body += chunk.toString();
+  }
+
+  let request;
+  try {
+    request = JSON.parse(body);
+  } catch (e) {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+    return;
+  }
+
+  log('info', 'Incoming request:', {
+    path,
+    format: detectFormat(request),
+    model: request.model
+  });
+
+  let upstreamBody;
+  const format = detectFormat(request);
+
+  if (format === 'responses') {
+    // Translate Responses to Chat
+    upstreamBody = translateResponsesToChat(request);
+  } else if (format === 'chat') {
+    // Pass through Chat format
+    upstreamBody = request;
+  } else {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Unknown request format' }));
+    return;
+  }
+
+  try {
+    const upstreamResponse = await makeUpstreamRequest(
+      '/chat/completions',
+      upstreamBody,
+      req.headers
+    );
+
+    if (!upstreamResponse.ok) {
+      const errorBody = await upstreamResponse.text();
+      log('error', 'Upstream error:', {
+        status: upstreamResponse.status,
+        body: errorBody.substring(0, 200)
+      });
+
+      res.writeHead(502, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        error: 'Upstream request failed',
+        upstream_status: upstreamResponse.status,
+        upstream_body: errorBody
+      }));
+      return;
+    }
+
+    // Handle streaming response
+    if (upstreamBody.stream) {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream; charset=utf-8',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive'
+      });
+
+      await streamChatToResponses(upstreamResponse.body, res);
+      res.end();
+    } else {
+      // Non-streaming response
+      const chatResponse = await upstreamResponse.json();
+      const response = translateChatToResponses(chatResponse);
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(response));
+    }
+  } catch (error) {
+    log('error', 'Request failed:', error);
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: error.message }));
+  }
+}
+
+/**
+ * Create HTTP server
+ */
+const server = http.createServer(async (req, res) => {
+  log('debug', 'Request:', req.method, req.url);
+
+  // Health check
+  if (req.url === '/health' && req.method === 'GET') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ ok: true }));
+    return;
+  }
+
+  // POST /responses
+  if (req.method === 'POST') {
+    await handlePostRequest(req, res);
+    return;
+  }
+
+  // 404
+  res.writeHead(404, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ error: 'Not Found' }));
+});
+
+/**
+ * Start server
+ */
+server.listen(PORT, HOST, () => {
+  log('info', `zai-codex-bridge listening on http://${HOST}:${PORT}`);
+  log('info', `Proxying to Z.AI at: ${ZAI_BASE_URL}`);
+  log('info', `Health check: http://${HOST}:${PORT}/health`);
+});