@workglow/anthropic 0.2.28

package/dist/ai-provider-runtime.js

@@ -0,0 +1,706 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ai-provider/common/Anthropic_Client.ts
+var _sdk;
+async function loadAnthropicSDK() {
+  if (!_sdk) {
+    try {
+      _sdk = await import("@anthropic-ai/sdk");
+    } catch {
+      throw new Error("@anthropic-ai/sdk is required for Anthropic tasks. Install it with: bun add @anthropic-ai/sdk");
+    }
+  }
+  return _sdk.default;
+}
+async function getClient(model) {
+  const Anthropic = await loadAnthropicSDK();
+  const config = model?.provider_config;
+  const apiKey = config?.credential_key || config?.api_key || (typeof process !== "undefined" ? process.env?.ANTHROPIC_API_KEY : undefined);
+  if (!apiKey) {
+    throw new Error("Missing Anthropic API key: set provider_config.credential_key or the ANTHROPIC_API_KEY environment variable.");
+  }
+  try {
+    return new Anthropic({
+      apiKey,
+      baseURL: config?.base_url || undefined,
+      dangerouslyAllowBrowser: typeof globalThis.document !== "undefined" || "WorkerGlobalScope" in globalThis
+    });
+  } catch (err) {
+    throw new Error(`Failed to create Anthropic client: ${err instanceof Error ? err.message : "unknown error"}`);
+  }
+}
+function getModelName(model) {
+  const name = model?.provider_config?.model_name;
+  if (!name) {
+    throw new Error("Missing model name in provider_config.model_name.");
+  }
+  return name;
+}
+function getMaxTokens(input, model) {
+  return input.maxTokens ?? model?.provider_config?.max_tokens ?? 1024;
+}
+
+// src/ai-provider/registerAnthropicInline.ts
+import { registerProviderInline } from "@workglow/ai-provider/common";
+
+// src/ai-provider/AnthropicQueuedProvider.ts
+import { AiProvider } from "@workglow/ai";
+
+// src/ai-provider/common/Anthropic_Constants.ts
+var ANTHROPIC = "ANTHROPIC";
+
+// src/ai-provider/AnthropicQueuedProvider.ts
+class AnthropicQueuedProvider extends AiProvider {
+  name = ANTHROPIC;
+  displayName = "Anthropic";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/common/Anthropic_ModelSearch.ts
+import { filterLabeledModelsByQuery } from "@workglow/ai-provider/common";
+var ANTHROPIC_FALLBACK = [
+  { label: "claude-opus-4-7", value: "claude-opus-4-7" },
+  { label: "claude-sonnet-4-6", value: "claude-sonnet-4-6" },
+  { label: "claude-haiku-4-5-20251001", value: "claude-haiku-4-5-20251001" },
+  { label: "claude-opus-4-6", value: "claude-opus-4-6" },
+  { label: "claude-sonnet-4-5-20250929", value: "claude-sonnet-4-5-20250929" },
+  { label: "claude-3-5-sonnet-20241022", value: "claude-3-5-sonnet-20241022" },
+  { label: "claude-3-5-haiku-20241022", value: "claude-3-5-haiku-20241022" }
+];
+async function listAnthropicModels(credentialKey) {
+  const client = await getClient({
+    provider: ANTHROPIC,
+    provider_config: { model_name: "", credential_key: credentialKey }
+  });
+  const models = [];
+  for await (const m of client.beta.models.list()) {
+    models.push({ label: `${m.id}  ${m.display_name}`, value: m.id });
+  }
+  return models;
+}
+function mapModelList(models) {
+  return models.map((m) => ({
+    id: m.value,
+    label: m.label,
+    description: "",
+    record: {
+      model_id: m.value,
+      provider: ANTHROPIC,
+      title: m.value,
+      description: "",
+      tasks: [],
+      provider_config: { model_name: m.value },
+      metadata: {}
+    },
+    raw: m
+  }));
+}
+var Anthropic_ModelSearch = async (input) => {
+  let models;
+  if (!input.credential_key) {
+    models = ANTHROPIC_FALLBACK;
+  } else {
+    models = await listAnthropicModels(input.credential_key);
+  }
+  models = filterLabeledModelsByQuery(models, input.query);
+  return { results: mapModelList(models) };
+};
+
+// src/ai-provider/common/Anthropic_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls } from "@workglow/ai/worker";
+import { parsePartialJson } from "@workglow/util/worker";
+function buildAnthropicMessages(messages, prompt) {
+  if (!messages || messages.length === 0) {
+    return [{ role: "user", content: prompt }];
+  }
+  const out = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const blocks = msg.content.map((b) => {
+        if (b.type === "text")
+          return { type: "text", text: b.text };
+        if (b.type === "image") {
+          return {
+            type: "image",
+            source: { type: "base64", media_type: b.mimeType, data: b.data }
+          };
+        }
+        return b;
+      });
+      out.push({ role: "user", content: blocks });
+    } else if (msg.role === "assistant") {
+      const blocks = msg.content.map((b) => {
+        if (b.type === "text")
+          return { type: "text", text: b.text };
+        if (b.type === "tool_use") {
+          return { type: "tool_use", id: b.id, name: b.name, input: b.input };
+        }
+        return b;
+      });
+      out.push({ role: "assistant", content: blocks });
+    } else if (msg.role === "tool") {
+      const blocks = msg.content.filter((b) => b.type === "tool_result").map((b) => {
+        const content = b.content.map((inner) => {
+          if (inner.type === "text")
+            return { type: "text", text: inner.text };
+          if (inner.type === "image") {
+            return {
+              type: "image",
+              source: { type: "base64", media_type: inner.mimeType, data: inner.data }
+            };
+          }
+          return inner;
+        });
+        return {
+          type: "tool_result",
+          tool_use_id: b.tool_use_id,
+          content,
+          ...b.is_error ? { is_error: true } : {}
+        };
+      });
+      out.push({ role: "user", content: blocks });
+    } else if (msg.role === "system") {
+      continue;
+    }
+  }
+  return out;
+}
+function mapAnthropicToolChoice(toolChoice) {
+  if (!toolChoice || toolChoice === "auto")
+    return { type: "auto" };
+  if (toolChoice === "none")
+    return;
+  if (toolChoice === "required")
+    return { type: "any" };
+  return { type: "tool", name: toolChoice };
+}
+var Anthropic_ToolCalling = async (input, model, update_progress, signal, _outputSchema, sessionId) => {
+  update_progress(0, "Starting Anthropic tool calling");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const tools = input.tools.map((t) => ({
+    name: t.name,
+    description: buildToolDescription(t),
+    input_schema: t.inputSchema
+  }));
+  const toolChoice = mapAnthropicToolChoice(input.toolChoice);
+  const messages = buildAnthropicMessages(input.messages, input.prompt);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: getMaxTokens(input, model),
+    temperature: input.temperature
+  };
+  if (input.systemPrompt) {
+    params.system = input.systemPrompt;
+  }
+  if (toolChoice !== undefined) {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  if (sessionId) {
+    if (params.system) {
+      params.system = [
+        {
+          type: "text",
+          text: params.system,
+          cache_control: { type: "ephemeral" }
+        }
+      ];
+    }
+    if (params.tools && params.tools.length > 0) {
+      const lastIdx = params.tools.length - 1;
+      params.tools[lastIdx] = {
+        ...params.tools[lastIdx],
+        cache_control: { type: "ephemeral" }
+      };
+    }
+  }
+  const response = await client.messages.create(params, { signal });
+  const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  const toolCalls = [];
+  response.content.filter((b) => b.type === "tool_use").forEach((b) => {
+    toolCalls.push({
+      id: b.id,
+      name: b.name,
+      input: b.input ?? {}
+    });
+  });
+  update_progress(100, "Completed Anthropic tool calling");
+  return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
+};
+var Anthropic_ToolCalling_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const tools = input.tools.map((t) => ({
+    name: t.name,
+    description: buildToolDescription(t),
+    input_schema: t.inputSchema
+  }));
+  const toolChoice = mapAnthropicToolChoice(input.toolChoice);
+  const messages = buildAnthropicMessages(input.messages, input.prompt);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: getMaxTokens(input, model),
+    temperature: input.temperature
+  };
+  if (input.systemPrompt) {
+    params.system = input.systemPrompt;
+  }
+  if (toolChoice !== undefined) {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  if (sessionId) {
+    if (params.system) {
+      params.system = [
+        {
+          type: "text",
+          text: params.system,
+          cache_control: { type: "ephemeral" }
+        }
+      ];
+    }
+    if (params.tools && params.tools.length > 0) {
+      const lastIdx = params.tools.length - 1;
+      params.tools[lastIdx] = {
+        ...params.tools[lastIdx],
+        cache_control: { type: "ephemeral" }
+      };
+    }
+  }
+  const stream = client.messages.stream(params, { signal });
+  const blockMeta = new Map;
+  const toolCallsByBlockIndex = new Map;
+  const toolCallsInStreamOrder = () => [...toolCallsByBlockIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, tc]) => tc);
+  for await (const event of stream) {
+    if (event.type === "content_block_start") {
+      const block = event.content_block;
+      const index = event.index;
+      if (block.type === "tool_use") {
+        blockMeta.set(index, {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          json: ""
+        });
+      } else if (block.type === "text") {
+        blockMeta.set(index, { type: "text", json: "" });
+      }
+    } else if (event.type === "content_block_delta") {
+      const index = event.index;
+      const delta = event.delta;
+      if (delta.type === "text_delta") {
+        yield { type: "text-delta", port: "text", textDelta: delta.text };
+      } else if (delta.type === "input_json_delta") {
+        const meta = blockMeta.get(index);
+        if (meta) {
+          meta.json += delta.partial_json;
+          let parsedInput;
+          try {
+            parsedInput = JSON.parse(meta.json);
+          } catch {
+            const partial = parsePartialJson(meta.json);
+            parsedInput = partial ?? {};
+          }
+          toolCallsByBlockIndex.set(index, {
+            id: meta.id ?? "",
+            name: meta.name ?? "",
+            input: parsedInput
+          });
+          yield {
+            type: "object-delta",
+            port: "toolCalls",
+            objectDelta: toolCallsInStreamOrder()
+          };
+        }
+      }
+    } else if (event.type === "content_block_stop") {
+      const index = event.index;
+      const meta = blockMeta.get(index);
+      if (meta?.type === "tool_use") {
+        let finalInput;
+        try {
+          finalInput = JSON.parse(meta.json);
+        } catch {
+          finalInput = parsePartialJson(meta.json) ?? {};
+        }
+        const id = meta.id ?? "";
+        toolCallsByBlockIndex.set(index, { id, name: meta.name ?? "", input: finalInput });
+        yield {
+          type: "object-delta",
+          port: "toolCalls",
+          objectDelta: toolCallsInStreamOrder()
+        };
+      }
+      blockMeta.delete(index);
+    }
+  }
+  yield { type: "finish", data: { text: "", toolCalls: [] } };
+};
+
+// src/ai-provider/common/Anthropic_Chat.ts
+function buildParams(input, model, sessionId) {
+  const messages = buildAnthropicMessages(input.messages, input.prompt);
+  const params = {
+    model: getModelName(model),
+    messages,
+    max_tokens: getMaxTokens({ maxTokens: input.maxTokens }, model)
+  };
+  if (input.temperature !== undefined)
+    params.temperature = input.temperature;
+  if (input.systemPrompt) {
+    params.system = sessionId ? [
+      {
+        type: "text",
+        text: input.systemPrompt,
+        cache_control: { type: "ephemeral" }
+      }
+    ] : input.systemPrompt;
+  }
+  if (sessionId && messages.length > 0) {
+    const last = messages[messages.length - 1];
+    if (Array.isArray(last.content) && last.content.length > 0) {
+      const blocks = last.content;
+      blocks[blocks.length - 1] = {
+        ...blocks[blocks.length - 1],
+        cache_control: { type: "ephemeral" }
+      };
+    }
+  }
+  return params;
+}
+var Anthropic_Chat = async (input, model, update_progress, signal, _outputSchema, sessionId) => {
+  update_progress(0, "Anthropic chat turn");
+  const client = await getClient(model);
+  const params = buildParams(input, model, sessionId);
+  const response = await client.messages.create(params, { signal });
+  const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  update_progress(100, "Turn complete");
+  return { text };
+};
+var Anthropic_Chat_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
+  const client = await getClient(model);
+  const params = buildParams(input, model, sessionId);
+  const stream = client.messages.stream(params, { signal });
+  for await (const event of stream) {
+    const e = event;
+    if (e.type === "content_block_delta" && e.delta?.type === "text_delta") {
+      yield { type: "text-delta", port: "text", textDelta: e.delta.text ?? "" };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/Anthropic_CountTokens.ts
+var Anthropic_CountTokens = async (input, model, onProgress, signal) => {
+  const client = await getClient(model);
+  const result = await client.messages.countTokens({
+    model: getModelName(model),
+    messages: [{ role: "user", content: input.text }]
+  });
+  return { count: result.input_tokens };
+};
+var Anthropic_CountTokens_Preview = async (input, _model) => {
+  return { count: Math.ceil(input.text.length / 4) };
+};
+
+// src/ai-provider/common/Anthropic_ModelInfo.ts
+var Anthropic_ModelInfo = async (input) => {
+  if (input.detail === "dimensions") {
+    return {
+      model: input.model,
+      is_local: false,
+      is_remote: true,
+      supports_browser: true,
+      supports_node: true,
+      is_cached: false,
+      is_loaded: false,
+      file_sizes: null
+    };
+  }
+  return {
+    model: input.model,
+    is_local: false,
+    is_remote: true,
+    supports_browser: true,
+    supports_node: true,
+    is_cached: false,
+    is_loaded: false,
+    file_sizes: null
+  };
+};
+
+// src/ai-provider/common/Anthropic_StructuredGeneration.ts
+import { parsePartialJson as parsePartialJson2 } from "@workglow/util/worker";
+var Anthropic_StructuredGeneration = async (input, model, update_progress, signal, outputSchema) => {
+  update_progress(0, "Starting Anthropic structured generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const schema = input.outputSchema ?? outputSchema;
+  const response = await client.messages.create({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    tools: [
+      {
+        name: "structured_output",
+        description: "Output structured data conforming to the schema",
+        input_schema: schema
+      }
+    ],
+    tool_choice: { type: "tool", name: "structured_output" },
+    max_tokens: getMaxTokens(input, model)
+  }, { signal });
+  const toolBlock = response.content.find((b) => b.type === "tool_use");
+  const object = toolBlock?.input ?? {};
+  update_progress(100, "Completed Anthropic structured generation");
+  return { object };
+};
+var Anthropic_StructuredGeneration_Stream = async function* (input, model, signal, outputSchema) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const schema = input.outputSchema ?? outputSchema;
+  const stream = client.messages.stream({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    tools: [
+      {
+        name: "structured_output",
+        description: "Output structured data conforming to the schema",
+        input_schema: schema
+      }
+    ],
+    tool_choice: { type: "tool", name: "structured_output" },
+    max_tokens: getMaxTokens(input, model)
+  }, { signal });
+  let accumulatedJson = "";
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "input_json_delta") {
+      accumulatedJson += event.delta.partial_json;
+      const partial = parsePartialJson2(accumulatedJson);
+      if (partial !== undefined) {
+        yield { type: "object-delta", port: "object", objectDelta: partial };
+      }
+    }
+  }
+  let finalObject;
+  try {
+    finalObject = JSON.parse(accumulatedJson);
+  } catch {
+    finalObject = parsePartialJson2(accumulatedJson) ?? {};
+  }
+  yield { type: "finish", data: { object: finalObject } };
+};
+
+// src/ai-provider/common/Anthropic_TextGeneration.ts
+import { getLogger } from "@workglow/util/worker";
+var Anthropic_TextGeneration = async (input, model, update_progress, signal, _outputSchema, sessionId) => {
+  const logger = getLogger();
+  const timerLabel = `anthropic:TextGeneration:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting Anthropic text generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const params = {
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: getMaxTokens(input, model),
+    temperature: input.temperature,
+    top_p: input.topP
+  };
+  if (sessionId && params.system) {
+    params.system = [
+      {
+        type: "text",
+        text: params.system,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  }
+  const response = await client.messages.create(params, { signal });
+  const text = response.content[0]?.type === "text" ? response.content[0].text : "";
+  update_progress(100, "Completed Anthropic text generation");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  return { text };
+};
+var Anthropic_TextGeneration_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const params = {
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: getMaxTokens(input, model),
+    temperature: input.temperature,
+    top_p: input.topP
+  };
+  if (sessionId && params.system) {
+    params.system = [
+      {
+        type: "text",
+        text: params.system,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  }
+  const stream = client.messages.stream(params, { signal });
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      yield { type: "text-delta", port: "text", textDelta: event.delta.text };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/Anthropic_TextRewriter.ts
+var Anthropic_TextRewriter = async (input, model, update_progress, signal) => {
+  update_progress(0, "Starting Anthropic text rewriting");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.messages.create({
+    model: modelName,
+    system: input.prompt,
+    messages: [{ role: "user", content: input.text }],
+    max_tokens: getMaxTokens({}, model)
+  }, { signal });
+  const text = response.content[0]?.type === "text" ? response.content[0].text : "";
+  update_progress(100, "Completed Anthropic text rewriting");
+  return { text };
+};
+var Anthropic_TextRewriter_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const stream = client.messages.stream({
+    model: modelName,
+    system: input.prompt,
+    messages: [{ role: "user", content: input.text }],
+    max_tokens: getMaxTokens({}, model)
+  }, { signal });
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      yield { type: "text-delta", port: "text", textDelta: event.delta.text };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/Anthropic_TextSummary.ts
+var Anthropic_TextSummary = async (input, model, update_progress, signal) => {
+  update_progress(0, "Starting Anthropic text summarization");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.messages.create({
+    model: modelName,
+    system: "Summarize the following text concisely.",
+    messages: [{ role: "user", content: input.text }],
+    max_tokens: getMaxTokens({}, model)
+  }, { signal });
+  const text = response.content[0]?.type === "text" ? response.content[0].text : "";
+  update_progress(100, "Completed Anthropic text summarization");
+  return { text };
+};
+var Anthropic_TextSummary_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const stream = client.messages.stream({
+    model: modelName,
+    system: "Summarize the following text concisely.",
+    messages: [{ role: "user", content: input.text }],
+    max_tokens: getMaxTokens({}, model)
+  }, { signal });
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      yield { type: "text-delta", port: "text", textDelta: event.delta.text };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/Anthropic_JobRunFns.ts
+var ANTHROPIC_TASKS = {
+  AiChatTask: Anthropic_Chat,
+  CountTokensTask: Anthropic_CountTokens,
+  ModelInfoTask: Anthropic_ModelInfo,
+  TextGenerationTask: Anthropic_TextGeneration,
+  TextRewriterTask: Anthropic_TextRewriter,
+  TextSummaryTask: Anthropic_TextSummary,
+  StructuredGenerationTask: Anthropic_StructuredGeneration,
+  ToolCallingTask: Anthropic_ToolCalling,
+  ModelSearchTask: Anthropic_ModelSearch
+};
+var ANTHROPIC_STREAM_TASKS = {
+  AiChatTask: Anthropic_Chat_Stream,
+  TextGenerationTask: Anthropic_TextGeneration_Stream,
+  TextRewriterTask: Anthropic_TextRewriter_Stream,
+  TextSummaryTask: Anthropic_TextSummary_Stream,
+  StructuredGenerationTask: Anthropic_StructuredGeneration_Stream,
+  ToolCallingTask: Anthropic_ToolCalling_Stream
+};
+var ANTHROPIC_PREVIEW_TASKS = {
+  CountTokensTask: Anthropic_CountTokens_Preview
+};
+
+// src/ai-provider/registerAnthropicInline.ts
+async function registerAnthropicInline(options) {
+  await registerProviderInline(new AnthropicQueuedProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS, ANTHROPIC_PREVIEW_TASKS), "Anthropic", options);
+}
+
+// src/ai-provider/registerAnthropicWorker.ts
+import { registerProviderWorker } from "@workglow/ai-provider/common";
+
+// src/ai-provider/AnthropicProvider.ts
+import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
+class AnthropicProvider extends AiProvider2 {
+  name = ANTHROPIC;
+  displayName = "Anthropic";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/registerAnthropicWorker.ts
+async function registerAnthropicWorker() {
+  await registerProviderWorker((ws) => new AnthropicProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS, ANTHROPIC_PREVIEW_TASKS).registerOnWorkerServer(ws), "Anthropic");
+}
+export {
+  registerAnthropicWorker,
+  registerAnthropicInline,
+  loadAnthropicSDK,
+  getModelName,
+  getMaxTokens,
+  getClient
+};
+
+//# debugId=5CF7CD36576BBE7E64756E2164756E21