feat: add Anthropic Claude integration

examples/anthropic-integration.ts

@@ -0,0 +1,63 @@
+/**
+ * This example shows how to use StackOne tools with Anthropic Claude.
+ */
+
+import assert from 'node:assert';
+import process from 'node:process';
+import Anthropic from '@anthropic-ai/sdk';
+import { StackOneToolSet } from '@stackone/ai';
+
+const apiKey = process.env.STACKONE_API_KEY;
+if (!apiKey) {
+	console.error('STACKONE_API_KEY environment variable is required');
+	process.exit(1);
+}
+
+// Replace with your actual account ID from StackOne dashboard
+const accountId = 'your-hris-account-id';
+
+const anthropicIntegration = async (): Promise<void> => {
+	// Initialise StackOne
+	const toolset = new StackOneToolSet({
+ accountId,
+ baseUrl: process.env.STACKONE_BASE_URL ?? 'https://api.stackone.com',
+	});
+
+	// Filter for any relevant tools
+	const tools = await toolset.fetchTools({
+ actions: ['*_list_*', '*_search_*'],
+	});
+	const anthropicTools = tools.toAnthropic();
+
+	// Initialise Anthropic client
+	const anthropic = new Anthropic();
+
+	// Create a message with tool calls
+	const response = await anthropic.messages.create({
+ model: 'claude-haiku-4-5-20241022',
+ max_tokens: 1024,
+ system: 'You are a helpful assistant that can access tools.',
+ messages: [
+ {
+ role: 'user',
+ content: 'What is the employee with id: c28xIQaWQ6MzM5MzczMDA2NzMzMzkwNzIwNA phone number?',
+ },
+ ],
+ tools: anthropicTools,
+	});
+
+	// Verify the response contains tool use
+	assert(response.content.length > 0, 'Expected at least one content block in the response');
+
+	const toolUseBlock = response.content.find((block) => block.type === 'tool_use');
+	assert(toolUseBlock !== undefined, 'Expected a tool_use block in the response');
+	assert(toolUseBlock.type === 'tool_use', 'Expected block to be tool_use type');
+	assert(toolUseBlock.name === 'hris_get_employee', 'Expected tool call to be hris_get_employee');
+
+	// Verify the input contains the expected fields
+	const input = toolUseBlock.input as Record<string, unknown>;
+	assert(input.id === 'c28xIQaWQ6MzM5MzczMDA2NzMzMzkwNzIwNA', 'Expected id to match the query');
+};
+
+// Run the example
+await anthropicIntegration();

examples/package.json

@@ -12,6 +12,7 @@
 	},
 	"devDependencies": {
  "@ai-sdk/openai": "catalog:dev",
+ "@anthropic-ai/sdk": "catalog:peer",
  "@clack/prompts": "catalog:dev",
  "@types/node": "catalog:dev",
  "ai": "catalog:peer",

package.json

@@ -64,10 +64,14 @@
  "vitest": "catalog:dev"
 	},
 	"peerDependencies": {
+ "@anthropic-ai/sdk": "catalog:peer",
  "ai": "catalog:peer",
  "openai": "catalog:peer"
 	},
 	"peerDependenciesMeta": {
+ "@anthropic-ai/sdk": {
+ "optional": true
+ },
  "ai": {
  "optional": true
  },

pnpm-workspace.yaml

@@ -28,6 +28,7 @@ catalogs:
  vitest: ^4.0.15
  zod: ^4.1.13
  peer:
+ '@anthropic-ai/sdk': ^0.52.0
  ai: ^5.0.108
  openai: ^6.2.0
  prod:

src/tool.test.ts

@@ -72,6 +72,18 @@ describe('StackOneTool', () => {
  ).toBe('string');
 	});
 
+	it('should convert to Anthropic tool format', () => {
+ const tool = createMockTool();
+ const anthropicFormat = tool.toAnthropic();
+
+ expect(anthropicFormat.name).toBe('test_tool');
+ expect(anthropicFormat.description).toBe('Test tool');
+ expect(anthropicFormat.input_schema.type).toBe('object');
+ const properties = anthropicFormat.input_schema.properties as Record<string, { type: string }>;
+ expect(properties.id).toBeDefined();
+ expect(properties.id.type).toBe('string');
+	});
+
 	it('should convert to OpenAI Responses API tool format', () => {
  const tool = createMockTool();
  const responsesFormat = tool.toOpenAIResponses();
@@ -352,6 +364,63 @@ describe('Tools', () => {
  expect(openAITools[1].function.name).toBe('tool2');
 	});
 
+	it('should convert all tools to Anthropic format', () => {
+ const tool1 = new BaseTool(
+ 'tool1',
+ 'Tool 1',
+ {
+ type: 'object',
+ properties: { id: { type: 'string' } },
+ },
+ {
+ kind: 'http',
+ method: 'GET',
+ url: 'https://api.example.com/test/{id}',
+ bodyType: 'json',
+ params: [
+ {
+ name: 'id',
+ location: ParameterLocation.PATH,
+ type: 'string',
+ },
+ ],
+ },
+ );
+
+ const tool2 = new BaseTool(
+ 'tool2',
+ 'Tool 2',
+ {
+ type: 'object',
+ properties: { name: { type: 'string' } },
+ },
+ {
+ kind: 'http',
+ method: 'POST',
+ url: 'https://api.example.com/test',
+ bodyType: 'json',
+ params: [
+ {
+ name: 'name',
+ location: ParameterLocation.BODY,
+ type: 'string',
+ },
+ ],
+ },
+ );
+
+ const tools = new Tools([tool1, tool2]);
+ const anthropicTools = tools.toAnthropic();
+
+ expect(anthropicTools).toBeInstanceOf(Array);
+ expect(anthropicTools.length).toBe(2);
+ expect(anthropicTools[0].name).toBe('tool1');
+ expect(anthropicTools[0].description).toBe('Tool 1');
+ expect(anthropicTools[0].input_schema.type).toBe('object');
+ expect(anthropicTools[1].name).toBe('tool2');
+ expect(anthropicTools[1].description).toBe('Tool 2');
+	});
+
 	it('should convert all tools to OpenAI Responses API tools', () => {
  const tool1 = new StackOneTool(
  'tool1',

src/tool.ts

@@ -1,3 +1,4 @@
+import type { Tool as AnthropicTool } from '@anthropic-ai/sdk/resources';
 import * as orama from '@orama/orama';
 import type { ChatCompletionFunctionTool } from 'openai/resources/chat/completions';
 import type { FunctionTool as OpenAIResponsesFunctionTool } from 'openai/resources/responses/responses';
@@ -182,6 +183,22 @@ export class BaseTool {
  };
 	}
 
+	/**
+ * Convert the tool to Anthropic format
+ * @see https://docs.anthropic.com/en/docs/build-with-claude/tool-use
+ */
+	toAnthropic(): AnthropicTool {
+ return {
+ name: this.name,
+ description: this.description,
+ input_schema: {
+ type: 'object',
+ properties: this.parameters.properties,
+ required: this.parameters.required,
+ },
+ };
+	}
+
 	/**
  * Convert the tool to OpenAI Responses API format
  * @see https://platform.openai.com/docs/api-reference/responses
@@ -379,6 +396,14 @@ export class Tools implements Iterable<BaseTool> {
  return this.tools.map((tool) => tool.toOpenAI());
 	}
 
+	/**
+ * Convert all tools to Anthropic format
+ * @see https://docs.anthropic.com/en/docs/build-with-claude/tool-use
+ */
+	toAnthropic(): AnthropicTool[] {
+ return this.tools.map((tool) => tool.toAnthropic());
+	}
+
 	/**
  * Convert all tools to OpenAI Responses API format
  * @see https://platform.openai.com/docs/api-reference/responses