@scalar/agent 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Scalar Agent SDK
 
-Connect your AI agent to Scalar's OpenAPI MCP servers. Provides native integrations for the Vercel AI SDK, OpenAI Agents SDK, and Anthropic Claude SDK.
+Connect your AI agent to Scalar's OpenAPI MCP servers. Provides native integrations for the Vercel AI SDK, OpenAI Agents SDK, and Anthropic Claude Agent SDK.
 
 ## Installation
 
@@ -22,20 +22,12 @@ bun i @scalar/agent
 import { agentScalar } from '@scalar/agent'
 
 const scalar = agentScalar({
-  agentKey: 'your-agent-key',
+  token: 'your-personal-token',
 })
 
-const session = await scalar.session({
-  apis: [{ namespace: 'scalar', slug: 'galaxy' }],
-})
+const installation = await scalar.installation('your-installation-id')
 ```
 
-# Agent Key
-
-An agent key allows access to private APIs as well as a default set of APIs if configured for a key. [Learn more about agent keys](https://scalar.com/products/agent/key).
-
-Agent keys also identify your team for billing and analytics.
-
 ## Providers
 
 ### Vercel AI SDK
@@ -43,126 +35,85 @@ Agent keys also identify your team for billing and analytics.
 Uses `@ai-sdk/mcp` natively. Returns a tool set ready for `generateText` / `streamText`.
 
 ```ts
-import { generateText } from 'ai'
-import { openai } from '@ai-sdk/openai'
+import { agentScalar } from '@scalar/agent'
+import { generateText, stepCountIs } from 'ai'
 
 const scalar = agentScalar({
-  agentKey: 'your-agent-key',
+  token: 'your-personal-token',
 })
 
-const session = await scalar.session({
-  apis: [{ namespace: 'scalar', slug: 'galaxy' }],
-})
+const installation = await scalar.installation('your-installation-id')
 
-const tools = await session.createVercelAITools()
+const tools = await installation.createVercelAITools()
 
 const { text } = await generateText({
-  model: openai('gpt-4o'),
+  model,
   tools,
-  prompt: 'List the available endpoints in the Galaxy API',
+  stopWhen: stepCountIs(5),
+  prompt: 'How do I create a planet?',
 })
 ```
 
 ### OpenAI Agents SDK
 
-Returns `MCPServerStreamableHttpOptions[]` — pass each entry to `new MCPServerStreamableHttp()` from `@openai/agents`. The agent runtime handles tool discovery and execution natively.
+Returns options for `MCPServerStreamableHttp` from `@openai/agents`. The agent runtime handles tool discovery and execution natively.
 
 ```ts
+import { agentScalar } from '@scalar/agent'
 import { Agent, MCPServerStreamableHttp, run } from '@openai/agents'
 
 const scalar = agentScalar({
-  agentKey: 'your-agent-key',
+  token: 'your-token',
 })
 
-const session = await scalar.session({
-  apis: [{ namespace: 'scalar', slug: 'galaxy' }],
-})
+const installation = await scalar.installation('your-installation-id')
 
-const serverOptions = session.createOpenAIMCPServerOptions()
-const servers = serverOptions.map((opts) => new MCPServerStreamableHttp(opts))
-await Promise.all(servers.map((s) => s.connect()))
+const server = new MCPServerStreamableHttp(installation.createOpenAIMCP())
+await server.connect()
 
 const agent = new Agent({
   name: 'api-agent',
-  instructions: 'You help users interact with APIs.',
-  mcpServers: servers,
+  mcpServers: [server],
 })
 
 const result = await run(
   agent,
-  'List the available endpoints in the Galaxy API',
+  'Which APIs are available that let me create a planet?',
 )
 
-await Promise.all(servers.map((s) => s.close()))
+await server.close()
 ```
 
-### Anthropic Claude SDK
+### Anthropic Claude Agent SDK
 
-Uses `@modelcontextprotocol/sdk` directly. Returns `tools` (ready for `messages.create`) and `executeTool` (for handling `tool_use` response blocks).
+Returns an MCP server configuration for `@anthropic-ai/claude-agent-sdk`.
 
 ```ts
-import Anthropic from '@anthropic-ai/sdk'
+import { agentScalar } from '@scalar/agent'
+import { query } from '@anthropic-ai/claude-agent-sdk'
 
 const scalar = agentScalar({
-  agentKey: 'your-agent-key',
-})
-
-const session = await scalar.session({
-  apis: [{ namespace: 'scalar', slug: 'galaxy' }],
+  token: 'your-token',
 })
 
-const client = new Anthropic()
-const { tools, executeTool } = await session.createAnthropicTools()
-
-const messages: Anthropic.MessageParam[] = [
-  { role: 'user', content: 'List the available endpoints in the Galaxy API' },
-]
-
-// Agentic loop
-while (true) {
-  const response = await client.messages.create({
-    model: 'claude-opus-4-6',
-    max_tokens: 4096,
-    tools,
-    messages,
-  })
-
-  messages.push({ role: 'assistant', content: response.content })
-
-  if (response.stop_reason !== 'tool_use') break
-
-  const toolResults: Anthropic.ToolResultBlockParam[] = await Promise.all(
-    response.content
-      .filter(
-        (block): block is Anthropic.ToolUseBlock => block.type === 'tool_use',
-      )
-      .map(async (block) => ({
-        type: 'tool_result',
-        tool_use_id: block.id,
-        content: await executeTool(
-          block.name,
-          block.input as Record<string, unknown>,
-        ),
-      })),
-  )
-
-  messages.push({ role: 'user', content: toolResults })
+const installation = await scalar.installation('your-installation-id')
+
+for await (const message of query({
+  prompt: 'Which APIs are available that let me create a planet?',
+  options: {
+    mcpServers: {
+      scalar: installation.createAnthropicMCP(),
+    },
+    allowedTools: ['mcp__scalar__*'],
+  },
+})) {
+  if ('result' in message) console.log(message.result)
 }
 ```
 
 ## Configuration
 
-| Option     | Type     | Description                                                            |
-| ---------- | -------- | ---------------------------------------------------------------------- |
-| `agentKey` | `string` | Scalar agent key, sent as the authorization request header             |
-| `baseUrl`  | `string` | Base URL of the Scalar MCP server. Defaults to the staging environment |
-
-## How it works
-
-Each Scalar API is exposed as an MCP (Model Context Protocol) server. The SDK connects to these servers and surfaces their tools to your AI framework of choice. Every API exposes three tools:
-
-- **`get-openapi-specs-summary`** — lists the available endpoints
-- **`get-mini-openapi-spec`** — fetches a trimmed OpenAPI spec for specific endpoints
-- **`execute-request`** — executes an HTTP request against the API
-
-Tools are namespaced by API to avoid collisions when connecting multiple APIs at once: `{namespace}{delimiter}{slug}__{toolName}`.
+| Option    | Type     | Description                                                           |
+| --------- | -------- | --------------------------------------------------------------------- |
+| `token`   | `string` | Your Scalar Personal Token used to authenticate requests to your MCP  |
+| `baseUrl` | `string` | Base URL of the Scalar MCP server. Defaults to the Scalar environment |

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare enum Provider {
+    VERCEL = "VERCEL",
+    OPENAI = "OPENAI",
+    ANTHROPIC = "ANTHROPIC"
+}
+export declare const SDK_PROVIDER_HEADER_NAME = "X-Scalar-SDK-Provider";

package/dist/constants.js

@@ -0,0 +1,11 @@
+var Provider = /* @__PURE__ */ ((Provider2) => {
+  Provider2["VERCEL"] = "VERCEL";
+  Provider2["OPENAI"] = "OPENAI";
+  Provider2["ANTHROPIC"] = "ANTHROPIC";
+  return Provider2;
+})(Provider || {});
+const SDK_PROVIDER_HEADER_NAME = "X-Scalar-SDK-Provider";
+export {
+  Provider,
+  SDK_PROVIDER_HEADER_NAME
+};

package/dist/index.d.ts

@@ -1,158 +1,113 @@
-import type Anthropic from '@anthropic-ai/sdk';
-import z from 'zod';
+import type { McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
+import type { ToolSet } from 'ai';
 export interface AgentSDKConfig {
     /** Base URL of the Scalar MCP server. Defaults to the Scalar staging environment. */
     baseUrl?: string;
-    /** Sent as the `x-scalar-agent-key` request header. */
-    agentKey?: string;
+    /** Your Scalar Personal Token used to authenticate requests to your MCP. */
+    token: string;
 }
-type Api = {
-    namespace: string;
-    slug: string;
-};
 export type MCPServerOptions = {
     url: string;
     name: string;
     fetch: (url: RequestInfo | URL, options?: RequestInit) => Promise<Response>;
 };
-export declare const EXECUTE_REQUEST_TOOL_NAME = "execute-request";
-export declare const executeRequestToolInputSchema: z.ZodObject<{
-    method: z.ZodString;
-    path: z.ZodString;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    body: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const mcpToolSchemas: {
-    "execute-request": {
-        inputSchema: z.ZodObject<{
-            method: z.ZodString;
-            path: z.ZodString;
-            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            body: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    };
-    "get-mini-openapi-spec": {
-        inputSchema: z.ZodObject<{
-            question: z.ZodString;
-        }, z.core.$strip>;
-    };
-    "get-openapi-specs-summary": {
-        inputSchema: z.ZodObject<{}, z.core.$strip>;
-    };
-};
 /**
  * Creates a Scalar agent client configured to connect to Scalar's MCP servers.
  *
  * @example
  * ```ts
- * const scalar = agentScalar({ agentKey: 'your-agent-key' })
+ * const scalar = agentScalar({ token: 'your-personal-token' })
+ * const installation = await scalar.installation('your-installation-id')
  * ```
  */
-export declare const agentScalar: (config?: AgentSDKConfig) => {
-    session: ({ apis }: {
-        apis: Api[];
-    }) => Promise<{
+export declare const agentScalar: (config: AgentSDKConfig) => {
+    installation: (installationId: string) => Promise<{
         /**
          * Returns tools in Vercel AI SDK format.
          * Uses `@ai-sdk/mcp` natively.
          *
          * @example
          * ```ts
-         * import { agentScalar } from '@scalar/agent'
-         * import { generateText } from 'ai'
-         * import { openai } from '@ai-sdk/openai'
+         * import { agentScalar } from "@scalar/agent";
+         * import { generateText, stepCountIs } from "ai";
          *
-         * const scalar = agentScalar({ agentKey: 'your-agent-key' })
-         * const session = await scalar.session({ apis: [{ namespace: 'scalar', slug: 'galaxy' }] })
+         * const scalar = agentScalar({
+         *   token: "your-personal-token",
+         * });
+         * const installation = await scalar.installation("0c1ea059-58ad-41ec-bcf7-331fefa0f61c");
          *
-         * const tools = await session.createVercelAITools()
+         * const tools = await installation.createVercelAITools();
          *
          * const { text } = await generateText({
-         *   model: openai('gpt-4o'),
+         *   model,
          *   tools,
-         *   prompt: 'List the available endpoints in the Petstore API',
-         * })
+         *   stopWhen: stepCountIs(5),
+         *   prompt: "How do I create a planet?",
+         * });
          * ```
          */
-        createVercelAITools: () => Promise<any>;
+        createVercelAITools: () => Promise<ToolSet>;
         /**
-         * Returns options for creating `MCPServerStreamableHttp` instances via `@openai/agents`.
+         * Returns options for creating an `MCPServerStreamableHttp` instance via `@openai/agents`.
          * The agent handles tool discovery and execution natively.
          *
          * @example
          * ```ts
-         * import { agentScalar } from '@scalar/agent'
-         * import { Agent, MCPServerStreamableHttp, run } from '@openai/agents'
+         * import { agentScalar } from "@scalar/agent";
+         * import { Agent, MCPServerStreamableHttp, run } from "@openai/agents";
          *
-         * const scalar = agentScalar({ agentKey: 'your-agent-key' })
-         * const session = await scalar.session({ apis: [{ namespace: 'scalar', slug: 'galaxy' }] })
+         * const scalar = agentScalar({
+         *   token: "your-token",
+         * });
+         * const installation = await scalar.installation("your-installation-id");
          *
-         * const servers = (await session.createOpenAIMCP()).map((opts) => new MCPServerStreamableHttp(opts))
-         * await Promise.all(servers.map((s) => s.connect()))
+         * const server = new MCPServerStreamableHttp(installation.createOpenAIMCP());
+         * await server.connect();
          *
          * const agent = new Agent({
-         *   name: 'api-agent',
-         *   instructions: 'You help users interact with APIs.',
-         *   mcpServers: servers,
-         * })
+         *   name: "api-agent",
+         *   mcpServers: [server],
+         * });
+         *
+         * const result = await run(
+         *   agent,
+         *   "Which APIs are available that let me create a planet?",
+         * );
          *
-         * const result = await run(agent, 'List the available endpoints in the Petstore API')
-         * await Promise.all(servers.map((s) => s.close()))
+         * await server.close();
          * ```
          */
-        createOpenAIMCP: () => Promise<MCPServerOptions[]>;
+        createOpenAIMCP: () => {
+            url: string;
+            name: string;
+            fetch: (url: RequestInfo | URL, options?: RequestInit) => Promise<Response>;
+        };
         /**
-         * Returns tools in `@anthropic-ai/sdk` format.
-         * Uses `@modelcontextprotocol/sdk` Client directly — `listTools()` already returns
-         * JSON Schema so no conversion needed. Tool calls are routed back via `callTool()`.
+         * Returns an MCP server configuration for `@anthropic-ai/claude-agent-sdk`.
          *
          * @example
          * ```ts
-         * import { agentScalar } from '@scalar/agent'
-         * import Anthropic from '@anthropic-ai/sdk'
-         *
-         * const scalar = agentScalar({ agentKey: 'your-agent-key' })
-         * const session = await scalar.session({ apis: [{ namespace: 'scalar', slug: 'galaxy' }] })
-         *
-         * const client = new Anthropic()
-         * const { tools, executeTool } = await session.createAnthropicTools()
-         *
-         * const messages: Anthropic.MessageParam[] = [
-         *   { role: 'user', content: 'List the available endpoints in the Petstore API' },
-         * ]
-         *
-         * // Agentic loop
-         * while (true) {
-         *   const response = await client.messages.create({
-         *     model: 'claude-opus-4-6',
-         *     max_tokens: 4096,
-         *     tools,
-         *     messages,
-         *   })
-         *
-         *   messages.push({ role: 'assistant', content: response.content })
-         *
-         *   if (response.stop_reason !== 'tool_use') break
-         *
-         *   const toolResults = await Promise.all(
-         *     response.content
-         *       .filter((b): b is Anthropic.ToolUseBlock => b.type === 'tool_use')
-         *       .map(async (b) => ({
-         *         type: 'tool_result' as const,
-         *         tool_use_id: b.id,
-         *         content: await executeTool(b.name, b.input as Record<string, unknown>),
-         *       })),
-         *   )
-         *
-         *   messages.push({ role: 'user', content: toolResults })
+         * import { agentScalar } from "@scalar/agent";
+         * import { query } from "@anthropic-ai/claude-agent-sdk";
+         *
+         * const scalar = agentScalar({
+         *   token: "your-token",
+         * });
+         * const installation = await scalar.installation("your-installation-id");
+         *
+         * for await (const message of query({
+         *   prompt: "Which APIs are available that let me create a planet?",
+         *   options: {
+         *     mcpServers: {
+         *       scalar: installation.createAnthropicMCP(),
+         *     },
+         *     allowedTools: ["mcp__scalar__*"],
+         *   },
+         * })) {
+         *   if ("result" in message) console.log(message.result);
          * }
          * ```
          */
-        createAnthropicTools: () => Promise<{
-            tools: Anthropic.Tool[];
-            executeTool: (toolName: string, input: Record<string, unknown>) => Promise<string>;
-        }>;
+        createAnthropicMCP: () => McpServerConfig;
     }>;
 };
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,78 +1,22 @@
 import { createMCPClient } from "@ai-sdk/mcp";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import z from "zod";
-import {
-  GET_MINI_OPENAPI_SPEC_TOOL_NAME,
-  GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME,
-  getMiniOpenAPIDocToolInputSchema,
-  TOOL_NAMESPACE_SLUG_DELIMITER
-} from "@scalar/agent-chat/entities";
-import { createWorkspaceStore } from "@scalar/workspace-store/client";
-const EXECUTE_REQUEST_TOOL_NAME = "execute-request";
-const executeRequestToolInputSchema = z.object({
-  method: z.string(),
-  path: z.string(),
-  headers: z.record(z.string(), z.string()).optional(),
-  body: z.string().optional()
-});
-const mcpToolSchemas = {
-  [EXECUTE_REQUEST_TOOL_NAME]: { inputSchema: executeRequestToolInputSchema },
-  [GET_MINI_OPENAPI_SPEC_TOOL_NAME]: {
-    inputSchema: getMiniOpenAPIDocToolInputSchema
-  },
-  [GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME]: { inputSchema: z.object({}) }
-};
-function safeParseJson(value) {
-  try {
-    return { success: true, data: JSON.parse(value) };
-  } catch {
-    return { success: false };
-  }
-}
-async function resolveActiveServerUrl(api) {
-  const store = createWorkspaceStore();
-  const key = `${api.namespace}/${api.slug}`;
-  await store.addDocument({
-    name: key,
-    url: `https://registry.scalar.com/@${api.namespace}/apis/${api.slug}`
-  });
-  return store.workspace.documents[key]?.servers?.[0]?.url ?? "";
-}
-function buildMCPUrl(api, baseUrl, serverUrl) {
-  return new URL(
-    `/vector/mcp/${api.namespace}/${api.slug}?activeServerUrl=${encodeURIComponent(serverUrl)}`,
-    baseUrl
-  );
-}
-function buildFetch(agentKey) {
-  return (url, options) => {
-    const parsed = safeParseJson(options?.body);
-    if (!parsed.success) return fetch(url, options);
-    if (parsed.data.params) {
-      parsed.data.params._meta = { securitySchemes: [] };
+import { Provider, SDK_PROVIDER_HEADER_NAME } from "./constants";
+function buildFetch(token, provider) {
+  return async (url, options) => await fetch(url, {
+    ...options,
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+      [SDK_PROVIDER_HEADER_NAME]: provider,
+      ...options?.headers,
+      ...token && { Authorization: token }
     }
-    return fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json, text/event-stream",
-        ...options?.headers,
-        ...agentKey && { "x-scalar-agent-key": agentKey }
-      },
-      body: JSON.stringify(parsed.data)
-    });
-  };
-}
-function namespaceTool(api, toolName) {
-  return `${api.namespace}${TOOL_NAMESPACE_SLUG_DELIMITER}${api.slug}__${toolName}`;
+  });
 }
-const agentScalar = (config = {}) => {
+const agentScalar = (config) => {
   const baseUrl = config.baseUrl ?? "https://services.scalar.com";
-  const session = async ({ apis }) => {
-    const mcpFetch = buildFetch(config.agentKey);
-    const serverUrls = await Promise.all(apis.map(resolveActiveServerUrl));
-    const mcpUrl = (api) => buildMCPUrl(api, baseUrl, serverUrls[apis.indexOf(api)]);
+  const installation = async (installationId) => {
+    const url = new URL(`/vector/mcp/${installationId}`, baseUrl);
     return {
       /**
        * Returns tools in Vercel AI SDK format.
@@ -80,175 +24,109 @@ const agentScalar = (config = {}) => {
        *
        * @example
        * ```ts
-       * import { agentScalar } from '@scalar/agent'
-       * import { generateText } from 'ai'
-       * import { openai } from '@ai-sdk/openai'
+       * import { agentScalar } from "@scalar/agent";
+       * import { generateText, stepCountIs } from "ai";
        *
-       * const scalar = agentScalar({ agentKey: 'your-agent-key' })
-       * const session = await scalar.session({ apis: [{ namespace: 'scalar', slug: 'galaxy' }] })
+       * const scalar = agentScalar({
+       *   token: "your-personal-token",
+       * });
+       * const installation = await scalar.installation("0c1ea059-58ad-41ec-bcf7-331fefa0f61c");
        *
-       * const tools = await session.createVercelAITools()
+       * const tools = await installation.createVercelAITools();
        *
        * const { text } = await generateText({
-       *   model: openai('gpt-4o'),
+       *   model,
        *   tools,
-       *   prompt: 'List the available endpoints in the Petstore API',
-       * })
+       *   stopWhen: stepCountIs(5),
+       *   prompt: "How do I create a planet?",
+       * });
        * ```
        */
       createVercelAITools: async () => {
-        const clients = await Promise.all(
-          apis.map(async (api) => ({
-            client: await createMCPClient({
-              transport: new StreamableHTTPClientTransport(mcpUrl(api), {
-                fetch: mcpFetch
-              })
-            }),
-            api
-          }))
-        );
-        const toolSets = await Promise.all(
-          clients.map(async ({ client, api }) => {
-            const tools = await client.tools({ schemas: mcpToolSchemas });
-            return Object.fromEntries(
-              Object.entries(tools).map(([toolName, tool]) => [
-                namespaceTool(api, toolName),
-                tool
-              ])
-            );
+        const mcpFetch = buildFetch(config.token, Provider.VERCEL);
+        const client = await createMCPClient({
+          transport: new StreamableHTTPClientTransport(url, {
+            fetch: mcpFetch
           })
-        );
-        return Object.assign({}, ...toolSets);
+        });
+        return client.tools();
       },
       /**
-       * Returns options for creating `MCPServerStreamableHttp` instances via `@openai/agents`.
+       * Returns options for creating an `MCPServerStreamableHttp` instance via `@openai/agents`.
        * The agent handles tool discovery and execution natively.
        *
        * @example
        * ```ts
-       * import { agentScalar } from '@scalar/agent'
-       * import { Agent, MCPServerStreamableHttp, run } from '@openai/agents'
+       * import { agentScalar } from "@scalar/agent";
+       * import { Agent, MCPServerStreamableHttp, run } from "@openai/agents";
        *
-       * const scalar = agentScalar({ agentKey: 'your-agent-key' })
-       * const session = await scalar.session({ apis: [{ namespace: 'scalar', slug: 'galaxy' }] })
+       * const scalar = agentScalar({
+       *   token: "your-token",
+       * });
+       * const installation = await scalar.installation("your-installation-id");
        *
-       * const servers = (await session.createOpenAIMCP()).map((opts) => new MCPServerStreamableHttp(opts))
-       * await Promise.all(servers.map((s) => s.connect()))
+       * const server = new MCPServerStreamableHttp(installation.createOpenAIMCP());
+       * await server.connect();
        *
        * const agent = new Agent({
-       *   name: 'api-agent',
-       *   instructions: 'You help users interact with APIs.',
-       *   mcpServers: servers,
-       * })
+       *   name: "api-agent",
+       *   mcpServers: [server],
+       * });
        *
-       * const result = await run(agent, 'List the available endpoints in the Petstore API')
-       * await Promise.all(servers.map((s) => s.close()))
+       * const result = await run(
+       *   agent,
+       *   "Which APIs are available that let me create a planet?",
+       * );
+       *
+       * await server.close();
        * ```
        */
-      createOpenAIMCP: async () => Promise.all(
-        apis.map(async (api) => ({
-          url: mcpUrl(api).toString(),
-          name: `${api.namespace}/${api.slug}`,
+      createOpenAIMCP: () => {
+        const mcpFetch = buildFetch(config.token, Provider.OPENAI);
+        return {
+          url: url.toString(),
+          name: installationId,
           fetch: mcpFetch
-        }))
-      ),
+        };
+      },
       /**
-       * Returns tools in `@anthropic-ai/sdk` format.
-       * Uses `@modelcontextprotocol/sdk` Client directly — `listTools()` already returns
-       * JSON Schema so no conversion needed. Tool calls are routed back via `callTool()`.
+       * Returns an MCP server configuration for `@anthropic-ai/claude-agent-sdk`.
        *
        * @example
        * ```ts
-       * import { agentScalar } from '@scalar/agent'
-       * import Anthropic from '@anthropic-ai/sdk'
-       *
-       * const scalar = agentScalar({ agentKey: 'your-agent-key' })
-       * const session = await scalar.session({ apis: [{ namespace: 'scalar', slug: 'galaxy' }] })
-       *
-       * const client = new Anthropic()
-       * const { tools, executeTool } = await session.createAnthropicTools()
-       *
-       * const messages: Anthropic.MessageParam[] = [
-       *   { role: 'user', content: 'List the available endpoints in the Petstore API' },
-       * ]
-       *
-       * // Agentic loop
-       * while (true) {
-       *   const response = await client.messages.create({
-       *     model: 'claude-opus-4-6',
-       *     max_tokens: 4096,
-       *     tools,
-       *     messages,
-       *   })
-       *
-       *   messages.push({ role: 'assistant', content: response.content })
-       *
-       *   if (response.stop_reason !== 'tool_use') break
-       *
-       *   const toolResults = await Promise.all(
-       *     response.content
-       *       .filter((b): b is Anthropic.ToolUseBlock => b.type === 'tool_use')
-       *       .map(async (b) => ({
-       *         type: 'tool_result' as const,
-       *         tool_use_id: b.id,
-       *         content: await executeTool(b.name, b.input as Record<string, unknown>),
-       *       })),
-       *   )
-       *
-       *   messages.push({ role: 'user', content: toolResults })
+       * import { agentScalar } from "@scalar/agent";
+       * import { query } from "@anthropic-ai/claude-agent-sdk";
+       *
+       * const scalar = agentScalar({
+       *   token: "your-token",
+       * });
+       * const installation = await scalar.installation("your-installation-id");
+       *
+       * for await (const message of query({
+       *   prompt: "Which APIs are available that let me create a planet?",
+       *   options: {
+       *     mcpServers: {
+       *       scalar: installation.createAnthropicMCP(),
+       *     },
+       *     allowedTools: ["mcp__scalar__*"],
+       *   },
+       * })) {
+       *   if ("result" in message) console.log(message.result);
        * }
        * ```
        */
-      createAnthropicTools: async () => {
-        const clients = await Promise.all(
-          apis.map(async (api) => {
-            const client = new Client({
-              name: "scalar-agent-sdk",
-              version: "0.1.0"
-            });
-            await client.connect(
-              new StreamableHTTPClientTransport(mcpUrl(api), {
-                fetch: mcpFetch
-              })
-            );
-            return { client, api };
-          })
-        );
-        const toolRoutes = /* @__PURE__ */ new Map();
-        const anthropicTools = [];
-        for (const { client, api } of clients) {
-          const { tools } = await client.listTools();
-          for (const tool of tools) {
-            const name = namespaceTool(api, tool.name);
-            anthropicTools.push({
-              name,
-              description: tool.description,
-              input_schema: tool.inputSchema
-            });
-            toolRoutes.set(name, { client, originalName: tool.name });
-          }
+      createAnthropicMCP: () => ({
+        type: "http",
+        url: url.toString(),
+        headers: {
+          Authorization: config.token,
+          [SDK_PROVIDER_HEADER_NAME]: Provider.ANTHROPIC
         }
-        const executeTool = async (toolName, input) => {
-          const route = toolRoutes.get(toolName);
-          if (!route) {
-            throw new Error(`Tool "${toolName}" not found`);
-          }
-          const result = await route.client.callTool({
-            name: route.originalName,
-            arguments: input
-          });
-          const content = result.content;
-          return content.filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n");
-        };
-        return { tools: anthropicTools, executeTool };
-      }
+      })
     };
   };
-  return { session };
+  return { installation };
 };
 export {
-  EXECUTE_REQUEST_TOOL_NAME,
-  agentScalar,
-  executeRequestToolInputSchema,
-  mcpToolSchemas
+  agentScalar
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scalar/agent",
   "description": "Scalar Agent SDK",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": "Scalar (https://github.com/scalar)",
   "license": "MIT",
   "private": false,
@@ -17,14 +17,14 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./constants": {
+      "import": "./dist/constants.js",
+      "types": "./dist/constants.d.ts",
+      "default": "./dist/constants.js"
     }
   },
   "dependencies": {
-    "@ai-sdk/mcp": "^1.0.14",
-    "@anthropic-ai/sdk": "^0.78.0",
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "@scalar/workspace-store": "^0.34.2",
-    "@scalar/agent-chat": "^0.5.16",
-    "zod": "^4.3.6"
+    "@modelcontextprotocol/sdk": "^1.27.1"
   }
 }

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAA;AAG9C,OAAO,CAAC,MAAM,KAAK,CAAA;AAUnB,MAAM,WAAW,cAAc;IAC7B,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,KAAK,GAAG,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,CAAC,GAAG,EAAE,WAAW,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC5E,CAAA;AAED,eAAO,MAAM,yBAAyB,oBAAoB,CAAA;AAE1D,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;CAM1B,CAAA;AA2DD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,cAAmB;wBAuBpB;QAAE,IAAI,EAAE,GAAG,EAAE,CAAA;KAAE;QAS5C;;;;;;;;;;;;;;;;;;;;;WAqBG;;QA6BH;;;;;;;;;;;;;;;;;;;;;;;;WAwBG;+BACwB,OAAO,CAAC,gBAAgB,EAAE,CAAC;QAStD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8CG;oCAC6B,OAAO,CAAC;YACtC,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,CAAA;YACvB,WAAW,EAAE,CACX,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC3B,OAAO,CAAC,MAAM,CAAC,CAAA;SACrB,CAAC;;CAyEP,CAAA"}

package/dist/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/index.ts"],
-  "sourcesContent": ["import { createMCPClient, type MCPClient } from '@ai-sdk/mcp'\nimport { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'\nimport { createNeverpanic } from 'neverpanic'\nimport z from 'zod'\n\nimport {\n  GET_MINI_OPENAPI_SPEC_TOOL_NAME,\n  GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME,\n  getMiniOpenAPIDocToolInputSchema,\n  TOOL_NAMESPACE_SLUG_DELIMITER,\n} from '@scalar/agent-chat/entities'\n\nexport type AgentError<D> = {\n  code: string\n  detail: D\n}\n\nexport const n = createNeverpanic<unknown, AgentError<unknown>>()\n\nexport interface AgentSDKConfig {\n  baseUrl?: string\n  agentKey?: string\n}\n\ntype Api = {\n  namespace: string\n  slug: string\n}\n\nexport const EXECUTE_REQUEST_TOOL_NAME = 'execute-request'\n\nexport const executeRequestToolInputSchema = z.object({\n  method: z.string(),\n  path: z.string(),\n  headers: z.record(z.string(), z.string()).optional(),\n  body: z.string().optional(),\n})\n\nexport const mcpToolSchemas = {\n  [EXECUTE_REQUEST_TOOL_NAME]: { inputSchema: executeRequestToolInputSchema },\n  [GET_MINI_OPENAPI_SPEC_TOOL_NAME]: {\n    inputSchema: getMiniOpenAPIDocToolInputSchema,\n  },\n  [GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME]: {\n    inputSchema: z.object(),\n  },\n}\n\nexport const safeParseJson = n.safeFn(\n  (value: any) => ({ success: true, data: JSON.parse(value) }),\n  (originalError) =>\n    n.err({ code: 'FAILED_TO_PARSE_JSON', detail: originalError }),\n)\n\nconst createClients = n.safeFn(\n  async ({\n    baseUrl,\n    agentKey,\n    apis,\n  }: {\n    baseUrl: string\n    agentKey?: string\n    apis: Api[]\n  }) => {\n    const clients = await Promise.all(\n      apis.map(async (api) => {\n        const mcpUrl = new URL(\n          `/vector/mcp/${api.namespace}/${api.slug}?activeServerUrl=${encodeURIComponent('https://galaxy.scalar.com')}`,\n          baseUrl,\n        )\n\n        const mcpClient = await createMCPClient({\n          transport: new StreamableHTTPClientTransport(mcpUrl, {\n            fetch(url, options) {\n              const parsedJsonBodyResult = safeParseJson(options?.body)\n              if (!parsedJsonBodyResult.success) return fetch(url, options)\n\n              if (parsedJsonBodyResult.data.params)\n                parsedJsonBodyResult.data.params._meta = {\n                  securitySchemes: [],\n                }\n\n              return fetch(url, {\n                ...options,\n                headers: {\n                  'Content-Type': 'application/json',\n                  'Accept': 'application/json, text/event-stream',\n                  ...options?.headers,\n                  ...(agentKey && {\n                    'x-scalar-agent-key': agentKey,\n                  }),\n                },\n                body: JSON.stringify(parsedJsonBodyResult.data),\n              })\n            },\n          }),\n        })\n\n        return {\n          mcpClient,\n          api,\n        }\n      }),\n    )\n\n    return {\n      success: true,\n      data: clients,\n    }\n  },\n  (originalError) =>\n    n.err({ code: 'FAILED_TO_CREATE_MCP_CLIENTS', detail: originalError }),\n)\n\n/**\n * Create AI SDK tools from an MCP clients returned tools.\n * Applies prefix for tool name uniqueness.\n */\nexport const createTools = n.safeFn(\n  async (mcpClients: { mcpClient: MCPClient; api: Api }[]) => {\n    const toolSets = await Promise.all(\n      mcpClients.map(async ({ mcpClient, api }) => {\n        const tools = await mcpClient.tools({\n          schemas: mcpToolSchemas,\n        })\n\n        return Object.fromEntries(\n          Object.entries(tools).map(([toolName, tool]) => [\n            `${api.namespace}${TOOL_NAMESPACE_SLUG_DELIMITER}${api.slug}__${toolName}`,\n            tool,\n          ]),\n        ) as any\n      }),\n    )\n\n    function merge<T>(sources: T[]): T {\n      return Object.assign({}, ...sources)\n    }\n\n    return {\n      success: true,\n      data: merge(toolSets),\n    }\n  },\n  (originalError) =>\n    n.err({ code: 'FAILED_TO_CREATE_MCP_TOOLS', detail: originalError }),\n)\n\nexport const agentScalar = (config: AgentSDKConfig = {}) => {\n  const baseUrl = config.baseUrl ?? 'https://services.staging.scalar.com'\n\n  const session = async ({ apis }: { apis: Api[] }) => {\n    const createClientsResult = await createClients({\n      agentKey: config.agentKey,\n      baseUrl,\n      apis,\n    })\n\n    if (!createClientsResult.success) {\n      throw createClientsResult.error\n    }\n\n    return {\n      tools: async () => {\n        const toolsResult = await createTools(createClientsResult.data)\n\n        if (!toolsResult.success) {\n          throw Error(toolsResult.error.code)\n        }\n\n        return toolsResult.data\n      },\n    }\n  }\n\n  return {\n    session,\n  }\n}\n"],
-  "mappings": "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",
-  "names": []
-}