@ahoo-wang/godex 0.0.16 → 0.0.17

package/README.md

@@ -1,19 +1,104 @@
-# Godex
+<div align="center">
 
-OpenAI Responses API gateway — translates `/v1/responses` into upstream Chat Completions API calls, so **any LLM provider can drive Codex**.
+<img src="design/assets/01-logo-system/png/godex-logo-horizontal-transparent-800x233.png" alt="GodeX" width="480" />
 
-[![codecov](https://codecov.io/gh/Ahoo-Wang/Godex/graph/badge.svg?token=dJQrmUAiXu)](https://codecov.io/gh/Ahoo-Wang/Godex)
+**Make every model a Codex engine.**
+
+OpenAI-compatible Responses API gateway — translates `/v1/responses` into upstream Chat Completions API calls, connecting Codex, CLI, IDE, and automation tools with any model provider.
+
+[![npm version](https://img.shields.io/npm/v/@ahoo-wang/godex?logo=npm)](https://www.npmjs.com/package/@ahoo-wang/godex)
+[![codecov](https://codecov.io/gh/Ahoo-Wang/GodeX/graph/badge.svg?token=dJQrmUAiXu)](https://codecov.io/gh/Ahoo-Wang/GodeX)
 [![Bun](https://img.shields.io/badge/runtime-bun-f9f1e0?logo=bun)](https://bun.sh)
 [![TypeScript](https://img.shields.io/badge/lang-typescript-3178c6?logo=typescript)](https://www.typescriptlang.org/)
 
+[Getting Started](https://godex.ahoo.me/01-getting-started/overview) · [Architecture](https://godex.ahoo.me/02-architecture/overview) · [Configuration](https://godex.ahoo.me/07-configuration/config-schema) · [Documentation](https://godex.ahoo.me)
+
+</div>
+
+## Features
+
+| | Feature | Description |
+|---|---------|-------------|
+| 🔄 | **Protocol Translation** | Bridges OpenAI Responses API and provider-specific Chat Completions APIs |
+| 🔌 | **Provider-agnostic** | Plugin-based adapter system — add providers by implementing a small set of interfaces |
+| ⚡ | **Streaming-first** | 4-stage `TransformStream` pipeline for low-latency SSE delivery |
+| 💾 | **Session History** | Built-in `previous_response_id` chain resolution (SQLite / in-memory) |
+| 🛡️ | **Structured Errors** | Domain-specific error hierarchy with structured codes and diagnostic context |
+| 🔧 | **Built-in Tools** | `local_shell`, `shell`, `apply_patch` — Codex-compatible function tools |
+| 📦 | **Standalone Binary** | Zero runtime dependencies, 6 platform builds via GitHub Actions |
+
+## Quick Start
+
+```bash
+# Install — no Bun required at runtime
+npm install -g @ahoo-wang/godex
+
+# Create config interactively
+godex init
+
+# Start the gateway
+godex serve
+```
+
+Point Codex CLI at your GodeX instance:
+
+```bash
+export OPENAI_BASE_URL=http://localhost:5678/v1
+export OPENAI_API_KEY=any-value          # not validated by GodeX, must be set
+codex
+```
+
+Or use the OpenAI SDK:
+
+```ts
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  baseURL: "http://localhost:5678/v1",
+  apiKey: "any-value",
+});
+
+const response = await client.responses.create({
+  model: "gpt-4o",          // mapped to glm-4.7 via godex.yaml models table
+  input: "Hello!",
+});
+```
+
+## How It Works
+
+```
+Codex / CLI / IDE
+      │
+      ▼  POST /v1/responses
+┌─────────────────────────────────────────┐
+│              GodeX Gateway              │
+│                                         │
+│  Bun.serve → handleResponses()          │
+│       → ResponsesContext.create()       │
+│           → ModelResolver.resolve()     │
+│           → Registrar.resolve()         │
+│       → DefaultAdapter.stream/request() │
+│           → ProviderMapper.map()        │
+│           → ChatClient.streamChat()     │
+│           → 4-stage TransformStream     │
+│       → Response (JSON or SSE)          │
+└──────────────┬──────────────────────────┘
+               │  Provider Adapter
+               ▼
+┌─────────────────────────────────────────┐
+│       Chat Completions-compatible API   │
+│       (Zhipu, OpenAI, or custom)        │
+└─────────────────────────────────────────┘
+```
+
 ## Architecture
 
 ```mermaid
 C4Context
-  title Godex — System Context
+  title GodeX — System Context
 
   Person(user, "Developer / Codex CLI", "Sends Responses API requests<br/>via the OpenAI-compatible endpoint")
-  System(godex_svr, "Godex Server", "Translates Responses API → Chat Completions API<br/>Bun HTTP server on configurable port")
+  System(godex_svr, "GodeX Server", "Translates Responses API → Chat Completions API<br/>Bun.serve on configurable port")
   SystemDb(sessions, "Session Store", "Stores response history for<br/>previous_response_id chain resolution<br/>SQLite (persistent) or In-Memory")
   System_Ext(zhipu, "Zhipu (智谱)", "Chat Completions API provider")
   System_Ext(openai, "OpenAI", "Chat Completions API provider")
@@ -26,72 +111,6 @@ C4Context
   Rel(godex_svr, other, "POST /chat/completions", "HTTPS")
 ```
 
-## Request Flow
-
-```mermaid
-sequenceDiagram
-  actor C as Client (Codex CLI)
-  participant R as Router
-  participant AC as ApplicationContext
-  participant RC as ResponsesContext
-  participant MR as ModelResolver
-  participant SS as SessionStore
-  participant REG as Registrar
-  participant A as Adapter (DefaultAdapter)
-  participant PM as ProviderMapper
-  participant CC as ChatClient
-  participant UP as Upstream API
-
-  C->>R: POST /v1/responses
-  R->>RC: ResponsesContext.create(app, body)
-
-  activate RC
-    RC->>MR: resolve(model)
-    MR-->>RC: { provider, model }
-    RC->>RC: validate provider config
-
-    opt previous_response_id
-      RC->>SS: resolveChain(id)
-      SS-->>RC: session snapshot
-    end
-
-    RC->>REG: resolve(provider)
-    REG-->>RC: Provider instance
-  deactivate RC
-
-  alt stream = true
-    R->>A: adapter.stream(ctx)
-    activate A
-      A->>PM: request.map(ctx)
-      PM-->>A: upstream request
-      A->>CC: streamChat(req)
-      CC->>UP: POST (SSE)
-      UP-->>CC: SSE chunks
-      CC-->>A: ReadableStream<SSE>
-      A->>A: pipeTransform → ProviderEventToResponseTransformer
-      A->>A: pipeTransform → ResponseSessionPersistenceTransformer
-      A-->>R: ReadableStream<ResponseStreamEvent>
-    deactivate A
-    R->>R: pipeTransform → ResponseSseEncodeTransformer
-    R-->>C: SSE byte stream
-  else stream = false
-    R->>A: adapter.request(ctx)
-    activate A
-      A->>PM: request.map(ctx)
-      PM-->>A: upstream request
-      A->>CC: chat(req)
-      CC->>UP: POST
-      UP-->>CC: JSON response
-      CC-->>A: upstream response
-      A->>PM: response.map(ctx, res)
-      PM-->>A: ResponseObject
-      A->>SS: save(session)
-      A-->>R: ResponseObject
-    deactivate A
-    R-->>C: JSON response
-  end
-```
-
 ## Component Model
 
 ```mermaid
@@ -99,7 +118,7 @@ classDiagram
   direction TB
 
   class ApplicationContext {
-    +config: GodexConfig
+    +config: GodeXConfig
     +logger: Logger
     +resolver: ModelResolver
     +registrar: Registrar
@@ -115,7 +134,7 @@ classDiagram
     +provider: Provider
     +responseId: string
     +requestId: string
-    +logger: Logger
+    +attributes: Map
     +create(app, body)$ Promise~ResponsesContext~
   }
 
@@ -130,7 +149,6 @@ classDiagram
     +registerFactory(name, factory)
     +build(providers)
     +resolve(name) Provider
-    +list() string[]
   }
 
   class Adapter {
@@ -165,22 +183,6 @@ classDiagram
     +streamChat(req) Promise~ReadableStream~
   }
 
-  class RequestMapper {
-    <<interface>>
-    +map(ctx) TReq
-  }
-
-  class ResponseMapper {
-    <<interface>>
-    +map(ctx, result) ResponseObject
-  }
-
-  class StreamMapper {
-    <<interface>>
-    +map(ctx, event) ResponseStreamEvent[]
-    +buildResponseObject(ctx, state) ResponseObject
-  }
-
   class ResponseSessionStore {
     <<interface>>
     +get(id) StoredResponseSession
@@ -190,12 +192,6 @@ classDiagram
     +close()
   }
 
-  class Router {
-    -routes: Route[]
-    +register(route)
-    +dispatch(req) Promise~Response~
-  }
-
   ApplicationContext --> ResponsesContext : creates
   ApplicationContext --> ModelResolver
   ApplicationContext --> Registrar
@@ -204,14 +200,65 @@ classDiagram
   ResponsesContext --> Provider : uses
   Provider --> ProviderMapper
   Provider --> ChatClient
-  ProviderMapper --> RequestMapper
-  ProviderMapper --> ResponseMapper
-  ProviderMapper --> StreamMapper
   Adapter <|.. DefaultAdapter
   DefaultAdapter --> ProviderMapper : calls
   DefaultAdapter --> ChatClient : calls
   DefaultAdapter --> ResponseSessionStore : saves
-  Router --> ResponsesContext : dispatches to
+```
+
+## Request Flow
+
+```mermaid
+sequenceDiagram
+  actor C as Client (Codex CLI)
+  participant H as handleResponses
+  participant RC as ResponsesContext
+  participant MR as ModelResolver
+  participant SS as SessionStore
+  participant REG as Registrar
+  participant A as DefaultAdapter
+  participant PM as ProviderMapper
+  participant CC as ChatClient
+  participant UP as Upstream API
+
+  C->>H: POST /v1/responses
+  H->>RC: ResponsesContext.create(app, body)
+  activate RC
+    RC->>MR: resolve(model)
+    MR-->>RC: { provider, model }
+    opt previous_response_id
+      RC->>SS: resolveChain(id)
+      SS-->>RC: session snapshot
+    end
+    RC->>REG: resolve(provider)
+    REG-->>RC: Provider instance
+  deactivate RC
+
+  alt stream = true
+    H->>A: adapter.stream(ctx)
+    activate A
+      A->>PM: mapper.request.map(ctx)
+      A->>CC: chatClient.streamChat(req)
+      CC->>UP: POST (SSE)
+      UP-->>CC: SSE chunks
+      A->>A: pipeTransform → ProviderEventToResponse
+      A->>A: pipeTransform → ResponseLog
+      A->>A: pipeTransform → ResponseSessionPersistence
+    deactivate A
+    H->>H: pipeTransform → ResponseSseEncode
+    H-->>C: SSE byte stream
+  else stream = false
+    H->>A: adapter.request(ctx)
+    activate A
+      A->>PM: mapper.request.map(ctx)
+      A->>CC: chatClient.chat(req)
+      CC->>UP: POST
+      UP-->>A: upstream response
+      A->>PM: mapper.response.map(ctx, res)
+      A->>SS: save(session)
+    deactivate A
+    H-->>C: JSON response
+  end
 ```
 
 ## Stream Pipeline
@@ -219,120 +266,65 @@ classDiagram
 ```mermaid
 flowchart LR
   subgraph upstream["Upstream Provider"]
-    SSE["SSE Chunks<br/>(JsonServerSentEvent)"]
+    SSE["SSE Chunks"]
   end
 
-  subgraph godex["Godex Stream Pipeline"]
-    T1["ProviderEventTo<br/>ResponseTransformer"]
-    T2["ResponseSession<br/>PersistenceTransformer"]
-    T3["ResponseSse<br/>EncodeTransformer"]
+  subgraph godex["GodeX Stream Pipeline"]
+    T1["① ProviderEventToResponse"]
+    T2["② ResponseLog"]
+    T3["③ SessionPersistence"]
+  end
+
+  subgraph server["HTTP Response"]
+    T4["④ SseEncode"]
   end
 
   subgraph client["Client"]
-    BYTES["SSE Bytes<br/>(text/event-stream)"]
+    BYTES["SSE Bytes"]
   end
 
-  SSE -->|"pipeThrough(TransformStream)"| T1
-  T1 -->|"per-event map()<br/>SSE chunk → ResponseStreamEvent[]"| T2
-  T2 -->|"accumulate StreamState<br/>intercept terminal event<br/>buildResponseObject()<br/>save session"| T3
-  T3 -->|"serialize to SSE wire format<br/>event: xxx\ndata: {...}\n\n"| BYTES
+  SSE -->|pipeThrough| T1
+  T1 -->|map per event| T2
+  T2 -->|log + pass through| T3
+  T3 -->|accumulate + save session| T4
+  T4 -->|serialize SSE wire format| BYTES
 
   style upstream fill:#1a1a2e,stroke:#16213e,color:#e0e0e0
   style godex fill:#0f3460,stroke:#16213e,color:#e0e0e0
+  style server fill:#1c2333,stroke:#16213e,color:#e0e0e0
   style client fill:#1a1a2e,stroke:#16213e,color:#e0e0e0
 ```
 
-### Transformer Roles
-
-| Stage | Transformer | Input | Output | Side Effects |
-|-------|------------|-------|--------|-------------|
-| 1 | `ProviderEventToResponseTransformer` | `JsonServerSentEvent<TChunk>` | `ResponseStreamEvent` | Calls `StreamMapper.map()` per event |
-| 2 | `ResponseSessionPersistenceTransformer` | `ResponseStreamEvent` | `ResponseStreamEvent` | Accumulates `StreamState`, on terminal event calls `buildResponseObject()` + saves session (skipped when `store=false`) |
-| 3 | `ResponseSseEncodeTransformer` | `ResponseStreamEvent` | `Uint8Array` (SSE wire format) | Serializes to `event:` / `data:` lines |
-
-## Error Hierarchy
-
-```mermaid
-classDiagram
-  direction TB
-
-  class GodexError {
-    +name: string
-    +code: string
-    +status: number
-    +context: object
-    +toLogEntry() object
-  }
-
-  class ServerError {
-    +status: 400-499
-    +context: object
-  }
-
-  class AdapterError {
-    +status: 400-499
-    +context: unsupported parameters / tools / input items
-  }
-
-  class ProviderError {
-    +status: 502
-    +context: upstream status / body / headers
-  }
-
-  class SessionError {
-    +status: 400-409
-    +context: chain metadata
-  }
-
-  GodexError <|-- ServerError
-  GodexError <|-- AdapterError
-  GodexError <|-- ProviderError
-  GodexError <|-- SessionError
-
-  note for GodexError "Base error with structured logging support.<br/>All errors carry domain codes (e.g. server.request.invalid_json)."
-  note for ProviderError "Wraps upstream HTTP failures:<br/>rate limits, timeouts, 5xx."
-  note for SessionError "Chain resolution failures:<br/>not found, cycles, depth exceeded."
-```
+| Stage | Transformer | Input | Output | Role |
+|-------|------------|-------|--------|------|
+| ① | `ProviderEventToResponseTransformer` | `JsonServerSentEvent` | `ResponseStreamEvent` | Maps upstream SSE chunks via `StreamMapper.map()` |
+| ② | `ResponseLogTransformer` | `ResponseStreamEvent` | `ResponseStreamEvent` | Logs stream events for observability |
+| ③ | `ResponseSessionPersistenceTransformer` | `ResponseStreamEvent` | `ResponseStreamEvent` | Accumulates `StreamState`, saves session on terminal event |
+| ④ | `ResponseSseEncodeTransformer` | `ResponseStreamEvent` | `Uint8Array` | Serializes to `event:` / `data:` wire format |
 
 ## Project Structure
 
 ```
 src/
-├── cli/              Commander CLI (serve, config check, init)
+├── cli/              Commander CLI (serve, config, init)
 ├── config/           godex.yaml schema, env interpolation, defaults
-├── context/          ApplicationContext (DI container), ResponsesContext (per-request)
+├── context/          ApplicationContext (DI), ResponsesContext (per-request)
 ├── adapter/          Adapter interface, DefaultAdapter, stream transformers
 │   ├── mapper/       RequestMapper / ResponseMapper / StreamMapper contracts
-│   └── transformers/ ProviderEvent → Response → SSE encode pipeline
+│   └── transformers/ 4-stage stream pipeline (map → log → persist → encode)
 ├── providers/        Provider registry + builtin factories
 │   └── zhipu/        Reference provider: mapper, chat-client, tools, messages
 ├── resolver/         ModelResolver (model selector → provider + model)
-├── server/           Bun HTTP server, Router, routes (/v1/responses, /health, /v1/models)
+├── server/           Bun.serve, routes (/v1/responses, /health, /v1/models)
 ├── session/          ResponseSessionStore (Memory + SQLite), chain resolution
-├── error/            GodexError hierarchy with domain codes
+├── error/            GodeXError hierarchy with domain codes
+├── tools/            Built-in function tools (local_shell, shell, apply_patch)
 ├── protocol/openai/  OpenAI-compatible type definitions
 ├── logger/           Structured JSON logger
 └── e2e/              End-to-end tests with mocked upstream
 ```
 
-## Quick Start
-
-```bash
-# Install dependencies
-bun install
-
-# Build standalone binary (current platform)
-bun run build
-
-# Create config interactively
-bun run start -- init
-
-# Start server (default port 5678)
-bun run dev
-
-# Or run the compiled binary directly
-./platforms/darwin-arm64/bin/godex serve
-```
+## Configuration
 
 ### godex.yaml
 
@@ -359,115 +351,65 @@ logging:
   level: info                   # trace | debug | info | warn | error
 ```
 
-### Adding a Provider
+### Model Selection
 
-Implement these interfaces in `src/providers/<name>/`:
-
-| Interface | Purpose |
-|-----------|---------|
-| `Provider<TReq, TRes, TChunk>` | Bundles mapper + chatClient + capabilities |
-| `ProviderMapper<TReq, TRes, TChunk>` | request / response / stream mapping functions |
-| `ChatClient<TReq, TRes, TChunk>` | `chat()` and `streamChat()` HTTP calls |
-
-Register the factory in `src/providers/builtin.ts`:
-
-```ts
-registrar.registerFactory("myprovider", (config) =>
-  createMyProvider(config) as Provider<unknown, unknown, unknown>
-);
 ```
-
-## Usage
-
-```bash
-# Install — no Bun required at runtime
-npm install -g @ahoo-wang/godex
-
-# Create config interactively
-godex init
-
-# Start the gateway
-godex serve
+model: "gpt-4o"              → resolved via default_provider model mapping
+model: "zhipu/glm-4.7"       → explicit provider/model selector
+model: "openai/gpt-4o"       → routes to configured openai provider
 ```
 
-Godex ships as a **standalone native binary** with zero runtime dependencies. npm's `postinstall` automatically selects the correct binary for your platform. The only prerequisite is Node.js >= 18 (needed only during `npm install`).
-
-Godex exposes an **OpenAI-compatible Responses API** at `http://localhost:5678` (port is configurable). Point any tool that speaks the OpenAI protocol at this endpoint:
-
-### With Codex CLI
+### Health Check
 
 ```bash
-export OPENAI_BASE_URL=http://localhost:5678/v1
-export OPENAI_API_KEY=any-value          # not validated by Godex, must be set
-codex
+curl http://localhost:5678/health
+# {"status":"ok","providers":["zhipu"],"unsupported_providers":[]}
 ```
 
-### With OpenAI SDK
-
-```ts
-import OpenAI from "openai";
+### Adding a Provider
 
-const client = new OpenAI({
-  baseURL: "http://localhost:5678/v1",
-  apiKey: "any-value",      // passed through, not validated
-});
+Implement three interfaces in `src/providers/<name>/`:
 
-const response = await client.responses.create({
-  model: "gpt-4o",          // mapped to glm-4.7 via godex.yaml models table
-  input: "Hello!",
-});
-```
+| Interface | Purpose |
+|-----------|---------|
+| `Provider` | Bundles mapper + chatClient + capabilities |
+| `ProviderMapper` | request / response / stream mapping functions |
+| `ChatClient` | `chat()` and `streamChat()` HTTP calls |
 
-### Model selection
+Register the factory in `src/providers/builtin.ts`:
 
+```ts
+registrar.registerFactory("myprovider", (config) =>
+  createMyProvider(config) as Provider<unknown, unknown, unknown>
+);
 ```
-model: "gpt-4o"              → resolved via default_provider model mapping
-model: "zhipu/glm-4.7"       → explicit provider/model selector
-model: "openai/gpt-4o"       → routes to configured openai provider
-```
-
-The `models` map in `godex.yaml` lets you translate standard model names into provider-native ones — no code changes needed in the client.
 
-### Health check
+## Development
 
 ```bash
-curl http://localhost:5678/health
-# {"status":"ok","providers":["zhipu"],"unsupported_providers":[]}
+bun install                  # Install dependencies
+bun run dev                  # Dev server with hot reload (port 13145)
+bun run test                 # Unit + integration tests
+bun run test:e2e             # E2E tests with mocked upstream
+bun run build                # Build standalone binary for current platform
+bun run check                # typecheck + lint + test
+bun run ci                   # Full CI pipeline
 ```
 
 ## Publishing
 
-The main `@ahoo-wang/godex` npm package is a lightweight shell. Native binaries are shipped as platform-specific optional dependencies:
+`@ahoo-wang/godex` is a lightweight npm wrapper. Native binaries ship as platform-specific optional dependencies:
 
 ```
-@ahoo-wang/godex (wrapper package, 0 runtime deps)
-├── engines: { node: ">=18.0.0" }    ← only for postinstall
-├── postinstall: scripts/install.cjs   ← detects platform, links binary
-└── optionalDependencies:
-    ├── @ahoo-wang/godex-darwin-arm64           ← macOS Apple Silicon
-    ├── @ahoo-wang/godex-darwin-x64             ← macOS Intel
-    ├── @ahoo-wang/godex-linux-x64              ← Linux x86_64
-    ├── @ahoo-wang/godex-linux-arm64            ← Linux ARM64
-    ├── @ahoo-wang/godex-win32-x64              ← Windows x86_64
-    └── @ahoo-wang/godex-win32-arm64            ← Windows ARM64
-
-# Publishing flow:
-# 1. Make the GitHub repository public, configure NPM_TOKEN, then push the release commit.
-# 2. Create a GitHub Release tagged vX.Y.Z.
-# 3. The Release workflow builds all platform binaries.
-# 4. The Release workflow uploads binary archives and SHA256SUMS to Release Assets.
-# 5. The Release workflow publishes platform packages first, then @ahoo-wang/godex.
+@ahoo-wang/godex
+├── @ahoo-wang/godex-darwin-arm64     ← macOS Apple Silicon
+├── @ahoo-wang/godex-darwin-x64       ← macOS Intel
+├── @ahoo-wang/godex-linux-x64        ← Linux x86_64
+├── @ahoo-wang/godex-linux-arm64      ← Linux ARM64
+├── @ahoo-wang/godex-win32-x64        ← Windows x86_64
+└── @ahoo-wang/godex-win32-arm64      ← Windows ARM64
 ```
 
-## Commands
+## License
 
-```bash
-bun run dev          # Hot-reload dev server on port 13145
-bun run build        # Compile native binary for current platform
-bun run compile:all  # Cross-compile all 6 platforms locally
-bun run test         # Unit + integration tests
-bun run test:e2e     # E2E with mocked upstream
-bun run typecheck    # tsc --noEmit
-bun run lint         # Biome check
-bun run ci           # Full CI pipeline
-```
+[Apache License 2.0](LICENSE)

package/README.zh-CN.md

@@ -1,19 +1,105 @@
-# Godex
+<div align="center">
 
-OpenAI Responses API 网关 — 将 `/v1/responses` 请求转换为上游 Chat Completions API 调用，让**任何 LLM 提供商都能驱动 Codex**。
+<img src="design/assets/01-logo-system/png/godex-logo-horizontal-transparent-800x233.png" alt="GodeX" width="480" />
 
-[![codecov](https://codecov.io/gh/Ahoo-Wang/Godex/graph/badge.svg?token=dJQrmUAiXu)](https://codecov.io/gh/Ahoo-Wang/Godex)
+**让每个模型都成为 Codex 引擎。**
+
+OpenAI 兼容的 Responses API 网关 — 将 `/v1/responses` 请求转换为上游 Chat Completions API 调用，连接 Codex、CLI、IDE 和自动化开发工具与不同模型供应商。
+
+[![npm version](https://img.shields.io/npm/v/@ahoo-wang/godex?logo=npm)](https://www.npmjs.com/package/@ahoo-wang/godex)
+[![codecov](https://codecov.io/gh/Ahoo-Wang/GodeX/graph/badge.svg?token=dJQrmUAiXu)](https://codecov.io/gh/Ahoo-Wang/GodeX)
 [![Bun](https://img.shields.io/badge/runtime-bun-f9f1e0?logo=bun)](https://bun.sh)
 [![TypeScript](https://img.shields.io/badge/lang-typescript-3178c6?logo=typescript)](https://www.typescriptlang.org/)
 
+[快速入门](https://godex.ahoo.me/zh/01-getting-started/overview) · [架构](https://godex.ahoo.me/zh/02-architecture/overview) · [配置](https://godex.ahoo.me/zh/07-configuration/config-schema) · [文档](https://godex.ahoo.me/zh/)
+
+</div>
+
+
+## 功能特性
+
+| | 特性 | 说明 |
+|---|------|------|
+| 🔄 | **协议转换** | 弥补 OpenAI Responses API 与提供商 Chat Completions API 之间的差距 |
+| 🔌 | **提供商无关** | 基于插件的适配器系统 — 添加提供商只需实现少量接口 |
+| ⚡ | **流式优先** | 4 阶段 `TransformStream` 管道，低延迟 SSE 传输 |
+| 💾 | **会话历史** | 内置 `previous_response_id` 链式解析（SQLite / 内存） |
+| 🛡️ | **结构化错误** | 域特定错误层次结构，带结构化编码和诊断上下文 |
+| 🔧 | **内置工具** | `local_shell`、`shell`、`apply_patch` — Codex 兼容函数工具 |
+| 📦 | **独立二进制** | 零运行时依赖，通过 GitHub Actions 构建 6 个平台 |
+
+## 快速开始
+
+```bash
+# 安装 — 运行时无需 Bun
+npm install -g @ahoo-wang/godex
+
+# 交互式创建配置
+godex init
+
+# 启动网关
+godex serve
+```
+
+将 Codex CLI 指向你的 GodeX 实例：
+
+```bash
+export OPENAI_BASE_URL=http://localhost:5678/v1
+export OPENAI_API_KEY=any-value          # GodeX 不验证此值，但必须设置
+codex
+```
+
+或使用 OpenAI SDK：
+
+```ts
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  baseURL: "http://localhost:5678/v1",
+  apiKey: "any-value",
+});
+
+const response = await client.responses.create({
+  model: "gpt-4o",          // 通过 godex.yaml 的 models 表映射为 glm-4.7
+  input: "Hello!",
+});
+```
+
+## 工作原理
+
+```
+Codex / CLI / IDE
+      │
+      ▼  POST /v1/responses
+┌─────────────────────────────────────────┐
+│              GodeX 网关                  │
+│                                         │
+│  Bun.serve → handleResponses()          │
+│       → ResponsesContext.create()       │
+│           → ModelResolver.resolve()     │
+│           → Registrar.resolve()         │
+│       → DefaultAdapter.stream/request() │
+│           → ProviderMapper.map()        │
+│           → ChatClient.streamChat()     │
+│           → 4 阶段 TransformStream      │
+│       → Response (JSON 或 SSE)          │
+└──────────────┬──────────────────────────┘
+               │  提供商适配器
+               ▼
+┌─────────────────────────────────────────┐
+│       Chat Completions 兼容 API          │
+│       (智谱、OpenAI 或自定义)             │
+└─────────────────────────────────────────┘
+```
+
 ## 架构
 
 ```mermaid
 C4Context
-  title Godex — 系统上下文
+  title GodeX — 系统上下文
 
   Person(user, "开发者 / Codex CLI", "通过 OpenAI 兼容端点<br/>发送 Responses API 请求")
-  System(godex_svr, "Godex 服务器", "转换 Responses API → Chat Completions API<br/>基于 Bun HTTP 服务器，端口可配置")
+  System(godex_svr, "GodeX 服务器", "转换 Responses API → Chat Completions API<br/>基于 Bun.serve，端口可配置")
   SystemDb(sessions, "会话存储", "存储响应历史，用于<br/>previous_response_id 链式解析<br/>SQLite（持久化）或内存")
   System_Ext(zhipu, "智谱 (Zhipu)", "Chat Completions API 提供商")
   System_Ext(openai, "OpenAI", "Chat Completions API 提供商")
@@ -26,72 +112,6 @@ C4Context
   Rel(godex_svr, other, "POST /chat/completions", "HTTPS")
 ```
 
-## 请求流程
-
-```mermaid
-sequenceDiagram
-  actor C as 客户端 (Codex CLI)
-  participant R as Router 路由
-  participant AC as ApplicationContext 应用上下文
-  participant RC as ResponsesContext 响应上下文
-  participant MR as ModelResolver 模型解析器
-  participant SS as SessionStore 会话存储
-  participant REG as Registrar 注册器
-  participant A as Adapter 适配器 (DefaultAdapter)
-  participant PM as ProviderMapper 提供商映射器
-  participant CC as ChatClient 聊天客户端
-  participant UP as 上游 API
-
-  C->>R: POST /v1/responses
-  R->>RC: ResponsesContext.create(app, body)
-
-  activate RC
-    RC->>MR: resolve(model)
-    MR-->>RC: { provider, model }
-    RC->>RC: 验证提供商配置
-
-    opt previous_response_id
-      RC->>SS: resolveChain(id)
-      SS-->>RC: 会话快照
-    end
-
-    RC->>REG: resolve(provider)
-    REG-->>RC: Provider 实例
-  deactivate RC
-
-  alt stream = true
-    R->>A: adapter.stream(ctx)
-    activate A
-      A->>PM: request.map(ctx)
-      PM-->>A: 上游请求
-      A->>CC: streamChat(req)
-      CC->>UP: POST (SSE)
-      UP-->>CC: SSE 数据块
-      CC-->>A: ReadableStream<SSE>
-      A->>A: pipeTransform → ProviderEventToResponseTransformer
-      A->>A: pipeTransform → ResponseSessionPersistenceTransformer
-      A-->>R: ReadableStream<ResponseStreamEvent>
-    deactivate A
-    R->>R: pipeTransform → ResponseSseEncodeTransformer
-    R-->>C: SSE 字节流
-  else stream = false
-    R->>A: adapter.request(ctx)
-    activate A
-      A->>PM: request.map(ctx)
-      PM-->>A: 上游请求
-      A->>CC: chat(req)
-      CC->>UP: POST
-      UP-->>CC: JSON 响应
-      CC-->>A: 上游响应
-      A->>PM: response.map(ctx, res)
-      PM-->>A: ResponseObject
-      A->>SS: save(session)
-      A-->>R: ResponseObject
-    deactivate A
-    R-->>C: JSON 响应
-  end
-```
-
 ## 组件模型
 
 ```mermaid
@@ -99,7 +119,7 @@ classDiagram
   direction TB
 
   class ApplicationContext {
-    +config: GodexConfig
+    +config: GodeXConfig
     +logger: Logger
     +resolver: ModelResolver
     +registrar: Registrar
@@ -115,7 +135,7 @@ classDiagram
     +provider: Provider
     +responseId: string
     +requestId: string
-    +logger: Logger
+    +attributes: Map
     +create(app, body)$ Promise~ResponsesContext~
   }
 
@@ -130,7 +150,6 @@ classDiagram
     +registerFactory(name, factory)
     +build(providers)
     +resolve(name) Provider
-    +list() string[]
   }
 
   class Adapter {
@@ -165,22 +184,6 @@ classDiagram
     +streamChat(req) Promise~ReadableStream~
   }
 
-  class RequestMapper {
-    <<interface>>
-    +map(ctx) TReq
-  }
-
-  class ResponseMapper {
-    <<interface>>
-    +map(ctx, result) ResponseObject
-  }
-
-  class StreamMapper {
-    <<interface>>
-    +map(ctx, event) ResponseStreamEvent[]
-    +buildResponseObject(ctx, state) ResponseObject
-  }
-
   class ResponseSessionStore {
     <<interface>>
     +get(id) StoredResponseSession
@@ -190,28 +193,73 @@ classDiagram
     +close()
   }
 
-  class Router {
-    -routes: Route[]
-    +register(route)
-    +dispatch(req) Promise~Response~
-  }
-
-  ApplicationContext --> ResponsesContext : 创建
+  ApplicationContext --> ResponsesContext : creates
   ApplicationContext --> ModelResolver
   ApplicationContext --> Registrar
   ApplicationContext --> Adapter
   ApplicationContext --> ResponseSessionStore
-  ResponsesContext --> Provider : 使用
+  ResponsesContext --> Provider : uses
   Provider --> ProviderMapper
   Provider --> ChatClient
-  ProviderMapper --> RequestMapper
-  ProviderMapper --> ResponseMapper
-  ProviderMapper --> StreamMapper
   Adapter <|.. DefaultAdapter
-  DefaultAdapter --> ProviderMapper : 调用
-  DefaultAdapter --> ChatClient : 调用
-  DefaultAdapter --> ResponseSessionStore : 保存
-  Router --> ResponsesContext : 分发至
+  DefaultAdapter --> ProviderMapper : calls
+  DefaultAdapter --> ChatClient : calls
+  DefaultAdapter --> ResponseSessionStore : saves
+```
+
+## 请求流程
+
+```mermaid
+sequenceDiagram
+  actor C as 客户端 (Codex CLI)
+  participant H as handleResponses
+  participant RC as ResponsesContext
+  participant MR as ModelResolver
+  participant SS as SessionStore
+  participant REG as Registrar
+  participant A as DefaultAdapter
+  participant PM as ProviderMapper
+  participant CC as ChatClient
+  participant UP as 上游 API
+
+  C->>H: POST /v1/responses
+  H->>RC: ResponsesContext.create(app, body)
+  activate RC
+    RC->>MR: resolve(model)
+    MR-->>RC: { provider, model }
+    opt previous_response_id
+      RC->>SS: resolveChain(id)
+      SS-->>RC: session snapshot
+    end
+    RC->>REG: resolve(provider)
+    REG-->>RC: Provider 实例
+  deactivate RC
+
+  alt stream = true
+    H->>A: adapter.stream(ctx)
+    activate A
+      A->>PM: mapper.request.map(ctx)
+      A->>CC: chatClient.streamChat(req)
+      CC->>UP: POST (SSE)
+      UP-->>CC: SSE 数据块
+      A->>A: pipeTransform → ProviderEventToResponse
+      A->>A: pipeTransform → ResponseLog
+      A->>A: pipeTransform → ResponseSessionPersistence
+    deactivate A
+    H->>H: pipeTransform → ResponseSseEncode
+    H-->>C: SSE 字节流
+  else stream = false
+    H->>A: adapter.request(ctx)
+    activate A
+      A->>PM: mapper.request.map(ctx)
+      A->>CC: chatClient.chat(req)
+      CC->>UP: POST
+      UP-->>A: 上游响应
+      A->>PM: mapper.response.map(ctx, res)
+      A->>SS: save(session)
+    deactivate A
+    H-->>C: JSON 响应
+  end
 ```
 
 ## 流式管道
@@ -219,80 +267,41 @@ classDiagram
 ```mermaid
 flowchart LR
   subgraph upstream["上游提供商"]
-    SSE["SSE 数据块<br/>(JsonServerSentEvent)"]
+    SSE["SSE 数据块"]
+  end
+
+  subgraph godex["GodeX 流式管道"]
+    T1["① ProviderEventToResponse"]
+    T2["② ResponseLog"]
+    T3["③ SessionPersistence"]
   end
 
-  subgraph godex["Godex 流式管道"]
-    T1["ProviderEventTo<br/>ResponseTransformer"]
-    T2["ResponseSession<br/>PersistenceTransformer"]
-    T3["ResponseSse<br/>EncodeTransformer"]
+  subgraph server["HTTP 响应"]
+    T4["④ SseEncode"]
   end
 
   subgraph client["客户端"]
-    BYTES["SSE 字节流<br/>(text/event-stream)"]
+    BYTES["SSE 字节流"]
   end
 
-  SSE -->|"pipeThrough(TransformStream)"| T1
-  T1 -->|"逐事件 map()<br/>SSE 数据块 → ResponseStreamEvent[]"| T2
-  T2 -->|"累积 StreamState<br/>拦截终止事件<br/>buildResponseObject()<br/>保存会话"| T3
-  T3 -->|"序列化为 SSE 传输格式<br/>event: xxx\ndata: {...}\n\n"| BYTES
+  SSE -->|pipeThrough| T1
+  T1 -->|逐事件映射| T2
+  T2 -->|日志透传| T3
+  T3 -->|累积状态并保存会话| T4
+  T4 -->|序列化 SSE 格式| BYTES
 
   style upstream fill:#1a1a2e,stroke:#16213e,color:#e0e0e0
   style godex fill:#0f3460,stroke:#16213e,color:#e0e0e0
+  style server fill:#1c2333,stroke:#16213e,color:#e0e0e0
   style client fill:#1a1a2e,stroke:#16213e,color:#e0e0e0
 ```
 
-### Transformer 职责
-
-| 阶段 | Transformer | 输入 | 输出 | 副作用 |
-|------|------------|------|------|--------|
-| 1 | `ProviderEventToResponseTransformer` | `JsonServerSentEvent<TChunk>` | `ResponseStreamEvent` | 逐事件调用 `StreamMapper.map()` |
-| 2 | `ResponseSessionPersistenceTransformer` | `ResponseStreamEvent` | `ResponseStreamEvent` | 累积 `StreamState`，终止事件时调用 `buildResponseObject()` 并保存会话（`store=false` 时跳过） |
-| 3 | `ResponseSseEncodeTransformer` | `ResponseStreamEvent` | `Uint8Array`（SSE 传输格式） | 序列化为 `event:` / `data:` 行 |
-
-## 错误体系
-
-```mermaid
-classDiagram
-  direction TB
-
-  class GodexError {
-    +name: string
-    +code: string
-    +status: number
-    +context: object
-    +toLogEntry() object
-  }
-
-  class ServerError {
-    +status: 400-499
-    +context: object
-  }
-
-  class AdapterError {
-    +status: 400-499
-    +context: 不支持的参数 / 工具 / 输入项
-  }
-
-  class ProviderError {
-    +status: 502
-    +context: 上游状态码 / 响应体 / 响应头
-  }
-
-  class SessionError {
-    +status: 400-409
-    +context: 链元数据
-  }
-
-  GodexError <|-- ServerError
-  GodexError <|-- AdapterError
-  GodexError <|-- ProviderError
-  GodexError <|-- SessionError
-
-  note for GodexError "基础错误，支持结构化日志。<br/>所有错误携带领域编码（如 server.request.invalid_json）。"
-  note for ProviderError "包装上游 HTTP 失败：<br/>速率限制、超时、5xx。"
-  note for SessionError "链式解析失败：<br/>未找到、循环、深度超限。"
-```
+| 阶段 | Transformer | 输入 | 输出 | 职责 |
+|------|------------|------|------|------|
+| ① | `ProviderEventToResponseTransformer` | `JsonServerSentEvent` | `ResponseStreamEvent` | 通过 `StreamMapper.map()` 映射上游 SSE 数据块 |
+| ② | `ResponseLogTransformer` | `ResponseStreamEvent` | `ResponseStreamEvent` | 可观测性日志 |
+| ③ | `ResponseSessionPersistenceTransformer` | `ResponseStreamEvent` | `ResponseStreamEvent` | 累积 `StreamState`，终止事件时保存会话 |
+| ④ | `ResponseSseEncodeTransformer` | `ResponseStreamEvent` | `Uint8Array` | 序列化为 `event:` / `data:` 传输格式 |
 
 ## 项目结构
 
@@ -303,36 +312,20 @@ src/
 ├── context/          ApplicationContext（DI 容器）、ResponsesContext（每请求）
 ├── adapter/          Adapter 接口、DefaultAdapter、流式 Transformer
 │   ├── mapper/       RequestMapper / ResponseMapper / StreamMapper 契约
-│   └── transformers/ ProviderEvent → Response → SSE 编码管道
+│   └── transformers/ 4 阶段流式管道（映射 → 日志 → 持久化 → 编码）
 ├── providers/        Provider 注册表 + 内置工厂
-│   └── zhipu/        参考提供商实现：映射器、聊天客户端、工具、消息
+│   └── zhipu/        参考提供商：映射器、聊天客户端、工具、消息
 ├── resolver/         ModelResolver（模型选择器 → 提供商 + 模型）
-├── server/           Bun HTTP 服务器、Router、路由（/v1/responses、/health、/v1/models）
+├── server/           Bun.serve、路由（/v1/responses、/health、/v1/models）
 ├── session/          ResponseSessionStore（内存 + SQLite）、链式解析
-├── error/            GodexError 错误体系及领域编码
+├── error/            GodeXError 错误体系及领域编码
+├── tools/            内置函数工具（local_shell、shell、apply_patch）
 ├── protocol/openai/  OpenAI 兼容类型定义
 ├── logger/           结构化 JSON 日志
 └── e2e/              模拟上游的端到端测试
 ```
 
-## 快速开始
-
-```bash
-# 安装依赖
-bun install
-
-# 构建独立二进制文件（当前平台）
-bun run build
-
-# 交互式创建配置
-bun run start -- init
-
-# 启动服务器（默认端口 5678）
-bun run dev
-
-# 或直接运行编译后的二进制文件
-./platforms/darwin-arm64/bin/godex serve
-```
+## 配置
 
 ### godex.yaml
 
@@ -359,115 +352,65 @@ logging:
   level: info                   # trace | debug | info | warn | error
 ```
 
-### 添加提供商
-
-在 `src/providers/<name>/` 中实现以下接口：
-
-| 接口 | 用途 |
-|------|------|
-| `Provider<TReq, TRes, TChunk>` | 组合 mapper + chatClient + capabilities |
-| `ProviderMapper<TReq, TRes, TChunk>` | request / response / stream 映射函数 |
-| `ChatClient<TReq, TRes, TChunk>` | `chat()` 和 `streamChat()` HTTP 调用 |
-
-在 `src/providers/builtin.ts` 中注册工厂：
+### 模型选择
 
-```ts
-registrar.registerFactory("myprovider", (config) =>
-  createMyProvider(config) as Provider<unknown, unknown, unknown>
-);
 ```
-
-## 使用
-
-```bash
-# 安装 — 运行时无需 Bun
-npm install -g @ahoo-wang/godex
-
-# 交互式创建配置
-godex init
-
-# 启动网关
-godex serve
+model: "gpt-4o"              → 通过 default_provider 的模型映射解析
+model: "zhipu/glm-4.7"       → 显式指定 provider/model 选择器
+model: "openai/gpt-4o"       → 路由到已配置的 openai 提供商
 ```
 
-Godex 以**独立原生二进制文件**发布，零运行时依赖。npm 的 `postinstall` 脚本自动为您的平台选择正确的二进制文件。唯一前置条件是 Node.js >= 18（仅在 `npm install` 期间需要）。
-
-Godex 在 `http://localhost:5678` 暴露**与 OpenAI 兼容的 Responses API**（端口可配置）。将任何使用 OpenAI 协议的工具指向此端点即可：
-
-### 搭配 Codex CLI
+### 健康检查
 
 ```bash
-export OPENAI_BASE_URL=http://localhost:5678/v1
-export OPENAI_API_KEY=any-value          # Godex 不验证此值，但必须设置
-codex
+curl http://localhost:5678/health
+# {"status":"ok","providers":["zhipu"],"unsupported_providers":[]}
 ```
 
-### 搭配 OpenAI SDK
+### 添加提供商
 
-```ts
-import OpenAI from "openai";
+在 `src/providers/<name>/` 中实现三个接口：
 
-const client = new OpenAI({
-  baseURL: "http://localhost:5678/v1",
-  apiKey: "any-value",      // 透传，不验证
-});
-
-const response = await client.responses.create({
-  model: "gpt-4o",          // 通过 godex.yaml 的 models 表映射为 glm-4.7
-  input: "Hello!",
-});
-```
+| 接口 | 用途 |
+|------|------|
+| `Provider` | 组合 mapper + chatClient + capabilities |
+| `ProviderMapper` | request / response / stream 映射函数 |
+| `ChatClient` | `chat()` 和 `streamChat()` HTTP 调用 |
 
-### 模型选择
+在 `src/providers/builtin.ts` 中注册工厂：
 
-```
-model: "gpt-4o"              → 通过 default_provider 的模型映射解析
-model: "zhipu/glm-4.7"       → 显式指定 provider/model 选择器
-model: "openai/gpt-4o"       → 路由到已配置的 openai 提供商
+```ts
+registrar.registerFactory("myprovider", (config) =>
+  createMyProvider(config) as Provider<unknown, unknown, unknown>
+);
 ```
 
-`godex.yaml` 中的 `models` 映射表可将标准模型名称转换为提供商原生名称 — 客户端无需修改代码。
-
-### 健康检查
+## 开发
 
 ```bash
-curl http://localhost:5678/health
-# {"status":"ok","providers":["zhipu"],"unsupported_providers":[]}
+bun install                  # 安装依赖
+bun run dev                  # 热重载开发服务器（端口 13145）
+bun run test                 # 单元 + 集成测试
+bun run test:e2e             # 模拟上游的端到端测试
+bun run build                # 为当前平台编译原生二进制
+bun run check                # typecheck + lint + test
+bun run ci                   # 完整 CI 流水线
 ```
 
 ## 发布
 
-主包 `@ahoo-wang/godex` 是一个轻量外壳。原生二进制文件以平台特定的可选依赖发布：
+`@ahoo-wang/godex` 是一个轻量 npm 外壳。原生二进制文件以平台特定的可选依赖发布：
 
 ```
-@ahoo-wang/godex（包装包，0 运行时依赖）
-├── engines: { node: ">=18.0.0" }    ← 仅用于 postinstall
-├── postinstall: scripts/install.cjs   ← 检测平台，链接二进制文件
-└── optionalDependencies:
-    ├── @ahoo-wang/godex-darwin-arm64           ← macOS Apple Silicon
-    ├── @ahoo-wang/godex-darwin-x64             ← macOS Intel
-    ├── @ahoo-wang/godex-linux-x64              ← Linux x86_64
-    ├── @ahoo-wang/godex-linux-arm64            ← Linux ARM64
-    ├── @ahoo-wang/godex-win32-x64              ← Windows x86_64
-    └── @ahoo-wang/godex-win32-arm64            ← Windows ARM64
-
-# 发布流程：
-# 1. 将 GitHub 仓库设为公开，配置 NPM_TOKEN，然后推送发布提交。
-# 2. 创建标签为 vX.Y.Z 的 GitHub Release。
-# 3. Release 工作流构建所有平台二进制文件。
-# 4. Release 工作流上传二进制压缩包和 SHA256SUMS 到 Release Assets。
-# 5. Release 工作流先发布平台包，再发布 @ahoo-wang/godex。
+@ahoo-wang/godex
+├── @ahoo-wang/godex-darwin-arm64     ← macOS Apple Silicon
+├── @ahoo-wang/godex-darwin-x64       ← macOS Intel
+├── @ahoo-wang/godex-linux-x64        ← Linux x86_64
+├── @ahoo-wang/godex-linux-arm64      ← Linux ARM64
+├── @ahoo-wang/godex-win32-x64        ← Windows x86_64
+└── @ahoo-wang/godex-win32-arm64      ← Windows ARM64
 ```
 
-## 命令
+## 许可证
 
-```bash
-bun run dev          # 热重载开发服务器，端口 13145
-bun run build        # 为当前平台编译原生二进制
-bun run compile:all  # 本地交叉编译全部 6 个平台
-bun run test         # 单元 + 集成测试
-bun run test:e2e     # 模拟上游的端到端测试
-bun run typecheck    # tsc --noEmit
-bun run lint         # Biome 检查
-bun run ci           # 完整 CI 流水线
-```
+[Apache License 2.0](LICENSE)

package/bin/godex

@@ -59,7 +59,7 @@ function findBinary() {
 const binary = findBinary();
 if (!binary) {
   console.error(
-    "godex: binary not found. Re-run npm install or build from source.",
+    "GodeX: binary not found. Re-run npm install or build from source.",
   );
   process.exit(1);
 }

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@ahoo-wang/godex",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "Make every model a Codex engine through an OpenAI-compatible Responses API gateway",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Ahoo-Wang/Godex.git"
+    "url": "git+https://github.com/Ahoo-Wang/GodeX.git"
   },
-  "homepage": "https://github.com/Ahoo-Wang/Godex#readme",
+  "homepage": "https://github.com/Ahoo-Wang/GodeX#readme",
   "bugs": {
-    "url": "https://github.com/Ahoo-Wang/Godex/issues"
+    "url": "https://github.com/Ahoo-Wang/GodeX/issues"
   },
   "publishConfig": {
     "access": "public"
@@ -45,12 +45,12 @@
     "node": ">=18.0.0"
   },
   "optionalDependencies": {
-    "@ahoo-wang/godex-darwin-arm64": "0.0.16",
-    "@ahoo-wang/godex-darwin-x64": "0.0.16",
-    "@ahoo-wang/godex-linux-x64": "0.0.16",
-    "@ahoo-wang/godex-linux-arm64": "0.0.16",
-    "@ahoo-wang/godex-win32-x64": "0.0.16",
-    "@ahoo-wang/godex-win32-arm64": "0.0.16"
+    "@ahoo-wang/godex-darwin-arm64": "0.0.17",
+    "@ahoo-wang/godex-darwin-x64": "0.0.17",
+    "@ahoo-wang/godex-linux-x64": "0.0.17",
+    "@ahoo-wang/godex-linux-arm64": "0.0.17",
+    "@ahoo-wang/godex-win32-x64": "0.0.17",
+    "@ahoo-wang/godex-win32-arm64": "0.0.17"
   },
   "devDependencies": {
     "@ahoo-wang/fetcher": "^3.16.8",

package/scripts/install.cjs

@@ -65,13 +65,13 @@ function link(src, dest) {
 
 const platform = detectPlatform();
 if (!platform) {
-  console.log("godex: skipping binary setup — unsupported platform", process.platform, process.arch);
+  console.log("GodeX: skipping binary setup — unsupported platform", process.platform, process.arch);
   process.exit(0);
 }
 
 const binary = findBinary("@ahoo-wang/godex-" + platform, platform);
 if (!binary) {
-  console.log("godex: no prebuilt binary for", platform, "— dev mode, skipping");
+  console.log("GodeX: no prebuilt binary for", platform, "— dev mode, skipping");
   process.exit(0);
 }
 
@@ -80,4 +80,4 @@ if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
 const dest = path.join(destDir, "godex-binary");
 
 link(binary, dest);
-console.log("godex: installed native binary for", platform);
+console.log("GodeX: installed native binary for", platform);