Anthropic Messages API with 资产生成

import Anthropic from '@anthropic-ai/sdk';
 
const anthropic = new Anthropic({
  apiKey: process.env.AI_GATEWAY_API_KEY,
  baseURL: 'https://ai-gateway.vercel.sh',
});
 
const message = await anthropic.messages.create({
  model: 'anthropic/claude-opus-5',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello, world!' }],
});

import os
import anthropic
 
client = anthropic.Anthropic(
    api_key=os.getenv('AI_GATEWAY_API_KEY'),
    base_url='https://ai-gateway.vercel.sh'
)
 
message = client.messages.create(
    model='anthropic/claude-opus-5',
    max_tokens=1024,
    messages=[
        {'role': 'user', 'content': 'Hello, world!'}
    ]
)

curl -X POST "https://ai-gateway.vercel.sh/v1/messages" \
  -H "Authorization: Bearer $AI_GATEWAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-opus-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Hello, world!"
      }
    ]
  }'

import Anthropic from '@anthropic-ai/sdk';
import { setTimeout } from 'node:timers/promises';
 
const client = new Anthropic({
  apiKey: process.env.AI_GATEWAY_API_KEY,
  baseURL: 'https://ai-gateway.vercel.sh',
});
const key = process.env.AI_GATEWAY_BATCH_IDEMPOTENCY_KEY;
if (!key) throw new Error('Set AI_GATEWAY_BATCH_IDEMPOTENCY_KEY');
 
let batch = await client.messages.batches.create(
  {
    requests: [{
      custom_id: 'review-1',
      params: {
        model: 'anthropic/claude-haiku-4.5',
        max_tokens: 64,
        messages: [{ role: 'user', content: 'Classify as positive or negative: I love this app.' }],
      },
    }],
  },
  { headers: { 'Idempotency-Key': key } },
);
console.log('Batch ID:', batch.id);
 
for (let attempt = 0; attempt < 20 && batch.processing_status !== 'ended'; attempt++) {
  await setTimeout(30_000);
  batch = await client.messages.batches.retrieve(batch.id);
}
if (batch.processing_status !== 'ended') {
  throw new Error(`Still processing. Resume polling batch ${batch.id} later.`);
}
if (!batch.results_url) {
  throw new Error(`No downloadable results for batch ${batch.id}.`);
}
 
const results = await client.messages.batches.results(batch.id);
for await (const item of results) {
  if (item.result.type === 'succeeded') {
    console.log(item.custom_id, item.result.message.content);
  } else {
    console.error(item.custom_id, item.result);
  }
}

import Anthropic from '@anthropic-ai/sdk';
import { setTimeout } from 'node:timers/promises';
 
const client = new Anthropic({
  apiKey: process.env.AI_GATEWAY_API_KEY,
  baseURL: 'https://ai-gateway.vercel.sh',
});
const key = process.env.AI_GATEWAY_BATCH_IDEMPOTENCY_KEY;
if (!key) throw new Error('Set AI_GATEWAY_BATCH_IDEMPOTENCY_KEY');
 
let batch = await client.messages.batches.create(
  {
    requests: [{
      custom_id: 'review-1',
      params: {
        model: 'anthropic/claude-haiku-4.5',
        max_tokens: 64,
        messages: [{ role: 'user', content: 'Classify as positive or negative: I love this app.' }],
      },
    }],
  },
  { headers: { 'Idempotency-Key': key } },
);
console.log('Batch ID:', batch.id);
 
for (let attempt = 0; attempt < 20 && batch.processing_status !== 'ended'; attempt++) {
  await setTimeout(30_000);
  batch = await client.messages.batches.retrieve(batch.id);
}
if (batch.processing_status !== 'ended') {
  throw new Error(`Still processing. Resume polling batch ${batch.id} later.`);
}
if (!batch.results_url) {
  throw new Error(`No downloadable results for batch ${batch.id}.`);
}
 
const results = await client.messages.batches.results(batch.id);
for await (const item of results) {
  if (item.result.type === 'succeeded') {
    console.log(item.custom_id, item.result.message.content);
  } else {
    console.error(item.custom_id, item.result);
  }
}

import os
import time
import anthropic
 
client = anthropic.Anthropic(
    api_key=os.environ['AI_GATEWAY_API_KEY'],
    base_url='https://ai-gateway.vercel.sh',
)
batch = client.messages.batches.create(
    requests=[{
        'custom_id': 'review-1',
        'params': {
            'model': 'anthropic/claude-haiku-4.5',
            'max_tokens': 64,
            'messages': [{'role': 'user', 'content': 'Classify as positive or negative: I love this app.'}],
        },
    }],
    extra_headers={'Idempotency-Key': os.environ['AI_GATEWAY_BATCH_IDEMPOTENCY_KEY']},
)
print('Batch ID:', batch.id, flush=True)
 
for _ in range(20):
    if batch.processing_status == 'ended':
        break
    time.sleep(30)
    batch = client.messages.batches.retrieve(batch.id)
if batch.processing_status != 'ended':
    raise RuntimeError(f'Still processing. Resume polling batch {batch.id} later.')
if not batch.results_url:
    raise RuntimeError(f'No downloadable results for batch {batch.id}.')
 
for item in client.messages.batches.results(batch.id):
    if item.result.type == 'succeeded':
        print(item.custom_id, item.result.message.content)
    else:
        print(item.custom_id, item.result)

import fs from 'node:fs';
import Anthropic from '@anthropic-ai/sdk';
 
const apiKey = process.env.AI_GATEWAY_API_KEY || process.env.VERCEL_OIDC_TOKEN;
 
const anthropic = new Anthropic({
  apiKey,
  baseURL: 'https://ai-gateway.vercel.sh',
});
 
// Caching only pays off above a provider minimum, currently 1024 tokens for
// most Claude models. A short string is silently not cached.
const longDocumentContent = fs.readFileSync('./contract.txt', 'utf8');
 
const message = await anthropic.messages.create({
  model: 'anthropic/claude-opus-5',
  max_tokens: 1024,
  system: [
    {
      type: 'text',
      text: 'You are a helpful assistant that analyzes documents.',
    },
    {
      type: 'text',
      text: longDocumentContent,
      cache_control: { type: 'ephemeral' },
    },
  ],
  messages: [
    {
      role: 'user',
      content: 'Summarize the key points from this document.',
    },
  ],
});
 
console.log(message.usage);
// {
//   input_tokens: 50,
//   output_tokens: 200,
//   cache_creation_input_tokens: 10000,  // Tokens written to cache
//   cache_read_input_tokens: 0           // Tokens read from cache
// }

import os
import anthropic
 
api_key = os.getenv('AI_GATEWAY_API_KEY') or os.getenv('VERCEL_OIDC_TOKEN')
 
client = anthropic.Anthropic(
    api_key=api_key,
    base_url='https://ai-gateway.vercel.sh'
)
 
# Caching only pays off above a provider minimum, currently 1024 tokens for
# most Claude models. A short string is silently not cached.
with open('contract.txt') as f:
    long_document_content = f.read()
 
message = client.messages.create(
    model='anthropic/claude-opus-5',
    max_tokens=1024,
    system=[
        {
            'type': 'text',
            'text': 'You are a helpful assistant that analyzes documents.',
        },
        {
            'type': 'text',
            'text': long_document_content,  # Large content to cache
            'cache_control': {'type': 'ephemeral'},
        },
    ],
    messages=[
        {
            'role': 'user',
            'content': 'Summarize the key points from this document.'
        }
    ],
)
 
print(message.usage)
# {
#   'input_tokens': 50,
#   'output_tokens': 200,
#   'cache_creation_input_tokens': 10000,  # Tokens written to cache
#   'cache_read_input_tokens': 0           # Tokens read from cache
# }

CONTRACT=$(sed 's/"/\\"/g' contract.txt | tr '\n' ' ')
 
curl -X POST "https://ai-gateway.vercel.sh/v1/messages" \
  -H "Authorization: Bearer $AI_GATEWAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-opus-5",
    "max_tokens": 1024,
    "system": [
      { "type": "text", "text": "You are a helpful assistant that analyzes documents." },
      {
        "type": "text",
        "text": "'"$CONTRACT"'",
        "cache_control": { "type": "ephemeral" }
      }
    ],
    "messages": [
      { "role": "user", "content": "Summarize the key points from this document." }
    ]
  }'