@slates-integrations/anthropic 0.2.0-rc.5

package/README.md

@@ -0,0 +1,53 @@
+# <img src="https://provider-logos.metorial-cdn.com/anthropic.png" height="20"> Anthropic
+
+Generate text and analyze images using Claude language models. Send conversational messages with configurable parameters (model, temperature, system prompt) and receive AI-generated responses, with optional streaming. Execute Python code in a sandboxed environment for data analysis and visualizations. Perform web searches for up-to-date information with cited sources. Use tool calling (function calling) to let Claude invoke structured tools during conversations. Enable extended thinking for complex reasoning tasks. Process and analyze images via vision capabilities. Upload and manage files for multi-session analysis. Connect to remote MCP servers for external system integration. Use agent skills for working with PowerPoint, Excel, Word, and PDF files. Count tokens, cache prompts for reduced latency and cost, create message batches for async processing, and enable citations for source attribution. Administer organizations by managing members, workspaces, invites, API keys, and retrieving usage and cost reports.
+
+## Tools
+
+### Count Tokens
+
+Count the number of tokens in a message without sending it. Useful for estimating costs, managing context window limits, and planning prompt strategies before making actual API calls.
+
+### Get Organization
+
+Retrieve information about the organization associated with the current Admin API key. Useful for determining which organization a key belongs to and getting organization details. Requires an Admin API key (sk-ant-admin...).
+
+### List Models
+
+List available Claude models and their details. Retrieve information about context window size, capabilities, and model identifiers. Optionally fetch details for a specific model by providing its ID.
+
+### Get Usage Report
+
+Retrieve Anthropic Admin API usage and cost reports for an organization. Use message usage reports for token and server-tool usage, and cost reports for USD spend attribution. Requires an Admin API key (sk-ant-admin...).
+
+### Manage API Keys
+
+List, retrieve, and update organization API keys via the Admin API. View active, inactive, or archived keys filtered by workspace. Update keys to activate, deactivate, or rename them. Requires an Admin API key (sk-ant-admin...).
+
+### Manage Files
+
+Upload, list, retrieve metadata for, download, or delete Anthropic Files API files. Uploaded files can be referenced from Messages requests by file ID; generated downloadable files can be retrieved as base64 content.
+
+### Manage Message Batch
+
+Create, retrieve, list, or cancel message batches for asynchronous processing. Batches allow processing large volumes of messages at reduced cost (up to 24 hours). Use **action** to specify the operation: "create", "get", "list", or "cancel".
+
+### Manage Organization Members
+
+Manage organization members and invites via the Admin API. List members, update roles, remove members, or manage invitations. Use **action** to specify the operation. Requires an Admin API key (sk-ant-admin...).
+
+### Manage Workspaces
+
+Manage organization workspaces and their members via the Admin API. Create, list, update, archive workspaces, and manage workspace membership. Use **action** to specify the operation. Requires an Admin API key (sk-ant-admin...).
+
+### Send Message
+
+Send a message to Claude and receive a generated response. Supports multi-turn conversations, system prompts, tool use (function calling), extended thinking, and vision (images). Provide a conversation history as messages and configure model parameters to control the response.
+
+## License
+
+This integration is licensed under the [FSL-1.1](https://github.com/metorial/metorial-platform/blob/dev/LICENSE).
+
+<div align="center">
+  <sub>Built with ❤️ by <a href="https://metorial.com">Metorial</a></sub>
+</div>

package/docs/SPEC.md

@@ -0,0 +1,113 @@
+# Slates Specification for Anthropic
+
+## Overview
+
+Anthropic is an AI research company that provides access to the Claude family of large language models via a REST API. The Claude API is a RESTful API at `https://api.anthropic.com` that provides programmatic access to Claude models. The API supports text and image inputs, tool use, code execution, web search, file management, and organization administration.
+
+## Authentication
+
+Anthropic uses **API key authentication**. There are two types of API keys:
+
+### Standard API Key
+
+- In the Anthropic Console, open Settings > API Keys to create a key.
+- Copy your key and store it in a safe location. You won't be able to re-access the key in the future.
+- The API key is passed via the `x-api-key` header on every request.
+- An `anthropic-version` header (e.g., `2023-06-01`) is also required on all requests.
+
+Example:
+
+```
+curl https://api.anthropic.com/v1/messages \
+  --header "x-api-key: $ANTHROPIC_API_KEY" \
+  --header "anthropic-version: 2023-06-01" \
+  --header "content-type: application/json" \
+  --data '{ ... }'
+```
+
+### Admin API Key
+
+- The Admin API requires a special Admin API key (starting with `sk-ant-admin...`) that differs from standard API keys. Only organization members with the admin role can provision Admin API keys through the Claude Console.
+- Used exclusively for organization administration tasks (managing members, workspaces, API keys).
+- Passed via the same `x-api-key` header.
+
+There is no OAuth2 or token-based authentication. All authentication is key-based.
+
+## Features
+
+### Message Generation (Conversations)
+
+The primary API is the Messages API for conversational interactions. Send a sequence of user and assistant messages to Claude and receive a model-generated response. Configurable parameters include model selection, maximum output tokens, system prompt, temperature, top-k, top-p, and stop sequences. All current Claude models support text and image input, text output, multilingual capabilities, and vision. Responses can be streamed via server-sent events (SSE) for real-time token delivery.
+
+### Extended Thinking
+
+Extended thinking is a feature that allows Claude to generate internal reasoning content blocks before producing its final response. It improves output quality for complex tasks by making the model's step-by-step thinking process explicit. You set a thinking token budget (minimum 1,024 tokens) when enabling this feature via the API.
+
+### Tool Use (Function Calling)
+
+Define tools with a name, description, and JSON Schema for inputs. Claude can decide to invoke tools during a conversation, returning structured tool-use requests. You execute the tool and return results to Claude to continue the conversation. Supports forcing specific tools, disabling tool use, and advanced patterns like programmatic tool calling where Claude orchestrates multiple tools through code.
+
+### Web Search
+
+Claude can generate targeted search queries when up-to-date information is needed. Claude analyzes the results, extracts relevant information, and provides a comprehensive response with citations to source materials. Enabled by including the web search tool in your API request.
+
+### Code Execution
+
+Anthropic offers a code execution tool on the API, giving Claude the ability to run Python code in a sandboxed environment to produce computational results and data visualizations. This transforms Claude from a code-writing assistant into a data analyst that can iterate on visualizations, clean datasets, and derive insights directly within API calls.
+
+### Computer Use
+
+Rather than building specialized tools for individual tasks, Anthropic is teaching Claude general computer skills—enabling it to use the same interfaces, applications, and workflows that humans use every day. Released in public beta, Computer Use made Claude the first frontier AI model to offer autonomous desktop control. Claude can view screenshots, move the mouse, click, type, and scroll to interact with desktop environments.
+
+### MCP Connector
+
+The Claude API supports an `mcp_servers` parameter that lets Claude connect directly to remote MCP servers. Use `mcp_servers` when you have remote servers accessible via URL and only need tool support. This allows Claude to interact with external systems through the Model Context Protocol.
+
+### Vision (Image Understanding)
+
+Claude can process and analyze images sent as part of messages. Images can be provided as base64-encoded data or URLs. All current Claude models support vision capabilities.
+
+### File Management
+
+Developers can upload a dataset through the Files API once, then have Claude analyze it across multiple sessions without re-uploading. Files can be uploaded, listed, and retrieved for use with messages and code execution.
+
+### Agent Skills
+
+Anthropic launched Agent Skills, a new way to extend Claude's capabilities. Skills are organized folders of instructions, scripts, and resources that Claude loads dynamically to perform specialized tasks. The initial release includes Anthropic-managed Skills for working with PowerPoint, Excel, Word, and PDF files, as well as Custom Skills you can upload via the Skills API.
+
+### Prompt Caching
+
+Prompt caching is available as a feature in the Claude API. Cache and re-use prompts to reduce latency by up to 80% and costs by up to 90%. Developers can now choose between a standard 5-minute TTL for prompt caching or opt for an extended 1-hour TTL at an additional cost.
+
+### Citations
+
+Anthropic launched citations capability in the API, allowing Claude to provide source attribution for information. When enabled, Claude returns references to specific parts of the provided source documents.
+
+### Token Counting
+
+Count tokens in a message before sending it, useful for managing costs and staying within context window limits.
+
+### Message Batches
+
+Process large volumes of message requests asynchronously at a reduced cost. Submit multiple independent requests as a batch and retrieve results when processing is complete.
+
+### Model Discovery
+
+List available Claude models and retrieve their details (context window size, capabilities, etc.) via the Models API.
+
+### Organization Administration
+
+The Admin API allows you to programmatically manage your organization's resources, including organization members, workspaces, and API keys. Specific capabilities include:
+
+- **Member management**: List, update roles, and remove organization members.
+- **Invites**: Create, list, and delete invitations to join the organization.
+- **Workspaces**: Create, list, update, and archive workspaces. Workspaces support data residency configuration.
+- **Workspace members**: Add, update roles, and remove members from specific workspaces.
+- **API key management**: List and update (activate/deactivate/rename) API keys.
+- **Usage and Cost reporting**: Retrieve usage and cost data for the organization.
+
+There are five organization-level roles. Workspace-level roles include workspace_user, workspace_developer, workspace_admin, and workspace_billing.
+
+## Events
+
+The provider does not support events. Anthropic does not offer webhooks or purpose-built polling mechanisms for subscribing to changes or notifications. Streaming (SSE) is available for real-time token delivery during message generation, but this is a response-streaming mechanism, not an event subscription system.

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@slates-integrations/anthropic",
+  "main": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "bunx @vercel/ncc build src/index.ts -o dist -m -s",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@lowerdeck/error": "^1.1.0",
+    "@types/node": "^20",
+    "slates": "1.0.0-rc.10",
+    "zod": "^4.2"
+  },
+  "devDependencies": {
+    "typescript": "^5"
+  },
+  "version": "0.2.0-rc.5"
+}

package/slate.json

@@ -0,0 +1,22 @@
+{
+  "name": "@metorial/anthropic",
+  "description": "Generate text and analyze images using Claude language models. Send conversational messages with configurable parameters (model, temperature, system prompt) and receive AI-generated responses, with optional streaming. Execute Python code in a sandboxed environment for data analysis and visualizations. Perform web searches for up-to-date information with cited sources. Use tool calling (function calling) to let Claude invoke structured tools during conversations. Enable extended thinking for complex reasoning tasks. Process and analyze images via vision capabilities. Upload and manage files for multi-session analysis. Connect to remote MCP servers for external system integration. Use agent skills for working with PowerPoint, Excel, Word, and PDF files. Count tokens, cache prompts for reduced latency and cost, create message batches for async processing, and enable citations for source attribution. Administer organizations by managing members, workspaces, invites, API keys, and retrieving usage and cost reports.",
+  "categories": [
+    "apis-and-http-requests",
+    "code-execution",
+    "web-search"
+  ],
+  "skills": [
+    "generate conversational responses",
+    "execute Python code",
+    "search the web",
+    "analyze images",
+    "manage file uploads",
+    "use tool calling",
+    "batch process messages",
+    "count tokens",
+    "administer organization members",
+    "manage workspaces and API keys"
+  ],
+  "logoUrl": "https://provider-logos.metorial-cdn.com/anthropic.png"
+}

package/src/auth.ts

@@ -0,0 +1,24 @@
+import { SlateAuth } from 'slates';
+import { z } from 'zod';
+
+export let auth = SlateAuth.create()
+  .output(
+    z.object({
+      token: z.string()
+    })
+  )
+  .addTokenAuth({
+    type: 'auth.token',
+    name: 'API Key',
+    key: 'api_key',
+    inputSchema: z.object({
+      apiKey: z.string().describe('Anthropic API key (starts with sk-ant-api or sk-ant-admin)')
+    }),
+    getOutput: async ctx => {
+      return {
+        output: {
+          token: ctx.input.apiKey
+        }
+      };
+    }
+  });

package/src/config.ts

@@ -0,0 +1,8 @@
+import { SlateConfig } from 'slates';
+import { z } from 'zod';
+
+export let config = SlateConfig.create(
+  z.object({
+    apiVersion: z.string().default('2023-06-01').describe('Anthropic API version header value')
+  })
+);

package/src/index.ts

@@ -0,0 +1,33 @@
+import { Slate } from 'slates';
+import { spec } from './spec';
+import {
+  sendMessage,
+  countTokens,
+  listModels,
+  manageMessageBatch,
+  manageOrganizationMembers,
+  manageWorkspaces,
+  manageApiKeys,
+  getOrganization,
+  manageFiles,
+  getUsageReport
+} from './tools';
+
+import { inboundWebhook } from './triggers/inbound-webhook';
+
+export let provider = Slate.create({
+  spec,
+  tools: [
+    sendMessage,
+    countTokens,
+    listModels,
+    manageMessageBatch,
+    manageOrganizationMembers,
+    manageWorkspaces,
+    manageApiKeys,
+    getOrganization,
+    manageFiles,
+    getUsageReport
+  ],
+  triggers: [inboundWebhook]
+});