@workglow/anthropic 0.2.34 → 0.2.35

package/dist/ai.js

@@ -8,7 +8,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/ai/common/Anthropic_Constants.ts
 var ANTHROPIC = "ANTHROPIC";
-
 // src/ai/common/Anthropic_ModelSchema.ts
 import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
 var AnthropicModelSchema = {
@@ -68,7 +67,6 @@ var AnthropicModelConfigSchema = {
   required: [...ModelConfigSchema.required, ...AnthropicModelSchema.required],
   additionalProperties: false
 };
-
 // src/ai/common/Anthropic_ModelSearch.ts
 import { filterLabeledModelsByQuery } from "@workglow/ai/provider-utils";
 
@@ -142,14 +140,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;
@@ -157,44 +155,482 @@ 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/registerAnthropic.ts
 import { registerProviderWithWorker } from "@workglow/ai/provider-utils";
 
 // src/ai/AnthropicQueuedProvider.ts
 import { AiProvider } from "@workglow/ai";
 import { createCloudProviderClass } from "@workglow/ai/provider-utils";
-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/registerAnthropic.ts
 async function registerAnthropic(options) {
   await registerProviderWithWorker(new AnthropicQueuedProvider, "Anthropic", options);
 }
+// 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_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 as parsePartialJson2 } 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_Stream = async (input, model, signal, emit, _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);
+  const validatedToolCallsInStreamOrder = () => filterValidToolCalls(toolCallsInStreamOrder(), input.tools);
+  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") {
+        emit({ 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 = parsePartialJson2(meta.json);
+            parsedInput = partial ?? {};
+          }
+          toolCallsByBlockIndex.set(index, {
+            id: meta.id ?? "",
+            name: meta.name ?? "",
+            input: parsedInput
+          });
+          emit({
+            type: "object-delta",
+            port: "toolCalls",
+            objectDelta: validatedToolCallsInStreamOrder()
+          });
+        }
+      }
+    } 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 = parsePartialJson2(meta.json) ?? {};
+        }
+        const id = meta.id ?? "";
+        toolCallsByBlockIndex.set(index, { id, name: meta.name ?? "", input: finalInput });
+        emit({
+          type: "object-delta",
+          port: "toolCalls",
+          objectDelta: validatedToolCallsInStreamOrder()
+        });
+      }
+      blockMeta.delete(index);
+    }
+  }
+  emit({ type: "finish", data: { text: "", toolCalls: [] } });
+};
+
+// src/ai/common/Anthropic_TextGeneration.ts
+var Anthropic_TextGeneration_Stream = async (input, model, signal, emit, _outputSchema, sessionId) => {
+  const logger = getLogger();
+  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 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 ?? "" });
+      }
+    }
+    emit({ type: "finish", data: {} });
+  } finally {
+    logger.timeEnd(timerLabel, { model: getModelName(model) });
+  }
+};
+
+// src/ai/common/Anthropic_TextRewriter.ts
+var Anthropic_TextRewriter_Stream = async (input, model, signal, emit) => {
+  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") {
+      emit({ type: "text-delta", port: "text", textDelta: event.delta.text });
+    }
+  }
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/Anthropic_TextSummary.ts
+var Anthropic_TextSummary_Stream = async (input, model, signal, emit) => {
+  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") {
+      emit({ type: "text-delta", port: "text", textDelta: event.delta.text });
+    }
+  }
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/Anthropic_JobRunFns.ts
+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/index.ts
+var _testOnly = {
+  AnthropicQueuedProvider,
+  ANTHROPIC_RUN_FN_SPECS,
+  ANTHROPIC_RUN_FNS
+};
 export {
   registerAnthropic,
-  Anthropic_ModelSearch,
+  _testOnly,
+  Anthropic_ModelSearch_Stream,
   AnthropicModelSchema,
   AnthropicModelRecordSchema,
   AnthropicModelConfigSchema,
   ANTHROPIC
 };
 
-//# debugId=33BB6E69EB04364264756E2164756E21
+//# debugId=4152D03071B4556864756E2164756E21