@slates-integrations/anthropic 0.2.0-rc.5

package/src/spec.ts

@@ -0,0 +1,13 @@
+import { SlateSpecification } from 'slates';
+import { auth } from './auth';
+import { config } from './config';
+
+export let spec = SlateSpecification.create({
+  key: 'anthropic',
+  name: 'Anthropic',
+  description:
+    'AI research company providing access to the Claude family of large language models via a REST API.',
+  metadata: {},
+  config,
+  auth
+});

package/src/tools/count-tokens.ts

@@ -0,0 +1,74 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let messageSchema = z.object({
+  role: z.enum(['user', 'assistant']).describe('Role of the message sender'),
+  content: z
+    .union([z.string(), z.array(z.record(z.string(), z.unknown()))])
+    .describe('Message content')
+});
+
+export let countTokens = SlateTool.create(spec, {
+  name: 'Count Tokens',
+  key: 'count_tokens',
+  description: `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.`,
+  tags: {
+    destructive: false,
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      model: z.string().describe('Claude model ID to use for token counting'),
+      messages: z.array(messageSchema).describe('Messages to count tokens for'),
+      system: z.string().optional().describe('System prompt to include in the count'),
+      tools: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('Tool definitions to include in the count'),
+      thinking: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Extended thinking configuration to include in the count'),
+      betaHeaders: z
+        .array(z.string())
+        .optional()
+        .describe('Anthropic beta headers to send with this request')
+    })
+  )
+  .output(
+    z.object({
+      inputTokens: z
+        .number()
+        .describe('Total number of tokens across messages, system prompt, and tools')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    let messages = ctx.input.messages as Array<{
+      role: 'user' | 'assistant';
+      content: string | Array<Record<string, unknown>>;
+    }>;
+    let result = await client.countTokens({
+      model: ctx.input.model,
+      messages,
+      system: ctx.input.system,
+      tools: ctx.input.tools,
+      thinking: ctx.input.thinking,
+      betaHeaders: ctx.input.betaHeaders
+    });
+
+    return {
+      output: {
+        inputTokens: result.inputTokens
+      },
+      message: `Token count for model **${ctx.input.model}**: **${result.inputTokens}** input tokens.`
+    };
+  })
+  .build();

package/src/tools/get-organization.ts

@@ -0,0 +1,36 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let getOrganization = SlateTool.create(spec, {
+  name: 'Get Organization',
+  key: 'get_organization',
+  description: `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...).`,
+  constraints: ['Requires an Admin API key (sk-ant-admin...).'],
+  tags: {
+    destructive: false,
+    readOnly: true
+  }
+})
+  .input(z.object({}))
+  .output(
+    z.object({
+      organization: z.record(z.string(), z.unknown()).describe('Organization details')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    let organization = await client.getOrganization();
+
+    return {
+      output: { organization },
+      message: `Retrieved organization info: **${(organization as Record<string, unknown>).name || organization.id || 'unknown'}**.`
+    };
+  })
+  .build();

package/src/tools/get-usage-report.ts

@@ -0,0 +1,141 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { anthropicServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let usageGroupBySchema = z.enum([
+  'api_key_id',
+  'workspace_id',
+  'model',
+  'service_tier',
+  'context_window',
+  'description'
+]);
+
+let costGroupBy = new Set(['workspace_id', 'description']);
+let messagesUsageGroupBy = new Set([
+  'api_key_id',
+  'workspace_id',
+  'model',
+  'service_tier',
+  'context_window'
+]);
+
+let ensureValidGroupBy = (reportType: 'messages_usage' | 'cost', groupBy?: string[]) => {
+  let allowed = reportType === 'cost' ? costGroupBy : messagesUsageGroupBy;
+  let invalid = (groupBy ?? []).filter(group => !allowed.has(group));
+  if (invalid.length > 0) {
+    throw anthropicServiceError(
+      `${invalid.join(', ')} cannot be used as groupBy for "${reportType}"`
+    );
+  }
+};
+
+export let getUsageReport = SlateTool.create(spec, {
+  name: 'Get Usage Report',
+  key: 'get_usage_report',
+  description: `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.`,
+  instructions: [
+    'Requires an Admin API key (sk-ant-admin...).',
+    'startingAt and endingAt must be RFC 3339 timestamps; buckets are snapped to UTC boundaries by Anthropic.',
+    'For messages_usage, groupBy supports api_key_id, workspace_id, model, service_tier, and context_window.',
+    'For cost, groupBy supports workspace_id and description.'
+  ],
+  constraints: ['Requires an Admin API key (sk-ant-admin...).'],
+  tags: {
+    destructive: false,
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      reportType: z.enum(['messages_usage', 'cost']).describe('Report endpoint to query'),
+      startingAt: z
+        .string()
+        .describe('RFC 3339 timestamp; buckets starting on or after this time are returned'),
+      endingAt: z
+        .string()
+        .optional()
+        .describe('RFC 3339 timestamp; buckets ending before this time are returned'),
+      bucketWidth: z
+        .enum(['1m', '1h', '1d'])
+        .optional()
+        .describe('Bucket width for messages_usage reports'),
+      groupBy: z
+        .array(usageGroupBySchema)
+        .optional()
+        .describe('Dimensions to group report rows by'),
+      apiKeyIds: z
+        .array(z.string())
+        .optional()
+        .describe('Filter messages_usage by API key IDs'),
+      workspaceIds: z
+        .array(z.string())
+        .optional()
+        .describe('Filter messages_usage by workspace IDs'),
+      models: z.array(z.string()).optional().describe('Filter messages_usage by model IDs'),
+      serviceTiers: z
+        .array(z.enum(['standard', 'batch', 'priority']))
+        .optional()
+        .describe('Filter messages_usage by service tiers'),
+      contextWindows: z
+        .array(z.enum(['0-200k', '200k-1M']))
+        .optional()
+        .describe('Filter messages_usage by context window'),
+      limit: z.number().optional().describe('Maximum number of time buckets to return'),
+      page: z.string().optional().describe('Pagination token returned as nextPage')
+    })
+  )
+  .output(
+    z.object({
+      data: z.array(z.record(z.string(), z.unknown())).describe('Report buckets'),
+      hasMore: z.boolean().describe('Whether more report data is available'),
+      nextPage: z.string().optional().describe('Pagination token for a follow-up request')
+    })
+  )
+  .handleInvocation(async ctx => {
+    ensureValidGroupBy(ctx.input.reportType, ctx.input.groupBy);
+
+    if (ctx.input.reportType === 'cost' && ctx.input.bucketWidth !== undefined) {
+      throw anthropicServiceError('bucketWidth is only supported for messages_usage reports');
+    }
+
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    let result =
+      ctx.input.reportType === 'messages_usage'
+        ? await client.getMessagesUsageReport({
+            startingAt: ctx.input.startingAt,
+            endingAt: ctx.input.endingAt,
+            bucketWidth: ctx.input.bucketWidth,
+            groupBy: ctx.input.groupBy,
+            apiKeyIds: ctx.input.apiKeyIds,
+            workspaceIds: ctx.input.workspaceIds,
+            models: ctx.input.models,
+            serviceTiers: ctx.input.serviceTiers,
+            contextWindows: ctx.input.contextWindows,
+            limit: ctx.input.limit,
+            page: ctx.input.page
+          })
+        : await client.getCostReport({
+            startingAt: ctx.input.startingAt,
+            endingAt: ctx.input.endingAt,
+            groupBy: ctx.input.groupBy,
+            limit: ctx.input.limit,
+            page: ctx.input.page
+          });
+
+    return {
+      output: {
+        data: result.data,
+        hasMore: result.hasMore,
+        nextPage: result.nextPage ?? undefined
+      },
+      message: `Retrieved **${result.data.length}** ${ctx.input.reportType} report bucket(s).${result.hasMore ? ' More data is available with nextPage.' : ''}`
+    };
+  })
+  .build();

package/src/tools/index.ts

@@ -0,0 +1,10 @@
+export { sendMessage } from './send-message';
+export { countTokens } from './count-tokens';
+export { listModels } from './list-models';
+export { manageMessageBatch } from './manage-message-batch';
+export { manageOrganizationMembers } from './manage-organization-members';
+export { manageWorkspaces } from './manage-workspaces';
+export { manageApiKeys } from './manage-api-keys';
+export { getOrganization } from './get-organization';
+export { manageFiles } from './manage-files';
+export { getUsageReport } from './get-usage-report';

package/src/tools/list-models.ts

@@ -0,0 +1,84 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let listModels = SlateTool.create(spec, {
+  name: 'List Models',
+  key: 'list_models',
+  description: `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.`,
+  tags: {
+    destructive: false,
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      modelId: z
+        .string()
+        .optional()
+        .describe(
+          'Specific model ID to retrieve details for. If omitted, lists all available models.'
+        ),
+      limit: z.number().optional().describe('Maximum number of models to return when listing'),
+      afterId: z
+        .string()
+        .optional()
+        .describe('Pagination cursor: return models after this ID'),
+      beforeId: z
+        .string()
+        .optional()
+        .describe('Pagination cursor: return models before this ID')
+    })
+  )
+  .output(
+    z.object({
+      models: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('List of available models (when listing)'),
+      model: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Single model details (when fetching by ID)'),
+      hasMore: z
+        .boolean()
+        .optional()
+        .describe('Whether more models are available for pagination')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    if (ctx.input.modelId) {
+      let model = await client.getModel(ctx.input.modelId);
+      return {
+        output: {
+          model,
+          models: undefined,
+          hasMore: undefined
+        },
+        message: `Retrieved details for model **${ctx.input.modelId}**.`
+      };
+    }
+
+    let result = await client.listModels({
+      limit: ctx.input.limit,
+      afterId: ctx.input.afterId,
+      beforeId: ctx.input.beforeId
+    });
+
+    return {
+      output: {
+        models: result.models,
+        model: undefined,
+        hasMore: result.hasMore
+      },
+      message: `Found **${result.models.length}** available model(s).${result.hasMore ? ' More models available with pagination.' : ''}`
+    };
+  })
+  .build();

package/src/tools/manage-api-keys.ts

@@ -0,0 +1,94 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { anthropicServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let manageApiKeys = SlateTool.create(spec, {
+  name: 'Manage API Keys',
+  key: 'manage_api_keys',
+  description: `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...).`,
+  constraints: [
+    'Requires an Admin API key (sk-ant-admin...).',
+    'Cannot create or delete API keys via this endpoint—only list and update.'
+  ],
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      action: z.enum(['list', 'get', 'update']).describe('Operation to perform'),
+      apiKeyId: z.string().optional().describe('API key ID (required for "get" and "update")'),
+      status: z
+        .enum(['active', 'inactive', 'archived'])
+        .optional()
+        .describe('Filter keys by status (for "list")'),
+      workspaceId: z.string().optional().describe('Filter keys by workspace ID (for "list")'),
+      name: z.string().optional().describe('New name for the API key (for "update")'),
+      keyStatus: z
+        .enum(['active', 'inactive'])
+        .optional()
+        .describe('New status for the API key (for "update")'),
+      limit: z.number().optional().describe('Max results for "list"'),
+      afterId: z.string().optional().describe('Pagination cursor for "list"')
+    })
+  )
+  .output(
+    z.object({
+      apiKeys: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('List of API keys'),
+      apiKey: z.record(z.string(), z.unknown()).optional().describe('Updated API key details'),
+      hasMore: z.boolean().optional().describe('Whether more results are available')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    switch (ctx.input.action) {
+      case 'list': {
+        let result = await client.listApiKeys({
+          limit: ctx.input.limit,
+          afterId: ctx.input.afterId,
+          status: ctx.input.status,
+          workspaceId: ctx.input.workspaceId
+        });
+        return {
+          output: { apiKeys: result.apiKeys, hasMore: result.hasMore },
+          message: `Found **${result.apiKeys.length}** API key(s).${result.hasMore ? ' More available with pagination.' : ''}`
+        };
+      }
+      case 'get': {
+        if (!ctx.input.apiKeyId) {
+          throw anthropicServiceError('apiKeyId is required for "get"');
+        }
+        let apiKey = await client.getApiKey(ctx.input.apiKeyId);
+        return {
+          output: { apiKey },
+          message: `Retrieved API key **${ctx.input.apiKeyId}**.`
+        };
+      }
+      case 'update': {
+        if (!ctx.input.apiKeyId) {
+          throw anthropicServiceError('apiKeyId is required for "update"');
+        }
+        let params: Record<string, unknown> = {};
+        if (ctx.input.name !== undefined) params.name = ctx.input.name;
+        if (ctx.input.keyStatus !== undefined) params.status = ctx.input.keyStatus;
+
+        let apiKey = await client.updateApiKey(ctx.input.apiKeyId, params);
+        return {
+          output: { apiKey },
+          message: `Updated API key **${ctx.input.apiKeyId}**.`
+        };
+      }
+    }
+  })
+  .build();

package/src/tools/manage-files.ts

@@ -0,0 +1,149 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { anthropicServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let fileOutputSchema = z.object({
+  fileId: z.string().describe('Anthropic file ID'),
+  type: z.string().optional().describe('Object type'),
+  filename: z.string().optional().describe('Original filename'),
+  mimeType: z.string().optional().describe('MIME type'),
+  sizeBytes: z.number().optional().describe('File size in bytes'),
+  createdAt: z.string().optional().describe('RFC 3339 creation timestamp'),
+  downloadable: z
+    .boolean()
+    .optional()
+    .describe('Whether this file can be downloaded through the Files API')
+});
+
+let fileContentOutputSchema = z.object({
+  fileId: z.string().describe('Anthropic file ID'),
+  contentBase64: z.string().describe('Downloaded file content encoded as base64'),
+  contentType: z.string().optional().describe('Downloaded response content type'),
+  sizeBytes: z.number().describe('Downloaded content size in bytes')
+});
+
+export let manageFiles = SlateTool.create(spec, {
+  name: 'Manage Files',
+  key: 'manage_files',
+  description: `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.`,
+  instructions: [
+    'For "create": provide filename and contentBase64; mimeType defaults to application/octet-stream.',
+    'For "list": optionally provide limit, afterId, or beforeId.',
+    'For "get", "download", and "delete": provide fileId.',
+    'Uploaded files are not always downloadable; Anthropic only allows downloading files that are marked downloadable, such as files generated by code execution.'
+  ],
+  tags: {
+    destructive: true,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['create', 'list', 'get', 'download', 'delete'])
+        .describe('Operation to perform'),
+      fileId: z
+        .string()
+        .optional()
+        .describe('File ID (required for get, download, and delete)'),
+      filename: z.string().optional().describe('Filename for create'),
+      contentBase64: z.string().optional().describe('Base64 encoded file content for create'),
+      mimeType: z
+        .string()
+        .optional()
+        .describe('MIME type for create, e.g. text/plain or application/pdf'),
+      limit: z.number().optional().describe('Max files to return for list'),
+      afterId: z.string().optional().describe('Pagination cursor after this file ID'),
+      beforeId: z.string().optional().describe('Pagination cursor before this file ID')
+    })
+  )
+  .output(
+    z.object({
+      file: fileOutputSchema.optional().describe('File metadata'),
+      files: z.array(fileOutputSchema).optional().describe('List of files'),
+      fileContent: fileContentOutputSchema.optional().describe('Downloaded file content'),
+      deletedFile: z
+        .object({
+          fileId: z.string(),
+          type: z.string().optional()
+        })
+        .optional()
+        .describe('Deleted file result'),
+      hasMore: z.boolean().optional().describe('Whether more list results are available'),
+      firstId: z.string().optional().describe('First file ID in the page'),
+      lastId: z.string().optional().describe('Last file ID in the page'),
+      success: z.boolean().optional().describe('Whether a delete operation succeeded')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    switch (ctx.input.action) {
+      case 'create': {
+        if (!ctx.input.filename || !ctx.input.contentBase64) {
+          throw anthropicServiceError('filename and contentBase64 are required for "create"');
+        }
+        let file = await client.createFile({
+          filename: ctx.input.filename,
+          contentBase64: ctx.input.contentBase64,
+          mimeType: ctx.input.mimeType
+        });
+        return {
+          output: { file },
+          message: `Uploaded file **${file.filename ?? ctx.input.filename}** as **${file.fileId}**.`
+        };
+      }
+      case 'list': {
+        let result = await client.listFiles({
+          limit: ctx.input.limit,
+          afterId: ctx.input.afterId,
+          beforeId: ctx.input.beforeId
+        });
+        return {
+          output: {
+            files: result.files,
+            hasMore: result.hasMore,
+            firstId: result.firstId,
+            lastId: result.lastId
+          },
+          message: `Found **${result.files.length}** file(s).${result.hasMore ? ' More files are available with pagination.' : ''}`
+        };
+      }
+      case 'get': {
+        if (!ctx.input.fileId) {
+          throw anthropicServiceError('fileId is required for "get"');
+        }
+        let file = await client.getFile(ctx.input.fileId);
+        return {
+          output: { file },
+          message: `Retrieved metadata for file **${file.fileId}**.`
+        };
+      }
+      case 'download': {
+        if (!ctx.input.fileId) {
+          throw anthropicServiceError('fileId is required for "download"');
+        }
+        let fileContent = await client.downloadFile(ctx.input.fileId);
+        return {
+          output: { fileContent },
+          message: `Downloaded file **${fileContent.fileId}** (${fileContent.sizeBytes} bytes).`
+        };
+      }
+      case 'delete': {
+        if (!ctx.input.fileId) {
+          throw anthropicServiceError('fileId is required for "delete"');
+        }
+        let deletedFile = await client.deleteFile(ctx.input.fileId);
+        return {
+          output: { deletedFile, success: true },
+          message: `Deleted file **${deletedFile.fileId}**.`
+        };
+      }
+    }
+  })
+  .build();