openclaw-aicodewith-auth 0.2.6 → 0.3.0

package/README.md

@@ -46,53 +46,23 @@ You will be prompted to enter your AICodewith API key.
 
 ```bash
 # Use Claude Opus 4.5 (default after auth)
-openclaw agent --agent main --message "Hello"
+openclaw agent --message "Hello"
+
+# Use a specific model
+openclaw agent --model aicodewith-gpt/gpt-5.2-codex --message "Hello"
 
 # List available models
 openclaw models list | grep aicodewith
 ```
 
-## Environment Variables
+## Environment Variable
 
-You can set the API key via environment variable:
+You can also set the API key via environment variable:
 
 ```bash
 export AICODEWITH_API_KEY=your-api-key
 ```
 
-### Local Testing / Development
-
-Override base URLs and API type for local testing:
-
-```bash
-# Override GPT base URL (e.g., local proxy)
-export AICODEWITH_GPT_BASE_URL=http://localhost:3000/v1
-
-# Override Claude base URL
-export AICODEWITH_CLAUDE_BASE_URL=http://localhost:3000/v1
-
-# Override Gemini base URL
-export AICODEWITH_GEMINI_BASE_URL=http://localhost:3000/gemini_cli
-
-# Switch GPT API type: "openai-responses" (default) or "openai-completions"
-export AICODEWITH_GPT_API=openai-responses
-```
-
-### Local Plugin Development
-
-Link the plugin for live editing:
-
-```bash
-# From openclaw repo root
-openclaw plugins install --link ../openclaw-aicodewith-auth
-
-# Enable the plugin
-openclaw plugins enable openclaw-aicodewith-auth
-
-# Restart gateway to pick up changes
-openclaw gateway restart
-```
-
 ## License
 
 MIT

package/index.ts

@@ -6,14 +6,102 @@ import {
   PROVIDER_ID_GPT,
   PROVIDER_ID_CLAUDE,
   PROVIDER_ID_GEMINI,
-  AICODEWITH_GPT_BASE_URL,
-  AICODEWITH_CLAUDE_BASE_URL,
-  AICODEWITH_GEMINI_BASE_URL,
   AICODEWITH_API_KEY_ENV,
-  AICODEWITH_GPT_API,
 } from "./src/constants.js";
-import { GPT_MODELS, CLAUDE_MODELS, GEMINI_MODELS } from "./src/models.js";
+import { buildProviderConfigs, buildModelMigrations } from "./lib/models/index.js";
 import { createAicodewithAuthMethod } from "./src/auth.js";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+function migrateConfigModels(): void {
+  const migrations = buildModelMigrations();
+  if (Object.keys(migrations).length === 0) {
+    return;
+  }
+
+  const configDir = join(homedir(), ".openclaw");
+  const configPath = join(configDir, "openclaw.json");
+
+  if (!existsSync(configPath)) {
+    return;
+  }
+
+  let config: Record<string, unknown>;
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    config = JSON.parse(content);
+  } catch {
+    return;
+  }
+
+  let changed = false;
+
+  const migrateModelField = (modelConfig: unknown): boolean => {
+    if (!modelConfig || typeof modelConfig !== "object") return false;
+    const model = modelConfig as Record<string, unknown>;
+    let fieldChanged = false;
+
+    if (typeof model.primary === "string" && migrations[model.primary]) {
+      console.log(`[${PLUGIN_ID}] Migrating primary: ${model.primary} -> ${migrations[model.primary]}`);
+      model.primary = migrations[model.primary];
+      fieldChanged = true;
+    }
+
+    if (Array.isArray(model.fallbacks)) {
+      model.fallbacks = model.fallbacks.map((fb: unknown) => {
+        if (typeof fb === "string" && migrations[fb]) {
+          console.log(`[${PLUGIN_ID}] Migrating fallback: ${fb} -> ${migrations[fb]}`);
+          fieldChanged = true;
+          return migrations[fb];
+        }
+        return fb;
+      });
+    }
+
+    return fieldChanged;
+  };
+
+  const agents = config.agents as Record<string, unknown> | undefined;
+  if (agents) {
+    const defaults = agents.defaults as Record<string, unknown> | undefined;
+    if (defaults) {
+      if (defaults.model && migrateModelField(defaults.model)) {
+        changed = true;
+      }
+      if (defaults.imageModel && migrateModelField(defaults.imageModel)) {
+        changed = true;
+      }
+    }
+
+    const agentList = agents.list;
+    if (Array.isArray(agentList)) {
+      for (const agentConfig of agentList) {
+        if (agentConfig && typeof agentConfig === "object") {
+          const agent = agentConfig as Record<string, unknown>;
+          if (agent.model && migrateModelField(agent.model)) {
+            changed = true;
+          }
+          if (agent.imageModel && migrateModelField(agent.imageModel)) {
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+
+  if (changed) {
+    try {
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      console.log(`[${PLUGIN_ID}] Migrated deprecated model IDs in config`);
+    } catch (error) {
+      console.warn(
+        `[${PLUGIN_ID}] Failed to write migrated config:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+}
 
 const aicodewithPlugin = {
   id: PLUGIN_ID,
@@ -41,17 +129,23 @@ const aicodewithPlugin = {
       auth: Array<ReturnType<typeof createAicodewithAuthMethod>>;
     }) => void;
   }) {
+    try {
+      migrateConfigModels();
+    } catch (error) {
+      console.warn(
+        `[${PLUGIN_ID}] Config migration failed:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+
     const authMethod = createAicodewithAuthMethod();
+    const providerConfigs = buildProviderConfigs();
 
     api.registerProvider({
       id: PROVIDER_ID_GPT,
       label: "AICodewith GPT",
       envVars: [AICODEWITH_API_KEY_ENV],
-      models: {
-        baseUrl: AICODEWITH_GPT_BASE_URL,
-        api: AICODEWITH_GPT_API,
-        models: GPT_MODELS,
-      },
+      models: providerConfigs[PROVIDER_ID_GPT],
       auth: [authMethod],
     });
 
@@ -59,11 +153,7 @@ const aicodewithPlugin = {
       id: PROVIDER_ID_CLAUDE,
       label: "AICodewith Claude",
       envVars: [AICODEWITH_API_KEY_ENV],
-      models: {
-        baseUrl: AICODEWITH_CLAUDE_BASE_URL,
-        api: "anthropic-messages",
-        models: CLAUDE_MODELS,
-      },
+      models: providerConfigs[PROVIDER_ID_CLAUDE],
       auth: [authMethod],
     });
 
@@ -71,11 +161,7 @@ const aicodewithPlugin = {
       id: PROVIDER_ID_GEMINI,
       label: "AICodewith Gemini",
       envVars: [AICODEWITH_API_KEY_ENV],
-      models: {
-        baseUrl: AICODEWITH_GEMINI_BASE_URL,
-        api: "google-generative-ai",
-        models: GEMINI_MODELS,
-      },
+      models: providerConfigs[PROVIDER_ID_GEMINI],
       auth: [authMethod],
     });
   },

package/lib/models/index.ts

@@ -0,0 +1,14 @@
+export {
+  MODELS,
+  PROVIDER_IDS,
+  getActiveModels,
+  getModelById,
+  getModelsByFamily,
+  toOpenClawModel,
+  buildProviderConfigs,
+  getDefaultModel,
+  getDeprecatedModels,
+  buildModelMigrations,
+} from "./registry.js";
+
+export type { ModelDefinition, ModelFamily, OpenClawModel } from "./registry.js";

package/lib/models/registry.ts

@@ -0,0 +1,456 @@
+/**
+ * @file registry.ts
+ * @description Central model definitions - single source of truth for OpenClaw plugin
+ * 
+ * HOW TO ADD A NEW MODEL:
+ * 1. Add entry to MODELS array below
+ * 2. Run `bun run build` to verify
+ * 3. Done!
+ */
+
+import {
+  PROVIDER_ID_GPT,
+  PROVIDER_ID_CLAUDE,
+  PROVIDER_ID_GEMINI,
+  AICODEWITH_GPT_BASE_URL,
+  AICODEWITH_CLAUDE_BASE_URL,
+  AICODEWITH_GEMINI_BASE_URL,
+  CODEX_USER_AGENT,
+  CODEX_ORIGINATOR,
+} from "../../src/constants.js";
+
+export type ModelFamily = "gpt" | "claude" | "gemini";
+
+/**
+ * OpenClaw SDK Model Interface (preserved from index.ts)
+ */
+export interface OpenClawModel {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: readonly ("text" | "image")[];
+  cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+  contextWindow: number;
+  maxTokens: number;
+}
+
+/**
+ * Extended Model Definition with Registry Metadata
+ */
+export interface ModelDefinition {
+  // OpenClaw SDK fields (preserved)
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: readonly ("text" | "image")[];
+  cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+  contextWindow: number;
+  maxTokens: number;
+
+  // Registry metadata (new)
+  family: ModelFamily;
+  displayName: string;
+  version: string;
+  limit: {
+    context: number;
+    output: number;
+  };
+  modalities: {
+    input: ("text" | "image")[];
+    output: ("text")[];
+  };
+  deprecated?: boolean;
+  replacedBy?: string;
+  isDefault?: boolean;
+}
+
+const DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+
+/**
+ * ============================================
+ * SINGLE SOURCE OF TRUTH - ALL MODELS DEFINED HERE
+ * ============================================
+ */
+export const MODELS: ModelDefinition[] = [
+  // GPT Models (Active)
+  {
+    id: "gpt-5.3-codex",
+    name: "GPT-5.3 Codex",
+    family: "gpt",
+    displayName: "GPT-5.3 Codex",
+    version: "5.3",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 400000,
+    maxTokens: 128000,
+    limit: { context: 400000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+  },
+  {
+    id: "gpt-5.2",
+    name: "GPT-5.2",
+    family: "gpt",
+    displayName: "GPT-5.2",
+    version: "5.2",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 400000,
+    maxTokens: 128000,
+    limit: { context: 400000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+  },
+
+  // GPT Models (Deprecated)
+  {
+    id: "gpt-5.2-codex",
+    name: "GPT-5.2 Codex (deprecated)",
+    family: "gpt",
+    displayName: "GPT-5.2 Codex (deprecated)",
+    version: "5.2",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 400000,
+    maxTokens: 128000,
+    limit: { context: 400000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "gpt-5.3-codex",
+  },
+  {
+    id: "gpt-5.1-codex",
+    name: "GPT-5.1 Codex (deprecated)",
+    family: "gpt",
+    displayName: "GPT-5.1 Codex (deprecated)",
+    version: "5.1",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 400000,
+    maxTokens: 128000,
+    limit: { context: 400000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "gpt-5.3-codex",
+  },
+  {
+    id: "gpt-5.1-codex-max",
+    name: "GPT-5.1 Codex Max (deprecated)",
+    family: "gpt",
+    displayName: "GPT-5.1 Codex Max (deprecated)",
+    version: "5.1",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 400000,
+    maxTokens: 128000,
+    limit: { context: 400000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "gpt-5.3-codex",
+  },
+  {
+    id: "gpt-5.1-codex-mini",
+    name: "GPT-5.1 Codex Mini (deprecated)",
+    family: "gpt",
+    displayName: "GPT-5.1 Codex Mini (deprecated)",
+    version: "5.1",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "gpt-5.3-codex",
+  },
+  {
+    id: "gpt-5.1",
+    name: "GPT-5.1 (deprecated)",
+    family: "gpt",
+    displayName: "GPT-5.1 (deprecated)",
+    version: "5.1",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 400000,
+    maxTokens: 128000,
+    limit: { context: 400000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "gpt-5.2",
+  },
+
+  // Claude Models (Active)
+  {
+    id: "claude-opus-4-6-20260205",
+    name: "Claude Opus 4.6",
+    family: "claude",
+    displayName: "Claude Opus 4.6",
+    version: "4.6",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    isDefault: true,
+  },
+  {
+    id: "claude-sonnet-4-5-20250929",
+    name: "Claude Sonnet 4.5",
+    family: "claude",
+    displayName: "Claude Sonnet 4.5",
+    version: "4.5",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+  },
+  {
+    id: "claude-haiku-4-5-20251001",
+    name: "Claude Haiku 4.5",
+    family: "claude",
+    displayName: "Claude Haiku 4.5",
+    version: "4.5",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 8192,
+    limit: { context: 200000, output: 8192 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+  },
+
+  // Claude Models (Deprecated)
+  {
+    id: "claude-opus-4-5-20251101",
+    name: "Claude Opus 4.5 (deprecated)",
+    family: "claude",
+    displayName: "Claude Opus 4.5 (deprecated)",
+    version: "4.5",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 180000,
+    maxTokens: 64000,
+    limit: { context: 180000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "claude-opus-4-6-20260205",
+  },
+  {
+    id: "claude-opus-4-6-20260205-third-party",
+    name: "Claude Opus 4.6 third-party (deprecated)",
+    family: "claude",
+    displayName: "Claude Opus 4.6 third-party (deprecated)",
+    version: "4.6",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "claude-opus-4-6-20260205",
+  },
+  {
+    id: "claude-opus-4-5-20251101-third-party",
+    name: "Claude Opus 4.5 third-party (deprecated)",
+    family: "claude",
+    displayName: "Claude Opus 4.5 third-party (deprecated)",
+    version: "4.5",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 180000,
+    maxTokens: 64000,
+    limit: { context: 180000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "claude-opus-4-6-20260205",
+  },
+  {
+    id: "claude-sonnet-4-5-20250929-third-party",
+    name: "Claude Sonnet 4.5 third-party (deprecated)",
+    family: "claude",
+    displayName: "Claude Sonnet 4.5 third-party (deprecated)",
+    version: "4.5",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "claude-sonnet-4-5-20250929",
+  },
+  {
+    id: "claude-haiku-4-5-20251001-third-party",
+    name: "Claude Haiku 4.5 third-party (deprecated)",
+    family: "claude",
+    displayName: "Claude Haiku 4.5 third-party (deprecated)",
+    version: "4.5",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 200000,
+    maxTokens: 8192,
+    limit: { context: 200000, output: 8192 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+    deprecated: true,
+    replacedBy: "claude-haiku-4-5-20251001",
+  },
+
+  // Gemini Models
+  {
+    id: "gemini-3-pro",
+    name: "Gemini 3 Pro",
+    family: "gemini",
+    displayName: "Gemini 3 Pro",
+    version: "3",
+    reasoning: false,
+    input: ["text", "image"] as const,
+    cost: DEFAULT_COST,
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    limit: { context: 1048576, output: 65536 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+  },
+];
+
+/**
+ * Provider IDs
+ */
+export const PROVIDER_IDS = {
+  GPT: PROVIDER_ID_GPT,
+  CLAUDE: PROVIDER_ID_CLAUDE,
+  GEMINI: PROVIDER_ID_GEMINI,
+} as const;
+
+/**
+ * ============================================
+ * HELPER FUNCTIONS
+ * ============================================
+ */
+
+/**
+ * Get all active (non-deprecated) models
+ */
+export const getActiveModels = (): ModelDefinition[] => {
+  return MODELS.filter((m) => !m.deprecated);
+};
+
+/**
+ * Get model by ID
+ */
+export const getModelById = (id: string): ModelDefinition | undefined => {
+  return MODELS.find((m) => m.id === id);
+};
+
+/**
+ * Get models by family
+ */
+export const getModelsByFamily = (family: ModelFamily): ModelDefinition[] => {
+  return MODELS.filter((m) => m.family === family && !m.deprecated);
+};
+
+/**
+ * Transform ModelDefinition to OpenClaw SDK format
+ */
+export const toOpenClawModel = (model: ModelDefinition): OpenClawModel => {
+  return {
+    id: model.id,
+    name: model.name,
+    reasoning: model.reasoning,
+    input: model.input,
+    cost: model.cost,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+  };
+};
+
+/**
+ * Get default model
+ */
+export const getDefaultModel = (): ModelDefinition => {
+  const defaultModel = MODELS.find((m) => m.isDefault);
+  if (!defaultModel) {
+    throw new Error("No default model found in registry");
+  }
+  return defaultModel;
+};
+
+/**
+ * Get all deprecated models
+ */
+export const getDeprecatedModels = (): ModelDefinition[] => {
+  return MODELS.filter((m) => m.deprecated);
+};
+
+/**
+ * Build model migrations map (oldModelId -> newModelId)
+ * Used for migrating users from deprecated models to their replacements
+ * Includes both bare model IDs and provider-prefixed IDs
+ */
+export const buildModelMigrations = (): Record<string, string> => {
+  const migrations: Record<string, string> = {};
+  
+  const getProviderForFamily = (family: ModelFamily): string => {
+    switch (family) {
+      case "gpt": return PROVIDER_ID_GPT;
+      case "claude": return PROVIDER_ID_CLAUDE;
+      case "gemini": return PROVIDER_ID_GEMINI;
+    }
+  };
+  
+  for (const model of MODELS) {
+    if (model.deprecated && model.replacedBy) {
+      migrations[model.id] = model.replacedBy;
+      
+      const provider = getProviderForFamily(model.family);
+      const replacementModel = MODELS.find(m => m.id === model.replacedBy);
+      if (replacementModel) {
+        const replacementProvider = getProviderForFamily(replacementModel.family);
+        migrations[`${provider}/${model.id}`] = `${replacementProvider}/${model.replacedBy}`;
+      }
+    }
+  }
+  return migrations;
+};
+
+/**
+ * Build provider configurations for all 3 providers
+ */
+export const buildProviderConfigs = () => {
+  const gptModels = getModelsByFamily("gpt").map(toOpenClawModel);
+  const claudeModels = getModelsByFamily("claude").map(toOpenClawModel);
+  const geminiModels = getModelsByFamily("gemini").map(toOpenClawModel);
+
+  return {
+    [PROVIDER_ID_GPT]: {
+      baseUrl: AICODEWITH_GPT_BASE_URL,
+      api: "openai-responses" as const,
+      models: gptModels,
+    },
+    [PROVIDER_ID_CLAUDE]: {
+      baseUrl: AICODEWITH_CLAUDE_BASE_URL,
+      api: "anthropic-messages" as const,
+      models: claudeModels,
+    },
+    [PROVIDER_ID_GEMINI]: {
+      baseUrl: AICODEWITH_GEMINI_BASE_URL,
+      api: "google-generative-ai" as const,
+      models: geminiModels,
+    },
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-aicodewith-auth",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "type": "module",
   "description": "AICodewith provider plugin for OpenClaw - Access GPT, Claude, and Gemini models via AICodewith API",
   "author": "daneel",
@@ -27,10 +27,18 @@
   "files": [
     "index.ts",
     "src",
+    "lib",
     "openclaw.plugin.json",
     "README.md"
   ],
   "peerDependencies": {
     "openclaw": ">=2026.1.0"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
   }
 }

package/src/auth.ts

@@ -2,13 +2,12 @@ import {
   AICODEWITH_GPT_BASE_URL,
   AICODEWITH_CLAUDE_BASE_URL,
   AICODEWITH_GEMINI_BASE_URL,
-  AICODEWITH_GPT_API,
   PROVIDER_ID_GPT,
   PROVIDER_ID_CLAUDE,
   PROVIDER_ID_GEMINI,
   AUTH_PROFILE_ID,
 } from "./constants.js";
-import { GPT_MODELS, CLAUDE_MODELS, GEMINI_MODELS } from "./models.js";
+import { buildProviderConfigs, getDefaultModel } from "../lib/models/index.js";
 
 function validateApiKey(value: string): string | undefined {
   const trimmed = value.trim();
@@ -39,7 +38,9 @@ export function createAicodewithAuthMethod() {
       });
 
       const trimmedKey = apiKey.trim();
-      const defaultModelRef = `${PROVIDER_ID_CLAUDE}/claude-opus-4-5-20251101`;
+      const providerConfigs = buildProviderConfigs();
+      const defaultModel = getDefaultModel();
+      const defaultModelRef = `${PROVIDER_ID_CLAUDE}/${defaultModel.id}`;
 
       return {
         profiles: [
@@ -56,22 +57,16 @@ export function createAicodewithAuthMethod() {
           models: {
             providers: {
               [PROVIDER_ID_GPT]: {
-                baseUrl: AICODEWITH_GPT_BASE_URL,
+                ...providerConfigs[PROVIDER_ID_GPT],
                 apiKey: trimmedKey,
-                api: AICODEWITH_GPT_API,
-                models: GPT_MODELS,
               },
               [PROVIDER_ID_CLAUDE]: {
-                baseUrl: AICODEWITH_CLAUDE_BASE_URL,
+                ...providerConfigs[PROVIDER_ID_CLAUDE],
                 apiKey: trimmedKey,
-                api: "anthropic-messages",
-                models: CLAUDE_MODELS,
               },
               [PROVIDER_ID_GEMINI]: {
-                baseUrl: AICODEWITH_GEMINI_BASE_URL,
+                ...providerConfigs[PROVIDER_ID_GEMINI],
                 apiKey: trimmedKey,
-                api: "google-generative-ai",
-                models: GEMINI_MODELS,
               },
             },
           },
@@ -80,13 +75,13 @@ export function createAicodewithAuthMethod() {
               model: defaultModelRef,
               models: {
                 ...Object.fromEntries(
-                  GPT_MODELS.map((m) => [`${PROVIDER_ID_GPT}/${m.id}`, {}])
+                  providerConfigs[PROVIDER_ID_GPT].models.map((m) => [`${PROVIDER_ID_GPT}/${m.id}`, {}])
                 ),
                 ...Object.fromEntries(
-                  CLAUDE_MODELS.map((m) => [`${PROVIDER_ID_CLAUDE}/${m.id}`, {}])
+                  providerConfigs[PROVIDER_ID_CLAUDE].models.map((m) => [`${PROVIDER_ID_CLAUDE}/${m.id}`, {}])
                 ),
                 ...Object.fromEntries(
-                  GEMINI_MODELS.map((m) => [`${PROVIDER_ID_GEMINI}/${m.id}`, {}])
+                  providerConfigs[PROVIDER_ID_GEMINI].models.map((m) => [`${PROVIDER_ID_GEMINI}/${m.id}`, {}])
                 ),
               },
             },

package/src/constants.ts

@@ -1,15 +1,6 @@
-// Base URLs - can be overridden via environment variables for local testing
-export const AICODEWITH_GPT_BASE_URL =
-  process.env.AICODEWITH_GPT_BASE_URL?.trim() || "https://api.aicodewith.com/chatgpt/v1";
-export const AICODEWITH_CLAUDE_BASE_URL =
-  process.env.AICODEWITH_CLAUDE_BASE_URL?.trim() || "https://api.aicodewith.com/v1";
-export const AICODEWITH_GEMINI_BASE_URL =
-  process.env.AICODEWITH_GEMINI_BASE_URL?.trim() || "https://api.aicodewith.com/gemini_cli";
-
-// API type for GPT - "openai-responses" (default) or "openai-completions"
-export const AICODEWITH_GPT_API =
-  (process.env.AICODEWITH_GPT_API?.trim() as "openai-responses" | "openai-completions") ||
-  "openai-responses";
+export const AICODEWITH_GPT_BASE_URL = "https://api.aicodewith.com/chatgpt/v1";
+export const AICODEWITH_CLAUDE_BASE_URL = "https://api.aicodewith.com";
+export const AICODEWITH_GEMINI_BASE_URL = "https://api.aicodewith.com/gemini_cli";
 
 export const PROVIDER_ID_GPT = "aicodewith-gpt";
 export const PROVIDER_ID_CLAUDE = "aicodewith-claude";
@@ -23,3 +14,7 @@ export const PLUGIN_ID = "openclaw-aicodewith-auth";
 export const PLUGIN_NAME = "AICodewith";
 export const PLUGIN_DESCRIPTION =
   "Access GPT, Claude, and Gemini models via AICodewith API";
+
+// Codex-specific headers (required for GPT models)
+export const CODEX_USER_AGENT = "codex_cli_rs/0.77.0 (Mac OS 26.2.0; arm64) iTerm.app/3.6.6";
+export const CODEX_ORIGINATOR = "codex_cli_rs";

package/src/models.ts

@@ -1,55 +0,0 @@
-const DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-
-export const GPT_MODELS = [
-  {
-    id: "gpt-5.2-codex",
-    name: "GPT-5.2 Codex",
-    reasoning: false,
-    input: ["text", "image"] as const,
-    cost: DEFAULT_COST,
-    contextWindow: 400000,
-    maxTokens: 128000,
-  },
-  {
-    id: "gpt-5.2",
-    name: "GPT-5.2",
-    reasoning: false,
-    input: ["text", "image"] as const,
-    cost: DEFAULT_COST,
-    contextWindow: 400000,
-    maxTokens: 128000,
-  },
-];
-
-export const CLAUDE_MODELS = [
-  {
-    id: "claude-sonnet-4-5-20250929",
-    name: "Claude Sonnet 4.5",
-    reasoning: false,
-    input: ["text", "image"] as const,
-    cost: DEFAULT_COST,
-    contextWindow: 200000,
-    maxTokens: 64000,
-  },
-  {
-    id: "claude-opus-4-5-20251101",
-    name: "Claude Opus 4.5",
-    reasoning: false,
-    input: ["text", "image"] as const,
-    cost: DEFAULT_COST,
-    contextWindow: 200000,
-    maxTokens: 64000,
-  },
-];
-
-export const GEMINI_MODELS = [
-  {
-    id: "gemini-3-pro",
-    name: "Gemini 3 Pro",
-    reasoning: false,
-    input: ["text", "image"] as const,
-    cost: DEFAULT_COST,
-    contextWindow: 1048576,
-    maxTokens: 65536,
-  },
-];