use built-in vercel-ai-gateway provider instead of custom providers

Remove models.providers from OpenClaw config. Instead, set AI_GATEWAY_API_KEY
and AI_GATEWAY_BASE_URL in ~/.openclaw/.env so OpenClaw uses its built-in
vercel-ai-gateway provider with auto-discovered models. The proxy handles
auth, credit metering, and forwarding to Vercel AI Gateway.

Made-with: Cursor

Author: albertsalgueda

src/lib/hetzner/cloud-init.test.ts

@@ -19,17 +19,18 @@ describe('generateCloudInit', () => {
 
     expect(result).toContain('#cloud-config')
     expect(result).toContain('/home/openclaw/.env')
+    expect(result).toContain('/home/openclaw/.openclaw/.env')
     expect(result).toContain('/home/openclaw/.openclaw/openclaw.json')
     expect(result).toContain('/etc/systemd/system/ttyd.service')
     expect(result).toContain('/etc/systemd/system/openclaw-gateway.service')
     expect(result).toContain('ssh-rsa AAAA')
-    expect(result).toContain(
-      Buffer.from(
-        'AI_GATEWAY_URL=https://app.example/api/gateway/proxy\n' +
-        'INSTANCE_ID=inst-1\n' +
-        'CUSTOMER_ID=org-1\n'
-      ).toString('base64')
-    )
+
+    const openclawEnvB64 = Buffer.from(
+      'AI_GATEWAY_API_KEY=gateway-token\n' +
+      'AI_GATEWAY_BASE_URL=https://app.example/api/gateway/proxy\n'
+    ).toString('base64')
+    expect(result).toContain(openclawEnvB64)
+
     expect(result).toContain(Buffer.from('{"hello":"world"}').toString('base64'))
     expect(result).toContain('npx playwright install --with-deps chromium')
     expect(result).toContain('base64 -d > /etc/caddy/Caddyfile')

src/lib/hetzner/cloud-init.ts

@@ -14,9 +14,14 @@ function b64(text: string): string {
   return Buffer.from(text).toString('base64')
 }
 
+function buildOpenClawEnv(params: CloudInitParams): string {
+  return `AI_GATEWAY_API_KEY=${params.gatewayToken}
+AI_GATEWAY_BASE_URL=${params.proxyBaseUrl}
+`
+}
+
 function buildEnvFile(params: CloudInitParams): string {
-  return `AI_GATEWAY_URL=${params.proxyBaseUrl}
-INSTANCE_ID=${params.instanceId}
+  return `INSTANCE_ID=${params.instanceId}
 CUSTOMER_ID=${params.customerId}
 `
 }
@@ -92,6 +97,7 @@ export function generateCloudInit(params: CloudInitParams): string {
   const hostname = `${params.slug}.${params.domain}`
 
   const envFile = b64(buildEnvFile(params))
+  const openclawEnv = b64(buildOpenClawEnv(params))
   const configFile = b64(params.openclawConfig)
   const caddyFile = b64(buildCaddyfile(hostname))
   const ttydService = b64(buildTtydService())
@@ -116,6 +122,10 @@ write_files:
     permissions: '0600'
     encoding: b64
     content: ${envFile}
+  - path: /home/openclaw/.openclaw/.env
+    permissions: '0600'
+    encoding: b64
+    content: ${openclawEnv}
   - path: /home/openclaw/.openclaw/openclaw.json
     permissions: '0644'
     encoding: b64

src/lib/openclaw/config.test.ts

@@ -54,7 +54,7 @@ function makeInstance(overrides: Partial<Instance> = {}): Instance {
 const defaultParams = {
   gatewayToken: 'gateway-token-xyz',
   dashboardUrl: 'https://my-instance.agentcomputers.app',
-  proxyBaseUrl: 'https://clawcloud.dev/api/gateway/proxy',
+  proxyBaseUrl: 'https://agentcomputers.app/api/gateway/proxy',
 }
 
 describe('generateOpenClawConfig', () => {
@@ -65,53 +65,26 @@ describe('generateOpenClawConfig', () => {
     expect(config.gateway.auth.token).toBe('gateway-token-xyz')
     expect(config.gateway.bind).toBe('lan')
     expect(config.gateway.controlUi.allowedOrigins).toEqual(['*'])
+    expect(config.gateway.controlUi.dangerouslyDisableDeviceAuth).toBe(true)
   })
 
-  it('sets default model with primary and fallbacks', () => {
+  it('sets default model to vercel-ai-gateway provider', () => {
     const config = generateOpenClawConfig(makeInstance(), makeOrg(), defaultParams)
-    expect(config.agents.defaults.model.primary).toBe('anthropic/claude-sonnet-4-5')
-    expect(config.agents.defaults.model.fallbacks.length).toBeGreaterThan(0)
-    expect(config.agents.defaults.model.fallbacks).not.toContain(config.agents.defaults.model.primary)
+    expect(config.agents.defaults.model.primary).toBe('vercel-ai-gateway/anthropic/claude-sonnet-4-5')
   })
 
-  it('registers per-prefix providers pointing to proxy URL', () => {
+  it('does not include models.providers (uses built-in vercel-ai-gateway)', () => {
     const config = generateOpenClawConfig(makeInstance(), makeOrg(), defaultParams)
-
-    for (const prefix of ['anthropic', 'openai', 'google']) {
-      const provider = config.models.providers[prefix]
-      expect(provider).toBeDefined()
-      expect(provider.baseUrl).toBe('https://clawcloud.dev/api/gateway/proxy')
-      expect(provider.api).toBe('openai-responses')
-      expect(provider.models.length).toBeGreaterThan(0)
-      expect(provider.models.every((m: { id: string }) => m.id.startsWith(`${prefix}/`))).toBe(true)
-    }
-  })
-
-  it('uses gateway token as API key for all providers', () => {
-    const config = generateOpenClawConfig(makeInstance(), makeOrg(), defaultParams)
-
-    for (const prefix of ['anthropic', 'openai', 'google']) {
-      expect(config.models.providers[prefix].apiKey).toBe('gateway-token-xyz')
-    }
+    expect((config as Record<string, unknown>).models).toBeUndefined()
   })
 
-  it('does not include any billing headers or secrets', () => {
+  it('does not include any secrets in the config', () => {
     const config = generateOpenClawConfig(makeInstance(), makeOrg(), defaultParams)
     const configStr = JSON.stringify(config)
 
     expect(configStr).not.toContain('stripe')
     expect(configStr).not.toContain('rk_test')
-    expect(configStr).not.toContain('restricted')
-
-    for (const prefix of ['anthropic', 'openai', 'google']) {
-      expect((config.models.providers[prefix] as unknown as Record<string, unknown>).headers).toBeUndefined()
-    }
-  })
-
-  it('works without stripe_customer_id (no longer required)', () => {
-    const org = makeOrg({ stripe_customer_id: null })
-    expect(() =>
-      generateOpenClawConfig(makeInstance(), org, defaultParams)
-    ).not.toThrow()
+    expect(configStr).not.toContain('AI_GATEWAY_API_KEY')
+    expect(configStr).not.toContain('proxyBaseUrl')
   })
 })

src/lib/openclaw/config.ts

@@ -13,37 +13,12 @@ export interface OpenClawConfig {
   }
   agents: {
     defaults: {
-      model: { primary: string; fallbacks: string[] }
+      model: { primary: string }
     }
   }
-  models: {
-    mode: string
-    providers: Record<string, {
-      baseUrl: string
-      apiKey: string
-      api: string
-      models: Array<{ id: string; name: string }>
-    }>
-  }
-}
-
-const DEFAULT_MODEL = 'anthropic/claude-sonnet-4-5'
-
-const AVAILABLE_MODELS: Record<string, Array<{ id: string; name: string }>> = {
-  anthropic: [
-    { id: 'anthropic/claude-sonnet-4-5', name: 'Claude Sonnet 4.5' },
-    { id: 'anthropic/claude-opus-4-6', name: 'Claude Opus 4.6' },
-  ],
-  openai: [
-    { id: 'openai/gpt-4o', name: 'GPT-4o' },
-    { id: 'openai/o3-mini', name: 'o3-mini' },
-  ],
-  google: [
-    { id: 'google/gemini-2.5-pro', name: 'Gemini 2.5 Pro' },
-  ],
 }
 
-const ALL_MODELS = Object.values(AVAILABLE_MODELS).flat()
+const DEFAULT_MODEL = 'vercel-ai-gateway/anthropic/claude-sonnet-4-5'
 
 interface ConfigParams {
   gatewayToken: string
@@ -54,9 +29,10 @@ interface ConfigParams {
 /**
  * Generate the OpenClaw configuration for a VPS instance.
  *
- * No secrets (AI gateway key, Stripe keys) are included — LLM requests
- * go through the ClawCloud proxy which holds secrets server-side.
- * The VPS authenticates to the proxy using its gateway_token.
+ * Uses the built-in vercel-ai-gateway provider. The API key and base URL
+ * are set via environment variables (AI_GATEWAY_API_KEY, AI_GATEWAY_BASE_URL)
+ * in ~/.openclaw/.env, not in this config file. OpenClaw auto-discovers
+ * all available models from the gateway.
  */
 export function generateOpenClawConfig(
   _instance: Instance,
@@ -77,23 +53,8 @@ export function generateOpenClawConfig(
       defaults: {
         model: {
           primary: DEFAULT_MODEL,
-          fallbacks: ALL_MODELS.filter(m => m.id !== DEFAULT_MODEL).map(m => m.id),
         },
       },
     },
-    models: {
-      mode: 'merge',
-      providers: Object.fromEntries(
-        Object.entries(AVAILABLE_MODELS).map(([provider, models]) => [
-          provider,
-          {
-            baseUrl: params.proxyBaseUrl,
-            apiKey: params.gatewayToken,
-            api: 'openai-responses',
-            models,
-          },
-        ])
-      ),
-    },
   }
 }