@slates-integrations/anthropic 0.2.0-rc.5

package/src/tools/manage-message-batch.ts

@@ -0,0 +1,132 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { anthropicServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let batchRequestSchema = z.object({
+  customId: z.string().describe('Unique identifier for matching results to this request'),
+  params: z
+    .record(z.string(), z.unknown())
+    .describe('Standard Messages API parameters (model, max_tokens, messages, etc.)')
+});
+
+let requestCountsSchema = z
+  .object({
+    processing: z.number(),
+    succeeded: z.number(),
+    errored: z.number(),
+    canceled: z.number(),
+    expired: z.number()
+  })
+  .optional();
+
+let batchOutputSchema = z.object({
+  batchId: z.string().describe('Batch ID'),
+  type: z.string().optional(),
+  processingStatus: z
+    .string()
+    .optional()
+    .describe('Current status: queued, in_progress, succeeded, failed, expired, canceled'),
+  requestCounts: requestCountsSchema.describe('Counts of requests by status'),
+  createdAt: z.string().optional().describe('ISO 8601 creation timestamp'),
+  updatedAt: z.string().optional().describe('ISO 8601 last update timestamp'),
+  expiresAt: z.string().optional().describe('ISO 8601 expiration timestamp'),
+  resultsUrl: z.string().optional().describe('URL to download batch results when complete')
+});
+
+export let manageMessageBatch = SlateTool.create(spec, {
+  name: 'Manage Message Batch',
+  key: 'manage_message_batch',
+  description: `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".`,
+  instructions: [
+    'For "create": provide requests array with customId and params for each message.',
+    'For "get": provide batchId to check status and retrieve the results URL.',
+    'For "cancel": provide batchId to cancel an in-progress batch.',
+    'For "list": optionally provide limit and afterId for pagination.'
+  ],
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      action: z.enum(['create', 'get', 'list', 'cancel']).describe('Operation to perform'),
+      batchId: z.string().optional().describe('Batch ID (required for "get" and "cancel")'),
+      requests: z
+        .array(batchRequestSchema)
+        .optional()
+        .describe('Batch requests (required for "create")'),
+      limit: z.number().optional().describe('Max results to return (for "list")'),
+      afterId: z.string().optional().describe('Pagination cursor after this batch ID'),
+      beforeId: z.string().optional().describe('Pagination cursor before this batch ID'),
+      betaHeaders: z
+        .array(z.string())
+        .optional()
+        .describe('Anthropic beta headers to send when creating the batch')
+    })
+  )
+  .output(
+    z.object({
+      batch: batchOutputSchema
+        .optional()
+        .describe('Single batch result (for create, get, cancel)'),
+      batches: z.array(batchOutputSchema).optional().describe('List of batches (for list)'),
+      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
+    });
+
+    let { action } = ctx.input;
+
+    if (action === 'create') {
+      if (!ctx.input.requests || ctx.input.requests.length === 0) {
+        throw anthropicServiceError('requests array is required for "create" action');
+      }
+      let batch = await client.createMessageBatch(ctx.input.requests, ctx.input.betaHeaders);
+      return {
+        output: { batch, batches: undefined, hasMore: undefined },
+        message: `Created message batch **${batch.batchId}** with **${ctx.input.requests.length}** request(s).`
+      };
+    }
+
+    if (action === 'get') {
+      if (!ctx.input.batchId) {
+        throw anthropicServiceError('batchId is required for "get" action');
+      }
+      let batch = await client.getMessageBatch(ctx.input.batchId);
+      return {
+        output: { batch, batches: undefined, hasMore: undefined },
+        message: `Batch **${batch.batchId}** status: **${batch.processingStatus}**.`
+      };
+    }
+
+    if (action === 'list') {
+      let result = await client.listMessageBatches({
+        limit: ctx.input.limit,
+        afterId: ctx.input.afterId,
+        beforeId: ctx.input.beforeId
+      });
+      return {
+        output: { batch: undefined, batches: result.batches, hasMore: result.hasMore },
+        message: `Found **${result.batches.length}** batch(es).${result.hasMore ? ' More available with pagination.' : ''}`
+      };
+    }
+
+    // cancel
+    if (!ctx.input.batchId) {
+      throw anthropicServiceError('batchId is required for "cancel" action');
+    }
+    let batch = await client.cancelMessageBatch(ctx.input.batchId);
+    return {
+      output: { batch, batches: undefined, hasMore: undefined },
+      message: `Cancelled batch **${batch.batchId}**.`
+    };
+  })
+  .build();

package/src/tools/manage-organization-members.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';
+
+export let manageOrganizationMembers = SlateTool.create(spec, {
+  name: 'Manage Organization Members',
+  key: 'manage_organization_members',
+  description: `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...).`,
+  instructions: [
+    'For "list_members": optionally pass limit and afterId for pagination.',
+    'For "update_member": provide userId and role.',
+    'For "remove_member": provide userId.',
+    'For "invite": provide email and role.',
+    'For "list_invites": optionally pass limit and afterId for pagination.',
+    'For "get_invite": provide inviteId.',
+    'For "delete_invite": provide inviteId.'
+  ],
+  constraints: [
+    'Requires an Admin API key (sk-ant-admin...).',
+    'Only organization admins can use this tool.'
+  ],
+  tags: {
+    destructive: true,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      action: z
+        .enum([
+          'list_members',
+          'update_member',
+          'remove_member',
+          'invite',
+          'list_invites',
+          'get_invite',
+          'delete_invite'
+        ])
+        .describe('Operation to perform'),
+      userId: z.string().optional().describe('User ID (for update_member, remove_member)'),
+      inviteId: z.string().optional().describe('Invite ID (for delete_invite)'),
+      email: z.string().optional().describe('Email address (for invite)'),
+      role: z.string().optional().describe('Organization role (for update_member, invite)'),
+      limit: z.number().optional().describe('Max results (for list operations)'),
+      afterId: z.string().optional().describe('Pagination cursor (for list operations)')
+    })
+  )
+  .output(
+    z.object({
+      members: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('List of organization members'),
+      invites: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('List of invitations'),
+      invite: z.record(z.string(), z.unknown()).optional().describe('Invitation details'),
+      member: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Updated or invited member details'),
+      hasMore: z.boolean().optional().describe('Whether more results are available'),
+      success: z.boolean().optional().describe('Whether a delete/remove operation succeeded')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    switch (ctx.input.action) {
+      case 'list_members': {
+        let result = await client.listMembers({
+          limit: ctx.input.limit,
+          afterId: ctx.input.afterId
+        });
+        return {
+          output: { members: result.members, hasMore: result.hasMore },
+          message: `Found **${result.members.length}** organization member(s).`
+        };
+      }
+      case 'update_member': {
+        if (!ctx.input.userId || !ctx.input.role) {
+          throw anthropicServiceError('userId and role are required for "update_member"');
+        }
+        let member = await client.updateMember(ctx.input.userId, ctx.input.role);
+        return {
+          output: { member },
+          message: `Updated member **${ctx.input.userId}** to role **${ctx.input.role}**.`
+        };
+      }
+      case 'remove_member': {
+        if (!ctx.input.userId) {
+          throw anthropicServiceError('userId is required for "remove_member"');
+        }
+        await client.removeMember(ctx.input.userId);
+        return {
+          output: { success: true },
+          message: `Removed member **${ctx.input.userId}** from the organization.`
+        };
+      }
+      case 'invite': {
+        if (!ctx.input.email || !ctx.input.role) {
+          throw anthropicServiceError('email and role are required for "invite"');
+        }
+        let member = await client.createInvite(ctx.input.email, ctx.input.role);
+        return {
+          output: { member },
+          message: `Invited **${ctx.input.email}** with role **${ctx.input.role}**.`
+        };
+      }
+      case 'list_invites': {
+        let result = await client.listInvites({
+          limit: ctx.input.limit,
+          afterId: ctx.input.afterId
+        });
+        return {
+          output: { invites: result.invites, hasMore: result.hasMore },
+          message: `Found **${result.invites.length}** invitation(s).`
+        };
+      }
+      case 'get_invite': {
+        if (!ctx.input.inviteId) {
+          throw anthropicServiceError('inviteId is required for "get_invite"');
+        }
+        let invite = await client.getInvite(ctx.input.inviteId);
+        return {
+          output: { invite },
+          message: `Retrieved invite **${ctx.input.inviteId}**.`
+        };
+      }
+      case 'delete_invite': {
+        if (!ctx.input.inviteId) {
+          throw anthropicServiceError('inviteId is required for "delete_invite"');
+        }
+        await client.deleteInvite(ctx.input.inviteId);
+        return {
+          output: { success: true },
+          message: `Deleted invite **${ctx.input.inviteId}**.`
+        };
+      }
+    }
+  })
+  .build();

package/src/tools/manage-workspaces.ts

@@ -0,0 +1,219 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { anthropicServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let manageWorkspaces = SlateTool.create(spec, {
+  name: 'Manage Workspaces',
+  key: 'manage_workspaces',
+  description: `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...).`,
+  instructions: [
+    'For "create": provide workspaceName.',
+    'For "list": optionally provide limit, afterId, and includeArchived.',
+    'For "get": provide workspaceId.',
+    'For "update": provide workspaceId and workspaceName.',
+    'For "archive": provide workspaceId.',
+    'For "add_member": provide workspaceId, userId, and workspaceRole.',
+    'For "list_members": provide workspaceId.',
+    'For "get_member": provide workspaceId and userId.',
+    'For "update_member": provide workspaceId, userId, and workspaceRole.',
+    'For "remove_member": provide workspaceId and userId.'
+  ],
+  constraints: ['Requires an Admin API key (sk-ant-admin...).'],
+  tags: {
+    destructive: true,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      action: z
+        .enum([
+          'create',
+          'list',
+          'get',
+          'update',
+          'archive',
+          'add_member',
+          'list_members',
+          'get_member',
+          'update_member',
+          'remove_member'
+        ])
+        .describe('Operation to perform'),
+      workspaceId: z
+        .string()
+        .optional()
+        .describe('Workspace ID (required for most operations except create and list)'),
+      workspaceName: z.string().optional().describe('Workspace name (for create, update)'),
+      userId: z.string().optional().describe('User ID (for member operations)'),
+      workspaceRole: z
+        .enum([
+          'workspace_user',
+          'workspace_developer',
+          'workspace_admin',
+          'workspace_billing'
+        ])
+        .optional()
+        .describe('Workspace role (for add_member, update_member)'),
+      includeArchived: z
+        .boolean()
+        .optional()
+        .describe('Include archived workspaces in list results'),
+      limit: z.number().optional().describe('Max results for list operations'),
+      afterId: z.string().optional().describe('Pagination cursor for list operations')
+    })
+  )
+  .output(
+    z.object({
+      workspace: z.record(z.string(), z.unknown()).optional().describe('Workspace details'),
+      workspaces: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('List of workspaces'),
+      member: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Workspace member details'),
+      members: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('List of workspace members'),
+      hasMore: z.boolean().optional().describe('Whether more results are available'),
+      success: z.boolean().optional().describe('Whether a remove/archive 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.workspaceName) {
+          throw anthropicServiceError('workspaceName is required for "create"');
+        }
+        let workspace = await client.createWorkspace(ctx.input.workspaceName);
+        return {
+          output: { workspace },
+          message: `Created workspace **${ctx.input.workspaceName}**.`
+        };
+      }
+      case 'list': {
+        let result = await client.listWorkspaces({
+          limit: ctx.input.limit,
+          afterId: ctx.input.afterId,
+          includeArchived: ctx.input.includeArchived
+        });
+        return {
+          output: { workspaces: result.workspaces, hasMore: result.hasMore },
+          message: `Found **${result.workspaces.length}** workspace(s).`
+        };
+      }
+      case 'get': {
+        if (!ctx.input.workspaceId) {
+          throw anthropicServiceError('workspaceId is required for "get"');
+        }
+        let workspace = await client.getWorkspace(ctx.input.workspaceId);
+        return {
+          output: { workspace },
+          message: `Retrieved workspace **${ctx.input.workspaceId}**.`
+        };
+      }
+      case 'update': {
+        if (!ctx.input.workspaceId || !ctx.input.workspaceName) {
+          throw anthropicServiceError(
+            'workspaceId and workspaceName are required for "update"'
+          );
+        }
+        let workspace = await client.updateWorkspace(ctx.input.workspaceId, {
+          name: ctx.input.workspaceName
+        });
+        return {
+          output: { workspace },
+          message: `Updated workspace **${ctx.input.workspaceId}** name to **${ctx.input.workspaceName}**.`
+        };
+      }
+      case 'archive': {
+        if (!ctx.input.workspaceId) {
+          throw anthropicServiceError('workspaceId is required for "archive"');
+        }
+        await client.archiveWorkspace(ctx.input.workspaceId);
+        return {
+          output: { success: true },
+          message: `Archived workspace **${ctx.input.workspaceId}**.`
+        };
+      }
+      case 'add_member': {
+        if (!ctx.input.workspaceId || !ctx.input.userId || !ctx.input.workspaceRole) {
+          throw anthropicServiceError(
+            'workspaceId, userId, and workspaceRole are required for "add_member"'
+          );
+        }
+        let member = await client.addWorkspaceMember(
+          ctx.input.workspaceId,
+          ctx.input.userId,
+          ctx.input.workspaceRole
+        );
+        return {
+          output: { member },
+          message: `Added **${ctx.input.userId}** to workspace **${ctx.input.workspaceId}** as **${ctx.input.workspaceRole}**.`
+        };
+      }
+      case 'list_members': {
+        if (!ctx.input.workspaceId) {
+          throw anthropicServiceError('workspaceId is required for "list_members"');
+        }
+        let result = await client.listWorkspaceMembers(ctx.input.workspaceId, {
+          limit: ctx.input.limit,
+          afterId: ctx.input.afterId
+        });
+        return {
+          output: { members: result.members, hasMore: result.hasMore },
+          message: `Found **${result.members.length}** member(s) in workspace **${ctx.input.workspaceId}**.`
+        };
+      }
+      case 'get_member': {
+        if (!ctx.input.workspaceId || !ctx.input.userId) {
+          throw anthropicServiceError('workspaceId and userId are required for "get_member"');
+        }
+        let member = await client.getWorkspaceMember(ctx.input.workspaceId, ctx.input.userId);
+        return {
+          output: { member },
+          message: `Retrieved **${ctx.input.userId}** membership in workspace **${ctx.input.workspaceId}**.`
+        };
+      }
+      case 'update_member': {
+        if (!ctx.input.workspaceId || !ctx.input.userId || !ctx.input.workspaceRole) {
+          throw anthropicServiceError(
+            'workspaceId, userId, and workspaceRole are required for "update_member"'
+          );
+        }
+        let member = await client.updateWorkspaceMember(
+          ctx.input.workspaceId,
+          ctx.input.userId,
+          ctx.input.workspaceRole
+        );
+        return {
+          output: { member },
+          message: `Updated **${ctx.input.userId}** role to **${ctx.input.workspaceRole}** in workspace **${ctx.input.workspaceId}**.`
+        };
+      }
+      case 'remove_member': {
+        if (!ctx.input.workspaceId || !ctx.input.userId) {
+          throw anthropicServiceError(
+            'workspaceId and userId are required for "remove_member"'
+          );
+        }
+        await client.removeWorkspaceMember(ctx.input.workspaceId, ctx.input.userId);
+        return {
+          output: { success: true },
+          message: `Removed **${ctx.input.userId}** from workspace **${ctx.input.workspaceId}**.`
+        };
+      }
+    }
+  })
+  .build();

package/src/tools/send-message.ts

@@ -0,0 +1,196 @@
+import { SlateTool } from 'slates';
+import { AnthropicClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let contentBlockSchema: z.ZodType<Record<string, unknown>> = z
+  .record(z.string(), z.unknown())
+  .describe('Content block (text, image, tool_use, tool_result, etc.)');
+
+let messageSchema = z.object({
+  role: z.enum(['user', 'assistant']).describe('Role of the message sender'),
+  content: z
+    .union([
+      z.string().describe('Simple text content'),
+      z.array(contentBlockSchema).describe('Array of content blocks for multi-modal input')
+    ])
+    .describe('Message content')
+});
+
+let clientToolDefinitionSchema = z
+  .object({
+    name: z.string().describe('Tool name'),
+    description: z.string().optional().describe('Tool description'),
+    inputSchema: z.record(z.string(), z.unknown()).describe('JSON Schema for tool input')
+  })
+  .passthrough()
+  .describe('Client tool definition using inputSchema');
+
+let rawToolDefinitionSchema = z
+  .record(z.string(), z.unknown())
+  .describe(
+    'Raw Anthropic tool definition, such as { name, input_schema } or server tools like web_search/code_execution'
+  );
+
+let toolDefinitionSchema = z.union([clientToolDefinitionSchema, rawToolDefinitionSchema]);
+
+let toolChoiceSchema = z
+  .record(z.string(), z.unknown())
+  .optional()
+  .describe(
+    'Tool choice configuration: { type: "auto" }, { type: "any" }, { type: "tool", name: "..." }, or { type: "none" }'
+  );
+
+let thinkingSchema = z
+  .record(z.string(), z.unknown())
+  .optional()
+  .describe(
+    'Extended thinking config: { type: "enabled", budget_tokens: 1024 }, { type: "disabled" }, or { type: "adaptive" }'
+  );
+
+export let sendMessage = SlateTool.create(spec, {
+  name: 'Send Message',
+  key: 'send_message',
+  description: `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.`,
+  instructions: [
+    'The messages array must alternate between user and assistant roles.',
+    'Use content blocks (arrays) for multi-modal input like images or tool results.',
+    'Set tools and toolChoice to enable function calling.',
+    'Enable extended thinking with the thinking parameter for complex reasoning tasks (minimum 1024 budget tokens).'
+  ],
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      model: z
+        .string()
+        .describe('Claude model ID, e.g. "claude-sonnet-4-5-20250929", "claude-haiku-4-5"'),
+      maxTokens: z.number().describe('Maximum number of tokens to generate'),
+      messages: z.array(messageSchema).describe('Conversation messages'),
+      system: z
+        .string()
+        .optional()
+        .describe('System prompt to set context and instructions for Claude'),
+      temperature: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Sampling temperature (0-1). Lower values are more deterministic'),
+      topK: z.number().optional().describe('Top-K sampling parameter'),
+      topP: z.number().optional().describe('Nucleus sampling parameter'),
+      stopSequences: z.array(z.string()).optional().describe('Custom stop sequences'),
+      tools: z
+        .array(toolDefinitionSchema)
+        .optional()
+        .describe('Client tool or raw Anthropic tool definitions for function calling'),
+      toolChoice: toolChoiceSchema,
+      thinking: thinkingSchema,
+      metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Request metadata object passed to Anthropic'),
+      mcpServers: z
+        .array(z.record(z.string(), z.unknown()))
+        .optional()
+        .describe('Remote MCP server definitions for the Messages API'),
+      serviceTier: z.string().optional().describe('Anthropic service_tier request option'),
+      betaHeaders: z
+        .array(z.string())
+        .optional()
+        .describe('Anthropic beta headers to send with this request')
+    })
+  )
+  .output(
+    z.object({
+      messageId: z.string().describe('Unique message ID'),
+      role: z.string().describe('Response role (always "assistant")'),
+      content: z
+        .array(z.record(z.string(), z.unknown()))
+        .describe('Response content blocks (text, tool_use, thinking, etc.)'),
+      model: z.string().describe('Model that generated the response'),
+      stopReason: z
+        .string()
+        .describe(
+          'Reason the model stopped: "end_turn", "max_tokens", "stop_sequence", or "tool_use"'
+        ),
+      stopSequence: z
+        .string()
+        .optional()
+        .describe('The stop sequence that caused the model to stop, if applicable'),
+      inputTokens: z.number().describe('Number of input tokens consumed'),
+      outputTokens: z.number().describe('Number of output tokens generated')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AnthropicClient({
+      token: ctx.auth.token,
+      apiVersion: ctx.config.apiVersion
+    });
+
+    let tools = ctx.input.tools?.map(tool => {
+      let rawTool = tool as Record<string, unknown>;
+      if (rawTool.inputSchema !== undefined) {
+        let { inputSchema, ...rest } = rawTool;
+        return {
+          ...rest,
+          input_schema: inputSchema
+        };
+      }
+      return rawTool;
+    });
+
+    let messages = ctx.input.messages as Array<{
+      role: 'user' | 'assistant';
+      content: string | Array<Record<string, unknown>>;
+    }>;
+    let result = await client.createMessage({
+      model: ctx.input.model,
+      maxTokens: ctx.input.maxTokens,
+      messages,
+      system: ctx.input.system,
+      temperature: ctx.input.temperature,
+      topK: ctx.input.topK,
+      topP: ctx.input.topP,
+      stopSequences: ctx.input.stopSequences,
+      tools,
+      toolChoice: ctx.input.toolChoice,
+      thinking: ctx.input.thinking,
+      metadata: ctx.input.metadata,
+      mcpServers: ctx.input.mcpServers,
+      serviceTier: ctx.input.serviceTier,
+      betaHeaders: ctx.input.betaHeaders
+    });
+
+    let usage = result.usage as Record<string, number> | undefined;
+    let content = result.content as Array<Record<string, unknown>>;
+
+    let textContent = content
+      .filter(b => b.type === 'text')
+      .map(b => b.text as string)
+      .join('\n');
+
+    let summary =
+      textContent.length > 200 ? textContent.substring(0, 200) + '...' : textContent;
+    let stopSequence =
+      typeof result.stop_sequence === 'string' ? result.stop_sequence : undefined;
+
+    return {
+      output: {
+        messageId: result.id as string,
+        role: result.role as string,
+        content,
+        model: result.model as string,
+        stopReason: result.stop_reason as string,
+        stopSequence,
+        inputTokens: usage?.input_tokens ?? 0,
+        outputTokens: usage?.output_tokens ?? 0
+      },
+      message: `Claude responded with **${content.length}** content block(s) using **${result.model}**. Stop reason: **${result.stop_reason}**.\n\n${summary ? `> ${summary}` : ''}`
+    };
+  })
+  .build();