@workglow/anthropic 0.2.34 → 0.2.36

package/dist/ai-runtime.js

@@ -55,25 +55,131 @@ import { createCloudProviderClass } from "@workglow/ai/provider-utils";
 // src/ai/common/Anthropic_Constants.ts
 var ANTHROPIC = "ANTHROPIC";
 
-// src/ai/AnthropicQueuedProvider.ts
-var ANTHROPIC_TASK_TYPES = [
-  "CountTokensTask",
-  "ModelInfoTask",
-  "TextGenerationTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "StructuredGenerationTask",
-  "ToolCallingTask",
-  "ModelSearchTask"
+// src/ai/common/Anthropic_CapabilitySets.ts
+var ANTHROPIC_TEXT_GENERATION = ["text.generation"];
+var ANTHROPIC_TOOL_USE = ["text.generation", "tool-use"];
+var ANTHROPIC_JSON_MODE = ["text.generation", "json-mode"];
+var ANTHROPIC_TEXT_REWRITER = ["text.rewriter"];
+var ANTHROPIC_TEXT_SUMMARY = ["text.summary"];
+var ANTHROPIC_COUNT_TOKENS = ["model.count-tokens"];
+var ANTHROPIC_MODEL_SEARCH = ["model.search"];
+var ANTHROPIC_MODEL_INFO = ["model.info"];
+var ANTHROPIC_CAPABILITY_SETS = [
+  ANTHROPIC_TEXT_GENERATION,
+  ANTHROPIC_TOOL_USE,
+  ANTHROPIC_JSON_MODE,
+  ANTHROPIC_TEXT_REWRITER,
+  ANTHROPIC_TEXT_SUMMARY,
+  ANTHROPIC_COUNT_TOKENS,
+  ANTHROPIC_MODEL_SEARCH,
+  ANTHROPIC_MODEL_INFO
 ];
 
+// src/ai/common/Anthropic_Capabilities.ts
+var ANTHROPIC_RUN_FN_SPECS = ANTHROPIC_CAPABILITY_SETS.map((serves) => ({ serves }));
+function anthropicWorkerRunFnSpecs() {
+  return ANTHROPIC_RUN_FN_SPECS;
+}
+function inferAnthropicCapabilities(model) {
+  const id = String(model.model_id ?? model.provider_config?.model_name ?? "");
+  if (/^claude-3[.-][57]-/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "vision-input",
+      "model.count-tokens",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/^claude-(sonnet|opus|haiku)-4/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "vision-input",
+      "model.count-tokens",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/^claude-3[.-](haiku|opus|sonnet)/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "vision-input",
+      "model.count-tokens",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/^claude-2/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "model.count-tokens",
+      "model.info",
+      "model.search"
+    ];
+  }
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  return ["model.search", "model.info"];
+}
+
+// src/ai/AnthropicQueuedProvider.ts
 class AnthropicQueuedProvider extends createCloudProviderClass(AiProvider, {
   name: ANTHROPIC,
-  displayName: "Anthropic",
-  taskTypes: ANTHROPIC_TASK_TYPES
+  displayName: "Anthropic"
 }) {
+  inferCapabilities(model) {
+    return inferAnthropicCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return anthropicWorkerRunFnSpecs();
+  }
 }
 
+// src/ai/common/Anthropic_CountTokens.ts
+var Anthropic_CountTokens_Stream = async (input, model, signal, emit) => {
+  const client = await getClient(model);
+  const result = await client.messages.countTokens({
+    model: getModelName(model),
+    messages: [{ role: "user", content: input.text }]
+  });
+  emit({ type: "finish", data: { count: result.input_tokens } });
+};
+var Anthropic_CountTokens_Preview = async (input, _model) => {
+  return { count: Math.ceil(input.text.length / 4) };
+};
+
+// src/ai/common/Anthropic_ModelInfo.ts
+var Anthropic_ModelInfo_Stream = async (input, _model, _signal, emit) => {
+  const result = {
+    model: input.model,
+    is_local: false,
+    is_remote: true,
+    supports_browser: true,
+    supports_node: true,
+    is_cached: false,
+    is_loaded: false,
+    file_sizes: null
+  };
+  emit({ type: "finish", data: result });
+};
+
 // src/ai/common/Anthropic_ModelSearch.ts
 import { filterLabeledModelsByQuery } from "@workglow/ai/provider-utils";
 var ANTHROPIC_FALLBACK = [
@@ -106,14 +212,14 @@ function mapModelList(models) {
       provider: ANTHROPIC,
       title: m.value,
       description: "",
-      tasks: [],
+      capabilities: [],
       provider_config: { model_name: m.value },
       metadata: {}
     },
     raw: m
   }));
 }
-var Anthropic_ModelSearch = async (input) => {
+var Anthropic_ModelSearch_Stream = async (input, _model, _signal, emit) => {
   let models;
   if (!input.credential_key) {
     models = ANTHROPIC_FALLBACK;
@@ -121,12 +227,53 @@ var Anthropic_ModelSearch = async (input) => {
     models = await listAnthropicModels(input.credential_key);
   }
   models = filterLabeledModelsByQuery(models, input.query);
-  return { results: mapModelList(models) };
+  emit({ type: "finish", data: { results: mapModelList(models) } });
+};
+
+// src/ai/common/Anthropic_StructuredGeneration.ts
+import { parsePartialJson } from "@workglow/util/worker";
+var Anthropic_StructuredGeneration_Stream = async (input, model, signal, emit, 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 = parsePartialJson(accumulatedJson);
+      if (partial !== undefined) {
+        emit({ type: "object-delta", port: "object", objectDelta: partial });
+      }
+    }
+  }
+  let finalObject;
+  try {
+    finalObject = JSON.parse(accumulatedJson);
+  } catch {
+    finalObject = parsePartialJson(accumulatedJson) ?? {};
+  }
+  emit({ type: "finish", data: { object: finalObject } });
 };
 
+// src/ai/common/Anthropic_TextGeneration.ts
+import { getLogger } from "@workglow/util/worker";
+
 // src/ai/common/Anthropic_ToolCalling.ts
 import { buildToolDescription, filterValidToolCalls } from "@workglow/ai/worker";
-import { parsePartialJson } from "@workglow/util/worker";
+import { parsePartialJson as parsePartialJson2 } from "@workglow/util/worker";
 function buildAnthropicMessages(messages, prompt) {
   if (!messages || messages.length === 0) {
     return [{ role: "user", content: prompt }];
@@ -192,62 +339,7 @@ function mapAnthropicToolChoice(toolChoice) {
     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) {
+var Anthropic_ToolCalling_Stream = async (input, model, signal, emit, _outputSchema, sessionId) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const tools = input.tools.map((t) => ({
@@ -292,6 +384,7 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal, _outpu
   const blockMeta = new Map;
   const toolCallsByBlockIndex = new Map;
   const toolCallsInStreamOrder = () => [...toolCallsByBlockIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, tc]) => tc);
+  const validatedToolCallsInStreamOrder = () => filterValidToolCalls(toolCallsInStreamOrder(), input.tools);
   for await (const event of stream) {
     if (event.type === "content_block_start") {
       const block = event.content_block;
@@ -310,7 +403,7 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal, _outpu
       const index = event.index;
       const delta = event.delta;
       if (delta.type === "text_delta") {
-        yield { type: "text-delta", port: "text", textDelta: delta.text };
+        emit({ type: "text-delta", port: "text", textDelta: delta.text });
       } else if (delta.type === "input_json_delta") {
         const meta = blockMeta.get(index);
         if (meta) {
@@ -319,7 +412,7 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal, _outpu
           try {
             parsedInput = JSON.parse(meta.json);
           } catch {
-            const partial = parsePartialJson(meta.json);
+            const partial = parsePartialJson2(meta.json);
             parsedInput = partial ?? {};
           }
           toolCallsByBlockIndex.set(index, {
@@ -327,11 +420,11 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal, _outpu
             name: meta.name ?? "",
             input: parsedInput
           });
-          yield {
+          emit({
             type: "object-delta",
             port: "toolCalls",
-            objectDelta: toolCallsInStreamOrder()
-          };
+            objectDelta: validatedToolCallsInStreamOrder()
+          });
         }
       }
     } else if (event.type === "content_block_stop") {
@@ -342,250 +435,76 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal, _outpu
         try {
           finalInput = JSON.parse(meta.json);
         } catch {
-          finalInput = parsePartialJson(meta.json) ?? {};
+          finalInput = parsePartialJson2(meta.json) ?? {};
         }
         const id = meta.id ?? "";
         toolCallsByBlockIndex.set(index, { id, name: meta.name ?? "", input: finalInput });
-        yield {
+        emit({
           type: "object-delta",
           port: "toolCalls",
-          objectDelta: toolCallsInStreamOrder()
-        };
+          objectDelta: validatedToolCallsInStreamOrder()
+        });
       }
       blockMeta.delete(index);
     }
   }
-  yield { type: "finish", data: { text: "", toolCalls: [] } };
-};
-
-// src/ai/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/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/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/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 } };
+  emit({ type: "finish", data: { text: "", toolCalls: [] } });
 };
 
 // src/ai/common/Anthropic_TextGeneration.ts
-import { getLogger } from "@workglow/util/worker";
-var Anthropic_TextGeneration = async (input, model, update_progress, signal, _outputSchema, sessionId) => {
+var Anthropic_TextGeneration_Stream = async (input, model, signal, emit, _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 timerLabel = `anthropic:TextGeneration:${getModelName(model)}`;
+  logger.time(timerLabel, { model: getModelName(model) });
+  try {
+    const client = await getClient(model);
+    const modelName = getModelName(model);
+    const unified = input;
+    const hasMessages = Array.isArray(unified.messages) && unified.messages.length > 0;
+    const messages = hasMessages ? buildAnthropicMessages(unified.messages, unified.prompt ?? "") : [{ role: "user", content: input.prompt }];
+    const params = {
+      model: modelName,
+      messages,
+      max_tokens: getMaxTokens(input, model)
+    };
+    if (input.temperature !== undefined)
+      params.temperature = input.temperature;
+    if (input.topP !== undefined)
+      params.top_p = input.topP;
+    if (unified.systemPrompt) {
+      params.system = sessionId ? [
+        {
+          type: "text",
+          text: unified.systemPrompt,
+          cache_control: { type: "ephemeral" }
+        }
+      ] : unified.systemPrompt;
+    }
+    if (sessionId && hasMessages && Array.isArray(messages) && 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" }
+        };
       }
-    ];
-  }
-  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) {
+      const e = event;
+      if (e.type === "content_block_delta" && e.delta?.type === "text_delta") {
+        emit({ type: "text-delta", port: "text", textDelta: e.delta.text ?? "" });
       }
-    ];
-  }
-  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 };
     }
+    emit({ type: "finish", data: {} });
+  } finally {
+    logger.timeEnd(timerLabel, { model: getModelName(model) });
   }
-  yield { type: "finish", data: {} };
 };
 
 // src/ai/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) {
+var Anthropic_TextRewriter_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const stream = client.messages.stream({
@@ -596,28 +515,14 @@ var Anthropic_TextRewriter_Stream = async function* (input, model, signal) {
   }, { 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 };
+      emit({ type: "text-delta", port: "text", textDelta: event.delta.text });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/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) {
+var Anthropic_TextSummary_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const stream = client.messages.stream({
@@ -628,39 +533,30 @@ var Anthropic_TextSummary_Stream = async function* (input, model, signal) {
   }, { 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 };
+      emit({ type: "text-delta", port: "text", textDelta: event.delta.text });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/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_RUN_FNS = [
+  { serves: ANTHROPIC_TEXT_GENERATION, runFn: Anthropic_TextGeneration_Stream },
+  { serves: ANTHROPIC_TOOL_USE, runFn: Anthropic_ToolCalling_Stream },
+  { serves: ANTHROPIC_JSON_MODE, runFn: Anthropic_StructuredGeneration_Stream },
+  { serves: ANTHROPIC_TEXT_REWRITER, runFn: Anthropic_TextRewriter_Stream },
+  { serves: ANTHROPIC_TEXT_SUMMARY, runFn: Anthropic_TextSummary_Stream },
+  { serves: ANTHROPIC_COUNT_TOKENS, runFn: Anthropic_CountTokens_Stream },
+  { serves: ANTHROPIC_MODEL_SEARCH, runFn: Anthropic_ModelSearch_Stream },
+  { serves: ANTHROPIC_MODEL_INFO, runFn: Anthropic_ModelInfo_Stream }
+];
 var ANTHROPIC_PREVIEW_TASKS = {
   CountTokensTask: Anthropic_CountTokens_Preview
 };
 
 // src/ai/registerAnthropicInline.ts
 async function registerAnthropicInline(options) {
-  await registerProviderInline(new AnthropicQueuedProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS, ANTHROPIC_PREVIEW_TASKS), "Anthropic", options);
+  await registerProviderInline(new AnthropicQueuedProvider(ANTHROPIC_RUN_FNS, ANTHROPIC_PREVIEW_TASKS), "Anthropic", options);
 }
 
 // src/ai/registerAnthropicWorker.ts
@@ -669,27 +565,21 @@ import { registerProviderWorker } from "@workglow/ai/provider-utils";
 // src/ai/AnthropicProvider.ts
 import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
 import { createCloudProviderClass as createCloudProviderClass2 } from "@workglow/ai/provider-utils";
-var ANTHROPIC_TASK_TYPES2 = [
-  "CountTokensTask",
-  "ModelInfoTask",
-  "TextGenerationTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "StructuredGenerationTask",
-  "ToolCallingTask",
-  "ModelSearchTask"
-];
-
 class AnthropicProvider extends createCloudProviderClass2(AiProvider2, {
   name: ANTHROPIC,
-  displayName: "Anthropic",
-  taskTypes: ANTHROPIC_TASK_TYPES2
+  displayName: "Anthropic"
 }) {
+  inferCapabilities(model) {
+    return inferAnthropicCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return anthropicWorkerRunFnSpecs();
+  }
 }
 
 // src/ai/registerAnthropicWorker.ts
 async function registerAnthropicWorker() {
-  await registerProviderWorker((ws) => new AnthropicProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS, ANTHROPIC_PREVIEW_TASKS).registerOnWorkerServer(ws), "Anthropic");
+  await registerProviderWorker((ws) => new AnthropicProvider(ANTHROPIC_RUN_FNS, ANTHROPIC_PREVIEW_TASKS).registerOnWorkerServer(ws), "Anthropic");
 }
 export {
   registerAnthropicWorker,
@@ -700,4 +590,4 @@ export {
   getClient
 };
 
-//# debugId=E195BAB59909F33A64756E2164756E21
+//# debugId=C12852ADBF7F344D64756E2164756E21