@workglow/ai-provider 0.0.121 → 0.0.123

package/dist/provider-anthropic/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/provider-anthropic/common/Anthropic_Constants.ts", "../src/provider-anthropic/common/Anthropic_ModelSchema.ts", "../src/provider-anthropic/AnthropicQueuedProvider.ts", "../src/provider-anthropic/registerAnthropic.ts"],
+  "sourcesContent": [
+    "/**\n * @license\n * Copyright 2025 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nexport const ANTHROPIC = \"ANTHROPIC\";\n",
+    "/**\n * @license\n * Copyright 2025 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { ModelConfigSchema, ModelRecordSchema } from \"@workglow/ai/worker\";\nimport { DataPortSchemaObject, FromSchema } from \"@workglow/util/worker\";\nimport { ANTHROPIC } from \"./Anthropic_Constants\";\n\nexport const AnthropicModelSchema = {\n  type: \"object\",\n  properties: {\n    provider: {\n      const: ANTHROPIC,\n      description: \"Discriminator: Anthropic cloud provider.\",\n    },\n    provider_config: {\n      type: \"object\",\n      description: \"Anthropic-specific configuration.\",\n      properties: {\n        model_name: {\n          type: \"string\",\n          description:\n            \"The Anthropic model identifier (e.g., 'claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022').\",\n        },\n        credential_key: {\n          type: \"string\",\n          format: \"credential\",\n          description: \"Key to look up in the credential store for the API key.\",\n          \"x-ui-hidden\": true,\n        },\n        base_url: {\n          type: \"string\",\n          description: \"Base URL for the Anthropic API (optional).\",\n        },\n        max_tokens: {\n          type: \"integer\",\n          description: \"Default max tokens for responses. Anthropic requires this parameter.\",\n          default: 1024,\n          minimum: 1,\n        },\n      },\n      required: [\"model_name\"],\n      additionalProperties: false,\n    },\n  },\n  required: [\"provider\", \"provider_config\"],\n  additionalProperties: true,\n} as const satisfies DataPortSchemaObject;\n\nexport const AnthropicModelRecordSchema = {\n  type: \"object\",\n  properties: {\n    ...ModelRecordSchema.properties,\n    ...AnthropicModelSchema.properties,\n  },\n  required: [...ModelRecordSchema.required, ...AnthropicModelSchema.required],\n  additionalProperties: false,\n} as const satisfies DataPortSchemaObject;\n\nexport type AnthropicModelRecord = FromSchema<typeof AnthropicModelRecordSchema>;\n\nexport const AnthropicModelConfigSchema = {\n  type: \"object\",\n  properties: {\n    ...ModelConfigSchema.properties,\n    ...AnthropicModelSchema.properties,\n  },\n  required: [...ModelConfigSchema.required, ...AnthropicModelSchema.required],\n  additionalProperties: false,\n} as const satisfies DataPortSchemaObject;\n\nexport type AnthropicModelConfig = FromSchema<typeof AnthropicModelConfigSchema>;\n",
+    "/**\n * @license\n * Copyright 2025 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {\n  QueuedAiProvider,\n  type AiProviderReactiveRunFn,\n  type AiProviderRunFn,\n  type AiProviderStreamFn,\n} from \"@workglow/ai\";\nimport { ANTHROPIC } from \"./common/Anthropic_Constants\";\nimport type { AnthropicModelConfig } from \"./common/Anthropic_ModelSchema\";\n\n/** Main-thread registration (inline or worker-backed); creates the default job queue. */\nexport class AnthropicQueuedProvider extends QueuedAiProvider<AnthropicModelConfig> {\n  readonly name = ANTHROPIC;\n  readonly isLocal = false;\n  readonly supportsBrowser = true;\n\n  readonly taskTypes = [\n    \"CountTokensTask\",\n    \"ModelInfoTask\",\n    \"TextGenerationTask\",\n    \"TextRewriterTask\",\n    \"TextSummaryTask\",\n    \"StructuredGenerationTask\",\n    \"ToolCallingTask\",\n    \"ModelSearchTask\",\n  ] as const;\n\n  constructor(\n    tasks?: Record<string, AiProviderRunFn<any, any, AnthropicModelConfig>>,\n    streamTasks?: Record<string, AiProviderStreamFn<any, any, AnthropicModelConfig>>,\n    reactiveTasks?: Record<string, AiProviderReactiveRunFn<any, any, AnthropicModelConfig>>\n  ) {\n    super(tasks, streamTasks, reactiveTasks);\n  }\n}\n",
+    "/**\n * @license\n * Copyright 2025 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { AiProviderRegisterOptions } from \"@workglow/ai\";\nimport { AnthropicQueuedProvider } from \"./AnthropicQueuedProvider\";\n\nexport async function registerAnthropic(\n  options: AiProviderRegisterOptions & {\n    worker: Worker | (() => Worker);\n  }\n): Promise<void> {\n  await new AnthropicQueuedProvider().register(options);\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAMO,IAAM,YAAY;;ACAzB;AAIO,IAAM,uBAAuB;AAAA,EAClC,MAAM;AAAA,EACN,YAAY;AAAA,IACV,UAAU;AAAA,MACR,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,iBAAiB;AAAA,MACf,MAAM;AAAA,MACN,aAAa;AAAA,MACb,YAAY;AAAA,QACV,YAAY;AAAA,UACV,MAAM;AAAA,UACN,aACE;AAAA,QACJ;AAAA,QACA,gBAAgB;AAAA,UACd,MAAM;AAAA,UACN,QAAQ;AAAA,UACR,aAAa;AAAA,UACb,eAAe;AAAA,QACjB;AAAA,QACA,UAAU;AAAA,UACR,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,QACA,YAAY;AAAA,UACV,MAAM;AAAA,UACN,aAAa;AAAA,UACb,SAAS;AAAA,UACT,SAAS;AAAA,QACX;AAAA,MACF;AAAA,MACA,UAAU,CAAC,YAAY;AAAA,MACvB,sBAAsB;AAAA,IACxB;AAAA,EACF;AAAA,EACA,UAAU,CAAC,YAAY,iBAAiB;AAAA,EACxC,sBAAsB;AACxB;AAEO,IAAM,6BAA6B;AAAA,EACxC,MAAM;AAAA,EACN,YAAY;AAAA,OACP,kBAAkB;AAAA,OAClB,qBAAqB;AAAA,EAC1B;AAAA,EACA,UAAU,CAAC,GAAG,kBAAkB,UAAU,GAAG,qBAAqB,QAAQ;AAAA,EAC1E,sBAAsB;AACxB;AAIO,IAAM,6BAA6B;AAAA,EACxC,MAAM;AAAA,EACN,YAAY;AAAA,OACP,kBAAkB;AAAA,OAClB,qBAAqB;AAAA,EAC1B;AAAA,EACA,UAAU,CAAC,GAAG,kBAAkB,UAAU,GAAG,qBAAqB,QAAQ;AAAA,EAC1E,sBAAsB;AACxB;;ACjEA;AAAA;AAAA;AAUO,MAAM,gCAAgC,iBAAuC;AAAA,EACzE,OAAO;AAAA,EACP,UAAU;AAAA,EACV,kBAAkB;AAAA,EAElB,YAAY;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EAEA,WAAW,CACT,OACA,aACA,eACA;AAAA,IACA,MAAM,OAAO,aAAa,aAAa;AAAA;AAE3C;;;AC9BA,eAAsB,iBAAiB,CACrC,SAGe;AAAA,EACf,MAAM,IAAI,wBAAwB,EAAE,SAAS,OAAO;AAAA;",
+  "debugId": "82AE50C439DDA50864756E2164756E21",
+  "names": []
+}

package/dist/provider-anthropic/registerAnthropic.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRegisterOptions } from "@workglow/ai";
+export declare function registerAnthropic(options: AiProviderRegisterOptions & {
+    worker: Worker | (() => Worker);
+}): Promise<void>;
+//# sourceMappingURL=registerAnthropic.d.ts.map

package/dist/provider-anthropic/registerAnthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerAnthropic.d.ts","sourceRoot":"","sources":["../../src/provider-anthropic/registerAnthropic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAG9D,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,yBAAyB,GAAG;IACnC,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;CACjC,GACA,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/provider-anthropic/registerAnthropicInline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRegisterOptions } from "@workglow/ai";
+export declare function registerAnthropicInline(options?: AiProviderRegisterOptions): Promise<void>;
+//# sourceMappingURL=registerAnthropicInline.d.ts.map

package/dist/provider-anthropic/registerAnthropicInline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerAnthropicInline.d.ts","sourceRoot":"","sources":["../../src/provider-anthropic/registerAnthropicInline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAQ9D,wBAAsB,uBAAuB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhG"}

package/dist/provider-anthropic/registerAnthropicWorker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function registerAnthropicWorker(): Promise<void>;
+//# sourceMappingURL=registerAnthropicWorker.d.ts.map

package/dist/provider-anthropic/registerAnthropicWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerAnthropicWorker.d.ts","sourceRoot":"","sources":["../../src/provider-anthropic/registerAnthropicWorker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAS7D"}

package/dist/provider-anthropic/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Worker server and main-thread inline Anthropic registration (pulls in `Anthropic_JobRunFns`),
+ * plus SDK client helpers (`Anthropic_Client`).
+ * Import from `@workglow/ai-provider/anthropic/runtime` — not from the main `anthropic` barrel.
+ *
+ * Use `export *` (not `export { … } from "…"`) so the Bun bundler keeps the module graph.
+ */
+export * from "./common/Anthropic_Client";
+export * from "./registerAnthropicInline";
+export * from "./registerAnthropicWorker";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/provider-anthropic/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/provider-anthropic/runtime.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC"}

package/dist/{anthropic/index.js → provider-anthropic/runtime.js}

@@ -1,20 +1,27 @@
-import {
-  ANTHROPIC,
-  AnthropicModelConfigSchema,
-  AnthropicModelRecordSchema,
-  AnthropicModelSchema,
-  AnthropicProvider
-} from "../index-60ev6k93.js";
-import {
-  __require
-} from "../index-6j5pq722.js";
-
-// src/anthropic/Anthropic_Worker.ts
-import { getLogger as getLogger2, globalServiceRegistry, WORKER_SERVER } from "@workglow/util";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+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/anthropic/common/Anthropic_JobRunFns.ts
-import { buildToolDescription, filterValidToolCalls } from "@workglow/ai";
-import { getLogger, parsePartialJson } from "@workglow/util";
+// src/provider-anthropic/common/Anthropic_Client.ts
 var _sdk;
 async function loadAnthropicSDK() {
   if (!_sdk) {
@@ -49,9 +56,160 @@ function getModelName(model) {
 function getMaxTokens(input, model) {
   return input.maxTokens ?? model?.provider_config?.max_tokens ?? 1024;
 }
+// src/provider-anthropic/common/Anthropic_Constants.ts
+var ANTHROPIC = "ANTHROPIC";
+
+// src/provider-anthropic/common/Anthropic_ModelSearch.ts
+var ANTHROPIC_FALLBACK = [
+  { label: "claude-opus-4-20250514", value: "claude-opus-4-20250514" },
+  { label: "claude-sonnet-4-20250514", value: "claude-sonnet-4-20250514" },
+  { label: "claude-haiku-4-5-20251001", value: "claude-haiku-4-5-20251001" },
+  { 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() {
+  const Anthropic = await loadAnthropicSDK();
+  const client = new Anthropic;
+  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 () => {
+  let models;
+  try {
+    models = await listAnthropicModels();
+  } catch {
+    models = ANTHROPIC_FALLBACK;
+  }
+  return { results: mapModelList(models) };
+};
+
+// src/provider-anthropic/common/Anthropic_CountTokens.ts
+import { getLogger } from "@workglow/util/worker";
+var Anthropic_CountTokens = async (input, model, onProgress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger().warn("Anthropic_CountTokens: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const counts = [];
+    for (const item of texts) {
+      const r = await Anthropic_CountTokens({ ...input, text: item }, model, onProgress, signal);
+      counts.push(r.count);
+    }
+    return { count: counts };
+  }
+  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_Reactive = async (input, _output, _model) => {
+  if (Array.isArray(input.text)) {
+    return { count: input.text.map((t) => Math.ceil(t.length / 4)) };
+  }
+  return { count: Math.ceil(input.text.length / 4) };
+};
+
+// src/provider-anthropic/common/Anthropic_ModelInfo.ts
+var Anthropic_ModelInfo = async (input) => {
+  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/provider-anthropic/common/Anthropic_StructuredGeneration.ts
+import { parsePartialJson } 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 = parsePartialJson(accumulatedJson);
+      if (partial !== undefined) {
+        yield { type: "object-delta", port: "object", objectDelta: partial };
+      }
+    }
+  }
+  let finalObject;
+  try {
+    finalObject = JSON.parse(accumulatedJson);
+  } catch {
+    finalObject = parsePartialJson(accumulatedJson) ?? {};
+  }
+  yield { type: "finish", data: { object: finalObject } };
+};
+
+// src/provider-anthropic/common/Anthropic_TextGeneration.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
 var Anthropic_TextGeneration = async (input, model, update_progress, signal) => {
   if (Array.isArray(input.prompt)) {
-    getLogger().warn("Anthropic_TextGeneration: array input received; processing sequentially (no native batch support)");
+    getLogger2().warn("Anthropic_TextGeneration: array input received; processing sequentially (no native batch support)");
     const prompts = input.prompt;
     const results = [];
     for (const item of prompts) {
@@ -60,7 +218,7 @@ var Anthropic_TextGeneration = async (input, model, update_progress, signal) =>
     }
     return { text: results };
   }
-  const logger = getLogger();
+  const logger = getLogger2();
   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");
@@ -78,9 +236,29 @@ var Anthropic_TextGeneration = async (input, model, update_progress, signal) =>
   logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
   return { text };
 };
+var Anthropic_TextGeneration_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const stream = client.messages.stream({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: getMaxTokens(input, model),
+    temperature: input.temperature,
+    top_p: input.topP
+  }, { 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/provider-anthropic/common/Anthropic_TextRewriter.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
 var Anthropic_TextRewriter = async (input, model, update_progress, signal) => {
   if (Array.isArray(input.text)) {
-    getLogger().warn("Anthropic_TextRewriter: array input received; processing sequentially (no native batch support)");
+    getLogger3().warn("Anthropic_TextRewriter: array input received; processing sequentially (no native batch support)");
     const texts = input.text;
     const results = [];
     for (const item of texts) {
@@ -102,9 +280,28 @@ var Anthropic_TextRewriter = async (input, model, update_progress, signal) => {
   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/provider-anthropic/common/Anthropic_TextSummary.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
 var Anthropic_TextSummary = async (input, model, update_progress, signal) => {
   if (Array.isArray(input.text)) {
-    getLogger().warn("Anthropic_TextSummary: array input received; processing sequentially (no native batch support)");
+    getLogger4().warn("Anthropic_TextSummary: array input received; processing sequentially (no native batch support)");
     const texts = input.text;
     const results = [];
     for (const item of texts) {
@@ -126,39 +323,6 @@ var Anthropic_TextSummary = async (input, model, update_progress, signal) => {
   update_progress(100, "Completed Anthropic text summarization");
   return { text };
 };
-var Anthropic_TextGeneration_Stream = async function* (input, model, signal) {
-  const client = await getClient(model);
-  const modelName = getModelName(model);
-  const stream = client.messages.stream({
-    model: modelName,
-    messages: [{ role: "user", content: input.prompt }],
-    max_tokens: getMaxTokens(input, model),
-    temperature: input.temperature,
-    top_p: input.topP
-  }, { 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: {} };
-};
-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: {} };
-};
 var Anthropic_TextSummary_Stream = async function* (input, model, signal) {
   const client = await getClient(model);
   const modelName = getModelName(model);
@@ -175,88 +339,10 @@ var Anthropic_TextSummary_Stream = async function* (input, model, signal) {
   }
   yield { type: "finish", data: {} };
 };
-var Anthropic_CountTokens = async (input, model, onProgress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().warn("Anthropic_CountTokens: array input received; processing sequentially (no native batch support)");
-    const texts = input.text;
-    const counts = [];
-    for (const item of texts) {
-      const r = await Anthropic_CountTokens({ ...input, text: item }, model, onProgress, signal);
-      counts.push(r.count);
-    }
-    return { count: counts };
-  }
-  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_Reactive = async (input, _output, _model) => {
-  if (Array.isArray(input.text)) {
-    return { count: input.text.map((t) => Math.ceil(t.length / 4)) };
-  }
-  return { count: Math.ceil(input.text.length / 4) };
-};
-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 = parsePartialJson(accumulatedJson);
-      if (partial !== undefined) {
-        yield { type: "object-delta", port: "object", objectDelta: partial };
-      }
-    }
-  }
-  let finalObject;
-  try {
-    finalObject = JSON.parse(accumulatedJson);
-  } catch {
-    finalObject = parsePartialJson(accumulatedJson) ?? {};
-  }
-  yield { type: "finish", data: { object: finalObject } };
-};
+
+// src/provider-anthropic/common/Anthropic_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls } from "@workglow/ai/worker";
+import { getLogger as getLogger5, parsePartialJson as parsePartialJson2 } from "@workglow/util/worker";
 function mapUserContentToAnthropic(content) {
   if (typeof content === "string")
     return content;
@@ -343,7 +429,7 @@ function mapAnthropicToolChoice(toolChoice) {
 }
 var Anthropic_ToolCalling = async (input, model, update_progress, signal) => {
   if (Array.isArray(input.prompt)) {
-    getLogger().warn("Anthropic_ToolCalling: array input received; processing sequentially (no native batch support)");
+    getLogger5().warn("Anthropic_ToolCalling: array input received; processing sequentially (no native batch support)");
     const prompts = input.prompt;
     const texts = [];
     const toolCallsList = [];
@@ -445,7 +531,7 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal) {
           try {
             parsedInput = JSON.parse(meta.json);
           } catch {
-            const partial = parsePartialJson(meta.json);
+            const partial = parsePartialJson2(meta.json);
             parsedInput = partial ?? {};
           }
           toolCallMap.set(meta.id ?? "", {
@@ -464,7 +550,7 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal) {
         try {
           finalInput = JSON.parse(meta.json);
         } catch {
-          finalInput = parsePartialJson(meta.json) ?? {};
+          finalInput = parsePartialJson2(meta.json) ?? {};
         }
         const id = meta.id ?? "";
         toolCallMap.set(id, { id, name: meta.name ?? "", input: finalInput });
@@ -479,18 +565,8 @@ var Anthropic_ToolCalling_Stream = async function* (input, model, signal) {
     data: { text: accumulatedText, toolCalls: validToolCalls }
   };
 };
-var Anthropic_ModelInfo = async (input) => {
-  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/provider-anthropic/common/Anthropic_JobRunFns.ts
 var ANTHROPIC_TASKS = {
   CountTokensTask: Anthropic_CountTokens,
   ModelInfoTask: Anthropic_ModelInfo,
@@ -498,7 +574,8 @@ var ANTHROPIC_TASKS = {
   TextRewriterTask: Anthropic_TextRewriter,
   TextSummaryTask: Anthropic_TextSummary,
   StructuredGenerationTask: Anthropic_StructuredGeneration,
-  ToolCallingTask: Anthropic_ToolCalling
+  ToolCallingTask: Anthropic_ToolCalling,
+  ModelSearchTask: Anthropic_ModelSearch
 };
 var ANTHROPIC_STREAM_TASKS = {
   TextGenerationTask: Anthropic_TextGeneration_Stream,
@@ -511,36 +588,73 @@ var ANTHROPIC_REACTIVE_TASKS = {
   CountTokensTask: Anthropic_CountTokens_Reactive
 };
 
-// src/anthropic/Anthropic_Worker.ts
-function ANTHROPIC_WORKER_JOBRUN_REGISTER() {
+// src/provider-anthropic/AnthropicQueuedProvider.ts
+import {
+  QueuedAiProvider
+} from "@workglow/ai";
+class AnthropicQueuedProvider extends QueuedAiProvider {
+  name = ANTHROPIC;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-anthropic/registerAnthropicInline.ts
+async function registerAnthropicInline(options) {
+  await new AnthropicQueuedProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS, ANTHROPIC_REACTIVE_TASKS).register(options ?? {});
+}
+// src/provider-anthropic/registerAnthropicWorker.ts
+import { getLogger as getLogger6, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+
+// src/provider-anthropic/AnthropicProvider.ts
+import {
+  AiProvider
+} from "@workglow/ai/worker";
+class AnthropicProvider extends AiProvider {
+  name = ANTHROPIC;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-anthropic/registerAnthropicWorker.ts
+async function registerAnthropicWorker() {
   const workerServer = globalServiceRegistry.get(WORKER_SERVER);
   new AnthropicProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS, ANTHROPIC_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
   workerServer.sendReady();
-  getLogger2().info("ANTHROPIC_WORKER_JOBRUN registered");
+  getLogger6().info("Anthropic worker job run functions registered");
 }
 export {
-  Anthropic_ToolCalling_Stream,
-  Anthropic_ToolCalling,
-  Anthropic_TextSummary_Stream,
-  Anthropic_TextSummary,
-  Anthropic_TextRewriter_Stream,
-  Anthropic_TextRewriter,
-  Anthropic_TextGeneration_Stream,
-  Anthropic_TextGeneration,
-  Anthropic_StructuredGeneration_Stream,
-  Anthropic_StructuredGeneration,
-  Anthropic_ModelInfo,
-  Anthropic_CountTokens_Reactive,
-  Anthropic_CountTokens,
-  AnthropicProvider,
-  AnthropicModelSchema,
-  AnthropicModelRecordSchema,
-  AnthropicModelConfigSchema,
-  ANTHROPIC_WORKER_JOBRUN_REGISTER,
-  ANTHROPIC_TASKS,
-  ANTHROPIC_STREAM_TASKS,
-  ANTHROPIC_REACTIVE_TASKS,
-  ANTHROPIC
+  registerAnthropicWorker,
+  registerAnthropicInline,
+  loadAnthropicSDK,
+  getModelName,
+  getMaxTokens,
+  getClient
 };
 
-//# debugId=0C8D60DE747D87A364756E2164756E21
+//# debugId=0124710F9CE2927464756E2164756E21