ai-zero-token 1.0.1 → 1.0.2

package/dist/server/app.js

@@ -1,28 +1,101 @@
 #!/usr/bin/env node
+import { randomUUID } from "node:crypto";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import { z } from "zod";
 import { createGatewayContext } from "../core/context.js";
+import { renderAdminPage } from "./admin-page.js";
+const inputPartSchema = z.object({
+  type: z.string().optional(),
+  text: z.string().optional()
+}).passthrough();
+const inputMessageSchema = z.object({
+  role: z.string().optional(),
+  content: z.array(inputPartSchema).optional()
+}).passthrough();
 const responsesBodySchema = z.object({
   model: z.string().optional(),
-  input: z.union([
-    z.string(),
-    z.array(
-      z.object({
-        role: z.string().optional(),
-        content: z.array(
-          z.object({
-            type: z.string().optional(),
-            text: z.string().optional()
-          })
-        ).optional()
-      })
-    )
-  ]),
+  input: z.union([z.string(), z.array(inputMessageSchema)]).optional(),
   instructions: z.string().optional(),
-  stream: z.boolean().optional()
+  stream: z.boolean().optional(),
+  tools: z.array(z.unknown()).optional(),
+  tool_choice: z.unknown().optional(),
+  include: z.array(z.string()).optional(),
+  text: z.record(z.string(), z.unknown()).optional(),
+  store: z.boolean().optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  experimental_codex: z.object({
+    body: z.record(z.string(), z.unknown()).optional(),
+    allow_unknown_model: z.boolean().optional(),
+    include_raw: z.boolean().optional()
+  }).passthrough().optional()
+});
+const chatCompletionContentPartSchema = z.object({
+  type: z.string().optional(),
+  text: z.string().optional(),
+  image_url: z.union([
+    z.string(),
+    z.object({
+      url: z.string().optional()
+    }).passthrough()
+  ]).optional()
+}).passthrough();
+const chatCompletionMessageSchema = z.object({
+  role: z.string().optional(),
+  content: z.union([z.string(), z.array(chatCompletionContentPartSchema)]).optional(),
+  name: z.string().optional(),
+  tool_call_id: z.string().optional()
+}).passthrough();
+const chatCompletionsBodySchema = z.object({
+  model: z.string().optional(),
+  messages: z.array(chatCompletionMessageSchema).min(1),
+  n: z.number().int().positive().optional(),
+  stream: z.boolean().optional(),
+  tools: z.array(z.unknown()).optional(),
+  tool_choice: z.unknown().optional(),
+  response_format: z.unknown().optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  store: z.boolean().optional(),
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  max_tokens: z.number().optional(),
+  max_completion_tokens: z.number().optional(),
+  presence_penalty: z.number().optional(),
+  frequency_penalty: z.number().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  stop: z.union([z.string(), z.array(z.string())]).optional(),
+  user: z.string().optional()
+}).passthrough();
+const settingsUpdateSchema = z.object({
+  defaultModel: z.string().min(1)
+});
+const profileActionSchema = z.object({
+  profileId: z.string().min(1)
 });
+const imageGenerationsBodySchema = z.object({
+  prompt: z.string().min(1),
+  model: z.string().optional(),
+  n: z.number().int().positive().optional(),
+  quality: z.enum(["low", "medium", "high", "auto"]).optional(),
+  size: z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional(),
+  background: z.enum(["transparent", "opaque", "auto"]).optional(),
+  output_format: z.enum(["png", "webp", "jpeg"]).optional(),
+  output_compression: z.number().int().min(0).max(100).optional(),
+  moderation: z.enum(["auto", "low"]).optional(),
+  response_format: z.enum(["b64_json", "url"]).optional(),
+  user: z.string().optional()
+}).passthrough();
+const chatCompletionExcludedKeys = /* @__PURE__ */ new Set([
+  "messages",
+  "n",
+  "stream",
+  "max_tokens",
+  "max_completion_tokens"
+]);
 function extractTextInput(input) {
+  if (typeof input === "undefined") {
+    return "";
+  }
   if (typeof input === "string") {
     return input;
   }
@@ -36,6 +109,204 @@ function extractTextInput(input) {
   }
   return chunks.join("\n").trim();
 }
+function normalizeResponseInput(input) {
+  if (typeof input === "undefined") {
+    return void 0;
+  }
+  if (typeof input === "string") {
+    return [
+      {
+        role: "user",
+        content: [{ type: "input_text", text: input }]
+      }
+    ];
+  }
+  return input;
+}
+function normalizeChatRole(role) {
+  if (role === "developer") {
+    return "system";
+  }
+  return role ?? "user";
+}
+function normalizeChatContentPart(part) {
+  if (part.type === "image_url") {
+    const url = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+    if (!url) {
+      throw new Error("chat.completions \u6D88\u606F\u91CC\u7684 image_url \u7F3A\u5C11 url\u3002");
+    }
+    return {
+      type: "input_image",
+      image_url: url
+    };
+  }
+  if (part.type === "input_image") {
+    return part;
+  }
+  const text = typeof part.text === "string" ? part.text : "";
+  return {
+    type: "input_text",
+    text
+  };
+}
+function normalizeChatContent(content) {
+  if (typeof content === "string") {
+    return [{ type: "input_text", text: content }];
+  }
+  if (!Array.isArray(content) || content.length === 0) {
+    return [{ type: "input_text", text: "" }];
+  }
+  return content.map((part) => normalizeChatContentPart(part));
+}
+function normalizeChatMessages(messages) {
+  return messages.map((message) => ({
+    role: normalizeChatRole(message.role),
+    content: normalizeChatContent(message.content),
+    ...message.name ? { name: message.name } : {},
+    ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}
+  }));
+}
+function createChatCompletionsCodexBody(data) {
+  const body = Object.fromEntries(
+    Object.entries(data).filter(([key]) => !chatCompletionExcludedKeys.has(key))
+  );
+  if (typeof data.max_completion_tokens === "number") {
+    body.max_output_tokens = data.max_completion_tokens;
+  } else if (typeof data.max_tokens === "number") {
+    body.max_output_tokens = data.max_tokens;
+  }
+  body.input = normalizeChatMessages(data.messages);
+  return body;
+}
+function summarizeImageRequestForLog(body) {
+  return {
+    model: body.model ?? "default",
+    promptLength: body.prompt.length,
+    size: body.size ?? "default",
+    quality: body.quality ?? "default",
+    background: body.background ?? "default",
+    output_format: body.output_format ?? "default",
+    output_compression: typeof body.output_compression === "number" ? body.output_compression : void 0,
+    moderation: body.moderation ?? "default",
+    response_format: body.response_format ?? "default",
+    user: body.user ?? void 0
+  };
+}
+function buildResponseApiBody(result, includeRaw) {
+  const responseBody = {
+    object: "response",
+    provider: result.provider,
+    model: result.model,
+    output_text: result.text,
+    output: [
+      {
+        type: "message",
+        role: "assistant",
+        content: [
+          {
+            type: "output_text",
+            text: result.text
+          }
+        ]
+      }
+    ]
+  };
+  if (result.artifacts.length > 0) {
+    responseBody.artifacts = result.artifacts;
+  }
+  if (includeRaw) {
+    responseBody.raw = result.raw;
+  }
+  return responseBody;
+}
+function buildChatCompletionsBody(result) {
+  const body = {
+    id: `chatcmpl_${randomUUID().replace(/-/g, "")}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: result.model,
+    choices: [
+      {
+        index: 0,
+        finish_reason: "stop",
+        message: {
+          role: "assistant",
+          content: result.text
+        }
+      }
+    ]
+  };
+  if (result.artifacts.length > 0) {
+    body.artifacts = result.artifacts;
+  }
+  return body;
+}
+function validateImageRequest(data) {
+  if (data.response_format === "url") {
+    return "\u5F53\u524D\u7F51\u5173\u4EC5\u652F\u6301 response_format=b64_json\uFF0C\u6682\u4E0D\u652F\u6301\u8FD4\u56DE\u6258\u7BA1\u56FE\u7247 URL\u3002";
+  }
+  if (data.background === "transparent" && typeof data.output_format === "string" && !["png", "webp"].includes(data.output_format)) {
+    return "transparent \u80CC\u666F\u4EC5\u652F\u6301 output_format=png \u6216 webp\u3002";
+  }
+  if (typeof data.output_compression === "number" && data.output_format === "png") {
+    return "output_compression \u4EC5\u652F\u6301 jpeg \u6216 webp \u8F93\u51FA\u3002";
+  }
+  return null;
+}
+function maskSecret(value) {
+  if (value.length <= 12) {
+    return value;
+  }
+  return `${value.slice(0, 8)}...${value.slice(-6)}`;
+}
+function serializeProfile(profile) {
+  if (!profile) {
+    return null;
+  }
+  return {
+    provider: profile.provider,
+    profileId: profile.profileId,
+    accountId: profile.accountId,
+    email: profile.email,
+    quota: profile.quota,
+    expiresAt: profile.expires,
+    accessTokenPreview: maskSecret(profile.access),
+    refreshTokenPreview: maskSecret(profile.refresh)
+  };
+}
+function serializeManagedProfile(profile) {
+  return {
+    provider: profile.provider,
+    profileId: profile.profileId,
+    accountId: profile.accountId,
+    email: profile.email,
+    quota: profile.quota,
+    expiresAt: profile.expiresAt,
+    accessTokenPreview: profile.accessTokenPreview,
+    refreshTokenPreview: profile.refreshTokenPreview,
+    isActive: profile.isActive
+  };
+}
+function resolveOrigin(request) {
+  const host = request.headers.host;
+  if (host) {
+    return `${request.protocol}://${host}`;
+  }
+  return "http://127.0.0.1:8787";
+}
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function getErrorStatusCode(error) {
+  const message = normalizeError(error).message;
+  if (message.includes("\u7F3A\u5C11") || message.includes("\u683C\u5F0F\u9519\u8BEF") || message.includes("\u672A\u5185\u7F6E\u6A21\u578B") || message.includes("\u4E0D\u652F\u6301") || message.includes("\u6CA1\u6709\u63D0\u4F9B")) {
+    return 400;
+  }
+  if (message.includes("\u8FD8\u6CA1\u6709\u767B\u5F55")) {
+    return 401;
+  }
+  return 500;
+}
 function createApp(params) {
   const app = Fastify({
     logger: false
@@ -43,13 +314,131 @@ function createApp(params) {
   const ctx = createGatewayContext();
   void app.register(cors, {
     origin: params?.corsOrigin ?? true,
-    methods: ["GET", "POST", "OPTIONS"]
+    methods: ["GET", "POST", "PUT", "OPTIONS"]
+  });
+  app.setErrorHandler((error, request, reply) => {
+    const normalized = normalizeError(error);
+    const statusCode = getErrorStatusCode(normalized);
+    console.error("[gateway:error]", {
+      method: request.method,
+      url: request.url,
+      statusCode,
+      message: normalized.message,
+      stack: normalized.stack
+    });
+    reply.code(statusCode);
+    return {
+      error: {
+        type: "gateway_error",
+        message: normalized.message
+      }
+    };
+  });
+  async function buildAdminConfig(request) {
+    const [status, models, settings, profile, profiles] = await Promise.all([
+      ctx.authService.getStatus(),
+      ctx.modelService.listModels(),
+      ctx.configService.getSettings(),
+      ctx.authService.getActiveProfile(),
+      ctx.authService.listProfiles()
+    ]);
+    const origin = resolveOrigin(request);
+    return {
+      status,
+      settings,
+      models,
+      profile: serializeProfile(profile),
+      profiles: profiles.map((item) => serializeManagedProfile(item)),
+      adminUrl: `${origin}/`,
+      baseUrl: `${origin}/v1`,
+      supportedEndpoints: [
+        {
+          method: "GET",
+          path: "/v1/models",
+          description: "OpenAI models \u5217\u8868\u517C\u5BB9\u63A5\u53E3\u3002"
+        },
+        {
+          method: "POST",
+          path: "/v1/responses",
+          description: "OpenAI responses \u517C\u5BB9\u63A5\u53E3\u3002"
+        },
+        {
+          method: "POST",
+          path: "/v1/chat/completions",
+          description: "OpenAI chat.completions \u517C\u5BB9\u63A5\u53E3\u3002"
+        },
+        {
+          method: "POST",
+          path: "/v1/images/generations",
+          description: "OpenAI images.generations \u517C\u5BB9\u63A5\u53E3\u3002"
+        }
+      ]
+    };
+  }
+  app.get("/", async (_request, reply) => {
+    reply.header("Content-Type", "text/html; charset=utf-8");
+    return renderAdminPage();
+  });
+  app.get("/favicon.ico", async (_request, reply) => {
+    reply.code(204);
+    return "";
   });
   app.get("/_gateway/health", async () => ({ ok: true }));
   app.get("/_gateway/status", async () => ctx.authService.getStatus());
   app.get("/_gateway/models", async () => ({
     data: await ctx.modelService.listModels()
   }));
+  app.get("/_gateway/admin/config", async (request) => buildAdminConfig(request));
+  app.post("/_gateway/admin/login", async (request) => {
+    await ctx.authService.login("openai-codex");
+    return buildAdminConfig(request);
+  });
+  app.post("/_gateway/admin/logout", async (request) => {
+    await ctx.authService.logoutAll();
+    return buildAdminConfig(request);
+  });
+  app.post("/_gateway/admin/profiles/activate", async (request, reply) => {
+    const parsed = profileActionSchema.safeParse(request.body);
+    if (!parsed.success) {
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    await ctx.authService.activateProfile(parsed.data.profileId);
+    return buildAdminConfig(request);
+  });
+  app.post("/_gateway/admin/profiles/remove", async (request, reply) => {
+    const parsed = profileActionSchema.safeParse(request.body);
+    if (!parsed.success) {
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    await ctx.authService.removeProfile(parsed.data.profileId);
+    return buildAdminConfig(request);
+  });
+  app.put("/_gateway/admin/settings", async (request, reply) => {
+    const parsed = settingsUpdateSchema.safeParse(request.body);
+    if (!parsed.success) {
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    await ctx.configService.setDefaultModel(parsed.data.defaultModel);
+    return buildAdminConfig(request);
+  });
   app.get("/v1/models", async () => ({
     object: "list",
     data: (await ctx.modelService.listModels()).map((model) => ({
@@ -74,47 +463,180 @@ function createApp(params) {
       return {
         error: {
           type: "not_supported",
-          message: "\u7B2C\u4E00\u9636\u6BB5\u6682\u4E0D\u652F\u6301 stream=true"
+          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 stream=true"
         }
       };
     }
     const input = extractTextInput(parsed.data.input);
-    if (!input) {
+    const hasInput = typeof parsed.data.input !== "undefined" || typeof parsed.data.experimental_codex?.body?.input !== "undefined";
+    if (!hasInput) {
       reply.code(400);
       return {
         error: {
           type: "validation_error",
-          message: "\u6CA1\u6709\u89E3\u6790\u51FA\u6709\u6548\u7684 input \u6587\u672C"
+          message: "\u6CA1\u6709\u63D0\u4F9B input\uFF0C\u4E5F\u6CA1\u6709\u5728 experimental_codex.body \u91CC\u900F\u4F20 input"
         }
       };
     }
+    const codexBody = {
+      ...parsed.data.experimental_codex?.body ?? {}
+    };
+    const normalizedInput = normalizeResponseInput(parsed.data.input);
+    if (typeof normalizedInput !== "undefined") {
+      codexBody.input = normalizedInput;
+    }
+    if (typeof parsed.data.instructions === "string") {
+      codexBody.instructions = parsed.data.instructions;
+    }
+    if (parsed.data.tools) {
+      codexBody.tools = parsed.data.tools;
+    }
+    if (typeof parsed.data.tool_choice !== "undefined") {
+      codexBody.tool_choice = parsed.data.tool_choice;
+    }
+    if (parsed.data.include) {
+      codexBody.include = parsed.data.include;
+    }
+    if (parsed.data.text) {
+      codexBody.text = parsed.data.text;
+    }
+    if (typeof parsed.data.store === "boolean") {
+      codexBody.store = parsed.data.store;
+    }
+    if (typeof parsed.data.parallel_tool_calls === "boolean") {
+      codexBody.parallel_tool_calls = parsed.data.parallel_tool_calls;
+    }
     const result = await ctx.chatService.chat({
       model: parsed.data.model,
-      input,
-      system: parsed.data.instructions
+      input: input || void 0,
+      system: parsed.data.instructions,
+      experimental: {
+        codexBody,
+        allowUnknownModel: parsed.data.experimental_codex?.allow_unknown_model
+      }
     });
-    return {
-      object: "response",
-      provider: result.provider,
-      model: result.model,
-      output_text: result.text,
-      output: [
-        {
-          type: "message",
-          role: "assistant",
-          content: [
-            {
-              type: "output_text",
-              text: result.text
-            }
-          ]
+    return buildResponseApiBody(result, parsed.data.experimental_codex?.include_raw);
+  });
+  app.post("/v1/chat/completions", async (request, reply) => {
+    const parsed = chatCompletionsBodySchema.safeParse(request.body);
+    if (!parsed.success) {
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
         }
-      ]
-    };
+      };
+    }
+    if (parsed.data.stream) {
+      reply.code(501);
+      return {
+        error: {
+          type: "not_supported",
+          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 chat.completions \u7684 stream=true"
+        }
+      };
+    }
+    if (typeof parsed.data.n === "number" && parsed.data.n > 1) {
+      reply.code(501);
+      return {
+        error: {
+          type: "not_supported",
+          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301\u4E00\u6B21\u8FD4\u56DE\u591A\u4E2A choices\uFF08n > 1\uFF09"
+        }
+      };
+    }
+    const codexBody = createChatCompletionsCodexBody(parsed.data);
+    const fallbackInput = parsed.data.messages.map(
+      (message) => typeof message.content === "string" ? message.content : (message.content ?? []).map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n")
+    ).filter(Boolean).join("\n").trim();
+    const result = await ctx.chatService.chat({
+      model: parsed.data.model,
+      input: fallbackInput || void 0,
+      experimental: {
+        codexBody
+      }
+    });
+    return buildChatCompletionsBody(result);
+  });
+  app.post("/v1/images/generations", async (request, reply) => {
+    const parsed = imageGenerationsBodySchema.safeParse(request.body);
+    if (!parsed.success) {
+      console.error("[gateway:image] validation failure", {
+        method: request.method,
+        url: request.url,
+        issue: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+      });
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    const validationError = validateImageRequest(parsed.data);
+    if (validationError) {
+      console.error("[gateway:image] validation failure", {
+        method: request.method,
+        url: request.url,
+        summary: summarizeImageRequestForLog(parsed.data),
+        issue: validationError
+      });
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: validationError
+        }
+      };
+    }
+    if (typeof parsed.data.n === "number" && parsed.data.n > 1) {
+      console.error("[gateway:image] not supported", {
+        method: request.method,
+        url: request.url,
+        summary: summarizeImageRequestForLog(parsed.data),
+        issue: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 images.generations \u4E00\u6B21\u8FD4\u56DE\u591A\u5F20\u56FE\uFF08n > 1\uFF09"
+      });
+      reply.code(501);
+      return {
+        error: {
+          type: "not_supported",
+          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 images.generations \u4E00\u6B21\u8FD4\u56DE\u591A\u5F20\u56FE\uFF08n > 1\uFF09"
+        }
+      };
+    }
+    const requestSummary = summarizeImageRequestForLog(parsed.data);
+    console.info("[gateway:image] request accepted", {
+      method: request.method,
+      url: request.url,
+      summary: requestSummary
+    });
+    const response = await ctx.imageService.generate({
+      prompt: parsed.data.prompt,
+      model: parsed.data.model,
+      n: parsed.data.n,
+      size: parsed.data.size,
+      quality: parsed.data.quality,
+      background: parsed.data.background,
+      outputFormat: parsed.data.output_format,
+      outputCompression: parsed.data.output_compression,
+      moderation: parsed.data.moderation
+    });
+    console.info("[gateway:image] response ready", {
+      method: request.method,
+      url: request.url,
+      summary: requestSummary,
+      created: response.created,
+      imageCount: response.data.length,
+      output_format: response.output_format,
+      quality: response.quality,
+      size: response.size
+    });
+    return response;
   });
   return app;
 }
 export {
   createApp
 };
-//# sourceMappingURL=app.js.map

package/dist/server/index.js

@@ -31,4 +31,3 @@ async function startServer(params) {
 export {
   startServer
 };
-//# sourceMappingURL=index.js.map

package/dist/store.js

@@ -17,4 +17,3 @@ export {
   saveProfile,
   saveStore
 };
-//# sourceMappingURL=store.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-zero-token",
-  "version": "1.0.1",
-  "description": "A local-first single-user AI CLI and gateway with OpenAI Codex OAuth support.",
+  "version": "1.0.2",
+  "description": "Local-first OpenAI-compatible AI CLI and gateway with Codex OAuth, multi-account management, and gpt-image-2 image generation.",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -22,7 +22,14 @@
     "gateway",
     "oauth",
     "openai",
-    "codex"
+    "codex",
+    "openai-compatible",
+    "chatgpt",
+    "gpt-image-2",
+    "image-generation",
+    "images-generations",
+    "local-gateway",
+    "multi-account"
   ],
   "engines": {
     "node": ">=22"
@@ -31,9 +38,11 @@
     "login": "bun src/cli.ts login",
     "status": "bun src/cli.ts status",
     "ask": "bun src/cli.ts ask",
+    "start": "bun src/cli.ts start",
     "serve": "bun src/cli.ts serve",
     "build": "tsup",
     "typecheck": "bunx tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build",
     "pack:dry": "npm pack --dry-run"
   },
   "dependencies": {