Anthropic

import os
import scalekit.client
from dotenv import load_dotenv
import anthropic
from google.protobuf.json_format import MessageToDict

load_dotenv()

scalekit_client = scalekit.client.ScalekitClient(
    client_id=os.getenv("SCALEKIT_CLIENT_ID"),
    client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
    env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
)
actions = scalekit_client.actions
client = anthropic.Anthropic()

import 'dotenv/config';
import { ScalekitClient } from '@scalekit-sdk/node';
import Anthropic from '@anthropic-ai/sdk';

const scalekit = new ScalekitClient(
  process.env.SCALEKIT_ENVIRONMENT_URL!,
  process.env.SCALEKIT_CLIENT_ID!,
  process.env.SCALEKIT_CLIENT_SECRET!,
);
const anthropic = new Anthropic();

1
# Connect the user's Gmail account, and wait until it's ACTIVE before calling tools
2
connection_name = "gmail"
3
identifier = "user_123"  # your app's unique user ID
4

5
response = actions.get_or_create_connected_account(
6
    connection_name=connection_name, identifier=identifier
7
)
8
if response.connected_account.status != "ACTIVE":
9
    link = actions.get_authorization_link(
10
        connection_name=connection_name, identifier=identifier
11
    )
12
    print("Authorize Gmail:", link.link)
13
    input("Press Enter after authorizing...")
14
    # Fetch the account again to pick up the new status
15
    response = actions.get_or_create_connected_account(
16
        connection_name=connection_name, identifier=identifier
17
    )
18

19
if response.connected_account.status != "ACTIVE":
20
    raise RuntimeError(
21
        f"Gmail is {response.connected_account.status}, not ACTIVE. Authorize it and run again."
22
    )

1
import { createInterface } from 'node:readline/promises';
2
import { ConnectorStatus } from '@scalekit-sdk/node';
3

4
// Connect the user's Gmail account, and wait until it's ACTIVE before calling tools
5
const connectionName = 'gmail';
6
const identifier = 'user_123'; // your app's unique user ID
7

8
let { connectedAccount } = await scalekit.actions.getOrCreateConnectedAccount({
9
  connectionName,
10
  identifier,
11
});
12
if (connectedAccount?.status !== ConnectorStatus.ACTIVE) {
13
  const { link } = await scalekit.actions.getAuthorizationLink({ connectionName, identifier });
14
  console.log('Authorize Gmail:', link);
15
  const rl = createInterface({ input: process.stdin, output: process.stdout });
16
  await rl.question('Press Enter after authorizing...');
17
  rl.close();
18
  // Fetch the account again to pick up the new status
19
  ({ connectedAccount } = await scalekit.actions.getOrCreateConnectedAccount({
20
    connectionName,
21
    identifier,
22
  }));
23
}
24

25
if (connectedAccount?.status !== ConnectorStatus.ACTIVE) {
26
  throw new Error(`Gmail is not ACTIVE (status ${connectedAccount?.status}). Authorize it and run again.`);
27
}

1
# Fetch tools scoped to this user
2
scoped_response, _ = actions.tools.list_scoped_tools(
3
    identifier="user_123",
4
    filter={"connection_names": ["gmail"]},
5
    page_size=100,  # up to 100 tools per page; page with next_page_token for more
6
)
7
llm_tools = [
8
    {
9
        "name": MessageToDict(t.tool).get("definition", {}).get("name"),
10
        "description": MessageToDict(t.tool).get("definition", {}).get("description", ""),
11
        "input_schema": MessageToDict(t.tool).get("definition", {}).get("input_schema", {}),
12
    }
13
    for t in scoped_response.tools
14
]
15

16
# Run the agent loop
17
messages = [{"role": "user", "content": "Fetch my last 5 unread emails and summarize them"}]
18

19
def ask():
20
    return client.messages.create(
21
        model="claude-sonnet-4-6",
22
        max_tokens=4096,
23
        tools=llm_tools,
24
        messages=messages,
25
    )
26

27
response = ask()
28
while response.stop_reason == "tool_use":
29
    tool_results = []
30
    for block in response.content:
31
        if block.type == "tool_use":
32
            result = actions.execute_tool(
33
                tool_name=block.name,
34
                identifier="user_123",
35
                connection_name="gmail",
36
                tool_input=block.input,
37
            )
38
            tool_results.append({
39
                "type": "tool_result",
40
                "tool_use_id": block.id,
41
                "content": str(result.data),
42
            })
43

44
    messages.append({"role": "assistant", "content": response.content})
45
    messages.append({"role": "user", "content": tool_results})
46
    response = ask()
47

48
# end_turn is the normal finish. Others, such as max_tokens or refusal, end early.
49
if response.stop_reason != "end_turn":
50
    print(f"Stopped early: {response.stop_reason}")
51
print("".join(block.text for block in response.content if block.type == "text"))

1
// Fetch tools scoped to this user
2
const { tools } = await scalekit.tools.listScopedTools('user_123', {
3
  filter: { connectionNames: ['gmail'] },
4
  pageSize: 100, // up to 100 tools per page; page with nextPageToken for more
5
});
6
// Tool definitions are typed as generic JSON, so read each field explicitly
7
const llmTools: Anthropic.Tool[] = tools.flatMap((t) => {
8
  const definition = t.tool?.definition;
9
  if (!definition) return [];
10
  return [{
11
    name: String(definition.name),
12
    description: String(definition.description ?? ''),
13
    input_schema: definition.input_schema as Anthropic.Tool.InputSchema,
14
  }];
15
});
16

17
// Run the agent loop
18
const messages: Anthropic.MessageParam[] = [
19
  { role: 'user', content: 'Fetch my last 5 unread emails and summarize them' },
20
];
21

22
const ask = () =>
23
  anthropic.messages.create({
24
    model: 'claude-sonnet-4-6',
25
    max_tokens: 4096,
26
    tools: llmTools,
27
    messages,
28
  });
29

30
let response = await ask();
31
while (response.stop_reason === 'tool_use') {
32
  const toolResults: Anthropic.ToolResultBlockParam[] = [];
33
  for (const block of response.content) {
34
    if (block.type === 'tool_use') {
35
      const result = await scalekit.actions.executeTool({
36
        toolName: block.name,
37
        identifier: 'user_123',
38
        connector: 'gmail',
39
        toolInput: block.input as Record<string, unknown>,
40
      });
41
      toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: JSON.stringify(result.data) });
42
    }
43
  }
44
  messages.push({ role: 'assistant', content: response.content });
45
  messages.push({ role: 'user', content: toolResults });
46
  response = await ask();
47
}
48

49
// end_turn is the normal finish. Others, such as max_tokens or refusal, end early.
50
if (response.stop_reason !== 'end_turn') console.log(`Stopped early: ${response.stop_reason}`);
51
for (const block of response.content) {
52
  if (block.type === 'text') console.log(block.text);
53
}

1
from datetime import timedelta
2

3
# Returned by create_config when you created the Virtual MCP server
4
config_id = os.environ["SCALEKIT_MCP_CONFIG_ID"]
5
mcp_url = os.environ["SCALEKIT_MCP_SERVER_URL"]
6

7
# Mint a fresh session token for this user before each agent run
8
mcp_token = actions.mcp.create_session_token(
9
    mcp_config_id=config_id,
10
    identifier="user_123",
11
    expiry=timedelta(hours=1),
12
).token
13

14
response = client.beta.messages.create(
15
    model="claude-sonnet-4-6",
16
    max_tokens=4096,
17
    messages=[{"role": "user", "content": "Fetch my last 5 unread emails and summarize them"}],
18
    mcp_servers=[
19
        {"type": "url", "url": mcp_url, "name": "scalekit", "authorization_token": mcp_token}
20
    ],
21
    tools=[{"type": "mcp_toolset", "mcp_server_name": "scalekit"}],
22
    betas=["mcp-client-2025-11-20"],
23
)
24
print("".join(block.text for block in response.content if block.type == "text"))

1
// Mint the token on your backend with scalekit.actions.mcp.createSessionToken
2
// (see Mint session tokens) and pass it in here.
3
const mcpUrl = process.env.SCALEKIT_MCP_SERVER_URL!; // mcp_server_url from your Virtual MCP server
4
const mcpToken = process.env.SCALEKIT_MCP_SESSION_TOKEN!; // minted on your backend for this user
5

6
const response = await anthropic.beta.messages.create({
7
  model: 'claude-sonnet-4-6',
8
  max_tokens: 4096,
9
  messages: [{ role: 'user', content: 'Fetch my last 5 unread emails and summarize them' }],
10
  mcp_servers: [{ type: 'url', url: mcpUrl, name: 'scalekit', authorization_token: mcpToken }],
11
  tools: [{ type: 'mcp_toolset', mcp_server_name: 'scalekit' }],
12
  betas: ['mcp-client-2025-11-20'],
13
});
14
for (const block of response.content) {
15
  if (block.type === 'text') console.log(block.text);
16
}