chore: import upstream snapshot with attribution

apps/sim/providers/anthropic/index.ts

@@ -0,0 +1,41 @@
+import Anthropic from '@anthropic-ai/sdk'
+import { createLogger } from '@sim/logger'
+import type { StreamingExecution } from '@/executor/types'
+import { executeAnthropicProviderRequest } from '@/providers/anthropic/core'
+import { getCachedProviderClient } from '@/providers/client-cache'
+import { getProviderDefaultModel, getProviderModels } from '@/providers/models'
+import type { ProviderConfig, ProviderRequest, ProviderResponse } from '@/providers/types'
+
+const logger = createLogger('AnthropicProvider')
+
+export const anthropicProvider: ProviderConfig = {
+  id: 'anthropic',
+  name: 'Anthropic',
+  description: "Anthropic's Claude models",
+  version: '1.0.0',
+  models: getProviderModels('anthropic'),
+  defaultModel: getProviderDefaultModel('anthropic'),
+
+  executeRequest: async (
+    request: ProviderRequest
+  ): Promise<ProviderResponse | StreamingExecution> => {
+    return executeAnthropicProviderRequest(request, {
+      providerId: 'anthropic',
+      providerLabel: 'Anthropic',
+      createClient: (apiKey, useNativeStructuredOutputs) => {
+        const cacheKey = `anthropic::${apiKey}::${useNativeStructuredOutputs ? 'beta' : 'default'}`
+        return getCachedProviderClient(
+          cacheKey,
+          () =>
+            new Anthropic({
+              apiKey,
+              defaultHeaders: useNativeStructuredOutputs
+                ? { 'anthropic-beta': 'structured-outputs-2025-11-13' }
+                : undefined,
+            })
+        )
+      },
+      logger,
+    })
+  },
+}

apps/sim/providers/anthropic/utils.ts

@@ -0,0 +1,85 @@
+import type {
+  RawMessageDeltaEvent,
+  RawMessageStartEvent,
+  RawMessageStreamEvent,
+  Usage,
+} from '@anthropic-ai/sdk/resources'
+import { createLogger } from '@sim/logger'
+import { randomFloat } from '@sim/utils/random'
+import { trackForcedToolUsage } from '@/providers/utils'
+
+const logger = createLogger('AnthropicUtils')
+
+export interface AnthropicStreamUsage {
+  input_tokens: number
+  output_tokens: number
+}
+
+export function createReadableStreamFromAnthropicStream(
+  anthropicStream: AsyncIterable<RawMessageStreamEvent>,
+  onComplete?: (content: string, usage: AnthropicStreamUsage) => void
+): ReadableStream<Uint8Array> {
+  let fullContent = ''
+  let inputTokens = 0
+  let outputTokens = 0
+
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of anthropicStream) {
+          if (event.type === 'message_start') {
+            const startEvent = event as RawMessageStartEvent
+            const usage: Usage = startEvent.message.usage
+            inputTokens = usage.input_tokens
+          } else if (event.type === 'message_delta') {
+            const deltaEvent = event as RawMessageDeltaEvent
+            outputTokens = deltaEvent.usage.output_tokens
+          } else if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+            const text = event.delta.text
+            fullContent += text
+            controller.enqueue(new TextEncoder().encode(text))
+          }
+        }
+
+        if (onComplete) {
+          onComplete(fullContent, { input_tokens: inputTokens, output_tokens: outputTokens })
+        }
+
+        controller.close()
+      } catch (err) {
+        controller.error(err)
+      }
+    },
+  })
+}
+
+export function generateToolUseId(toolName: string): string {
+  return `${toolName}-${Date.now()}-${randomFloat().toString(36).substring(2, 7)}`
+}
+
+export function checkForForcedToolUsage(
+  response: any,
+  toolChoice: any,
+  forcedTools: string[],
+  usedForcedTools: string[]
+): { hasUsedForcedTool: boolean; usedForcedTools: string[] } | null {
+  if (typeof toolChoice === 'object' && toolChoice !== null && Array.isArray(response.content)) {
+    const toolUses = response.content.filter((item: any) => item.type === 'tool_use')
+
+    if (toolUses.length > 0) {
+      const adaptedToolCalls = toolUses.map((tool: any) => ({ name: tool.name }))
+      const adaptedToolChoice =
+        toolChoice.type === 'tool' ? { function: { name: toolChoice.name } } : toolChoice
+
+      return trackForcedToolUsage(
+        adaptedToolCalls,
+        adaptedToolChoice,
+        logger,
+        'anthropic',
+        forcedTools,
+        usedForcedTools
+      )
+    }
+  }
+  return null
+}