1
import { createOpenRouter } from '@openrouter/ai-sdk-provider';
2
import {
3
  streamText,
4
  convertToModelMessages,
5
  UIMessage,
6
  wrapLanguageModel,
7
} from 'ai';
8

9
import { createOpenRouterV3Middleware } from '@ai-billing/openrouter';
10
import { consoleDestination } from '@ai-billing/core';
11
import { createPolarDestination } from '@ai-billing/polar';
12

13
type BillingTags = {
14
  customer_id?: string;
15
  org_name?: string;
16
};
17

18
const polarDestination = createPolarDestination<BillingTags>({
19
  accessToken: process.env.POLAR_ACCESS_TOKEN, // Make sure this is in your .env
20
  eventName: 'llm_usage', // The slug from your Polar dashboard
21
  server: 'sandbox', // Good for testing!
22
});
23

24
const openrouter = createOpenRouter({
25
  // eslint-disable-next-line turbo/no-undeclared-env-vars
26
  apiKey: process.env.OPENROUTER_API_KEY,
27
});
28

29
//const consoleLogger = new ConsoleDestination();
30
const billingMiddleware = createOpenRouterV3Middleware<BillingTags>({
31
  destinations: [consoleDestination(), polarDestination],
32
});
33

34
export async function POST() {
35
  const messages: UIMessage[] = [
36
    {
37
      id: 'test-message-123',
38
      role: 'user',
39
      parts: [
40
        {
41
          type: 'text',
42
          text: 'What is the capital of Sweden?',
43
        },
44
      ],
45
    },
46
  ];
47

48
  const model = 'google/gemini-2.0-flash-001';
49

50
  const wrappedModel = wrapLanguageModel({
51
    model: openrouter(model),
52
    middleware: billingMiddleware,
53
  });
54

55
  const result = streamText({
56
    model: wrappedModel,
57
    messages: await convertToModelMessages(messages),
58
    providerOptions: {
59
      'ai-billing-tags': {
60
        customer_id: '4a874ea3-53ec-432d-9d55-c55bf957e18f', // This triggers internalCustomerId in Polar
61
        org_name: 'Acme Corp', // This will end up in Polar metadata
62
      } as BillingTags,
63
    },
64
  });
65

66
  return result.toUIMessageStreamResponse();
67
}

1
import { createOpenRouter } from '@openrouter/ai-sdk-provider';
2
import {
3
  streamText,
4
  convertToModelMessages,
5
  UIMessage,
6
  wrapLanguageModel,
7
} from 'ai';
8
import { createOpenRouterV3Middleware } from '@ai-billing/openrouter';
9
import { consoleDestination } from '@ai-billing/core';
10
import { createLagoDestination } from '@ai-billing/lago';
11

12
type BillingTags = {
13
  userId?: string;
14
};
15

16
const lagoDestination = createLagoDestination<BillingTags>({
17
  apiKey: `${process.env.LAGO_API_KEY}`,
18
  apiUrl: process.env.LAGO_API_URL,
19
  meterCode: 'llm_usage',
20
});
21

22
const openrouter = createOpenRouter({
23
  // eslint-disable-next-line turbo/no-undeclared-env-vars
24
  apiKey: process.env.OPENROUTER_API_KEY,
25
});
26

27
const billingMiddleware = createOpenRouterV3Middleware<BillingTags>({
28
  destinations: [consoleDestination(), lagoDestination],
29
});
30

31
export async function POST() {
32
  const messages: UIMessage[] = [
33
    {
34
      id: 'test-message-123',
35
      role: 'user',
36
      parts: [
37
        {
38
          type: 'text',
39
          text: 'What is the capital of Sweden?',
40
        },
41
      ],
42
    },
43
  ];
44

45
  const model = 'openai/gpt-4o';
46

47
  const wrappedModel = wrapLanguageModel({
48
    model: openrouter(model),
49
    middleware: billingMiddleware,
50
  });
51

52
  const result = streamText({
53
    model: wrappedModel,
54
    messages: await convertToModelMessages(messages),
55
    providerOptions: {
56
      'ai-billing-tags': {
57
        userId: 'user_lago_test',
58
      } as BillingTags,
59
    },
60
  });
61

62
  return result.toUIMessageStreamResponse();
63
}

1
import { createOpenRouter } from '@openrouter/ai-sdk-provider';
2
import {
3
  streamText,
4
  convertToModelMessages,
5
  UIMessage,
6
  wrapLanguageModel,
7
} from 'ai';
8
import { createOpenRouterV3Middleware } from '@ai-billing/openrouter';
9
import { consoleDestination } from '@ai-billing/core';
10
import { createOpenMeterDestination } from '@ai-billing/openmeter';
11

12
type BillingTags = {
13
  userId?: string;
14
  org_name?: string;
15
};
16

17
const openMeterDestination = createOpenMeterDestination<BillingTags>({
18
  apiKey: `${process.env.OPENMETER_API_KEY}`,
19
});
20

21
const openrouter = createOpenRouter({
22
  // eslint-disable-next-line turbo/no-undeclared-env-vars
23
  apiKey: process.env.OPENROUTER_API_KEY,
24
});
25

26
const billingMiddleware = createOpenRouterV3Middleware<BillingTags>({
27
  destinations: [consoleDestination(), openMeterDestination],
28
});
29

30
export async function POST() {
31
  const messages: UIMessage[] = [
32
    {
33
      id: 'test-message-123',
34
      role: 'user',
35
      parts: [{ type: 'text', text: 'What is the capital of Sweden?' }],
36
    },
37
  ];
38

39
  const model = 'openai/gpt-4o';
40

41
  const wrappedModel = wrapLanguageModel({
42
    model: openrouter(model),
43
    middleware: billingMiddleware,
44
  });
45

46
  const result = streamText({
47
    model: wrappedModel,
48
    messages: await convertToModelMessages(messages),
49
    providerOptions: {
50
      'ai-billing-tags': {
51
        userId: 'user_openmeter_test',
52
        org_name: 'Acme Corp',
53
      } as BillingTags,
54
    },
55
  });
56

57
  return result.toUIMessageStreamResponse();
58
}