@workglow/ai-provider 0.0.89 → 0.0.91

package/README.md

@@ -41,11 +41,16 @@ npm install @mediapipe/tasks-text @mediapipe/tasks-vision @mediapipe/tasks-audio
 ### 1. Basic Setup
 
 ```typescript
-import { register_HFT_InlineJobFns, register_TFMP_InlineJobFns } from "@workglow/ai-provider";
-
-// Register AI providers
-await register_HFT_InlineJobFns();
-await register_TFMP_InlineJobFns();
+import {
+  HFT_TASKS,
+  HuggingFaceTransformersProvider,
+  TFMP_TASKS,
+  TensorFlowMediaPipeProvider,
+} from "@workglow/ai-provider";
+
+// Register AI providers (inline mode requires task maps via constructor)
+await new HuggingFaceTransformersProvider(HFT_TASKS).register({ mode: "inline" });
+await new TensorFlowMediaPipeProvider(TFMP_TASKS).register({ mode: "inline" });
 ```
 
 ### 2. Using AI Tasks in Workflows
@@ -234,17 +239,22 @@ For better performance, especially in browser environments, run AI inference in
 #### Main Thread Setup
 
 ```typescript
-import { register_HFT_ClientJobFns, register_TFMP_ClientJobFns } from "@workglow/ai-provider";
-
-// Register HuggingFace Transformers with worker
-register_HFT_ClientJobFns(
-  new Worker(new URL("./hft-worker.ts", import.meta.url), { type: "module" })
-);
+import {
+  HuggingFaceTransformersProvider,
+  TensorFlowMediaPipeProvider,
+} from "@workglow/ai-provider";
+
+// Register HuggingFace Transformers with worker (no task map needed on main thread)
+await new HuggingFaceTransformersProvider().register({
+  mode: "worker",
+  worker: new Worker(new URL("./hft-worker.ts", import.meta.url), { type: "module" }),
+});
 
-// Register MediaPipe with worker
-register_TFMP_ClientJobFns(
-  new Worker(new URL("./tfmp-worker.ts", import.meta.url), { type: "module" })
-);
+// Register MediaPipe with worker (no task map needed on main thread)
+await new TensorFlowMediaPipeProvider().register({
+  mode: "worker",
+  worker: new Worker(new URL("./tfmp-worker.ts", import.meta.url), { type: "module" }),
+});
 ```
 
 #### Worker Setup Files
@@ -252,19 +262,19 @@ register_TFMP_ClientJobFns(
 **hft-worker.ts:**
 
 ```typescript
-import { register_HFT_WorkerJobFns } from "@workglow/ai-provider";
+import { HFT_WORKER_JOBRUN_REGISTER } from "@workglow/ai-provider";
 
 // Register HuggingFace Transformers worker functions
-register_HFT_WorkerJobFns();
+HFT_WORKER_JOBRUN_REGISTER();
 ```
 
 **tfmp-worker.ts:**
 
 ```typescript
-import { register_TFMP_WorkerJobFns } from "@workglow/ai-provider";
+import { TFMP_WORKER_JOBRUN_REGISTER } from "@workglow/ai-provider";
 
 // Register MediaPipe worker functions
-register_TFMP_WorkerJobFns();
+TFMP_WORKER_JOBRUN_REGISTER();
 ```
 
 ### Model Management
@@ -286,30 +296,20 @@ await downloadTask.execute();
 ### Custom Job Queue Configuration
 
 ```typescript
-import {
-  JobQueueClient,
-  JobQueueServer,
-  ConcurrencyLimiter,
-  DelayLimiter,
-} from "@workglow/job-queue";
-import { InMemoryQueueStorage } from "@workglow/storage";
-import { register_HFT_InlineJobFns, HF_TRANSFORMERS_ONNX } from "@workglow/ai-provider";
-
-// Configure queue with custom limits
-const customQueue = new JobQueueServer(HF_TRANSFORMERS_ONNX, AiJob, {
-  storage: new InMemoryQueueStorage(HF_TRANSFORMERS_ONNX),
-  queueName: HF_TRANSFORMERS_ONNX,
-  limiter: new ConcurrencyLimiter(2, 1000), // 2 concurrent jobs, 1000ms timeout
-});
+import { HFT_TASKS, HuggingFaceTransformersProvider } from "@workglow/ai-provider";
 
-const client = new JobQueueClient({
-  storage: new InMemoryQueueStorage(HF_TRANSFORMERS_ONNX),
-  queueName: HF_TRANSFORMERS_ONNX,
+// Register with custom queue concurrency (provider creates queue with concurrency: 2)
+await new HuggingFaceTransformersProvider(HFT_TASKS).register({
+  mode: "inline",
+  queue: { concurrency: 2 },
 });
 
-client.attach(customQueue);
-// Register AI providers
-await register_HFT_InlineJobFns(client);
+// Or skip auto-creation and use your own queue:
+await new HuggingFaceTransformersProvider(HFT_TASKS).register({
+  mode: "inline",
+  queue: { autoCreate: false },
+});
+// Then register your custom queue with getTaskQueueRegistry().registerQueue(...)
 ```
 
 ### Error Handling
@@ -352,13 +352,13 @@ await task.execute();
 ## Complete Working Example
 
 ```typescript
-import { HF_TRANSFORMERS_ONNX, register_HFT_InlineJobFns } from "@workglow/ai-provider";
-import { TextGenerationTask, TextEmbeddingTask, AiJob } from "@workglow/ai";
-import { Workflow, getTaskQueueRegistry } from "@workglow/task-graph";
+import { HFT_TASKS, HuggingFaceTransformersProvider } from "@workglow/ai-provider";
+import { TextGenerationTask, TextEmbeddingTask } from "@workglow/ai";
+import { Workflow } from "@workglow/task-graph";
 
 async function main() {
-  // 1. Register the AI provider
-  await register_HFT_InlineJobFns();
+  // 1. Register the AI provider (inline mode requires HFT_TASKS via constructor)
+  await new HuggingFaceTransformersProvider(HFT_TASKS).register({ mode: "inline" });
 
   // 2. Create and run workflow
   const workflow = new Workflow();

package/dist/anthropic/AnthropicProvider.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AiProvider, type AiProviderRunFn, type AiProviderStreamFn } from "@workglow/ai";
+import type { AnthropicModelConfig } from "./common/Anthropic_ModelSchema";
+/**
+ * AI provider for Anthropic cloud models.
+ *
+ * Supports text generation, text rewriting, and text summarization via the
+ * Anthropic Messages API using the `@anthropic-ai/sdk` SDK.
+ *
+ * Note: Anthropic does not offer an embeddings API, so TextEmbeddingTask
+ * is not supported by this provider.
+ *
+ * Task run functions are injected via the constructor so that the SDK
+ * is only imported where actually needed (inline mode, worker server), not on
+ * the main thread in worker mode.
+ *
+ * @example
+ * ```typescript
+ * // Worker mode (main thread) -- lightweight, no SDK import:
+ * await new AnthropicProvider().register({
+ *   mode: "worker",
+ *   worker: new Worker(new URL("./worker_anthropic.ts", import.meta.url), { type: "module" }),
+ * });
+ *
+ * // Inline mode -- caller provides the tasks:
+ * import { ANTHROPIC_TASKS } from "@workglow/ai-provider/anthropic";
+ * await new AnthropicProvider(ANTHROPIC_TASKS).register({ mode: "inline" });
+ * ```
+ */
+export declare class AnthropicProvider extends AiProvider<AnthropicModelConfig> {
+    readonly name = "ANTHROPIC";
+    readonly taskTypes: readonly ["TextGenerationTask", "TextRewriterTask", "TextSummaryTask"];
+    constructor(tasks?: Record<string, AiProviderRunFn<any, any, AnthropicModelConfig>>, streamTasks?: Record<string, AiProviderStreamFn<any, any, AnthropicModelConfig>>);
+}
+//# sourceMappingURL=AnthropicProvider.d.ts.map

package/dist/anthropic/AnthropicProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnthropicProvider.d.ts","sourceRoot":"","sources":["../../src/anthropic/AnthropicProvider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEzF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,iBAAkB,SAAQ,UAAU,CAAC,oBAAoB,CAAC;IACrE,QAAQ,CAAC,IAAI,eAAa;IAE1B,QAAQ,CAAC,SAAS,yEAA0E;gBAG1F,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,oBAAoB,CAAC,CAAC,EACvE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,oBAAoB,CAAC,CAAC;CAInF"}

package/dist/anthropic/Anthropic_Worker.d.ts

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

package/dist/anthropic/Anthropic_Worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Anthropic_Worker.d.ts","sourceRoot":"","sources":["../../src/anthropic/Anthropic_Worker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,wBAAgB,gCAAgC,SAO/C"}

package/dist/anthropic/common/Anthropic_Constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const ANTHROPIC = "ANTHROPIC";
+//# sourceMappingURL=Anthropic_Constants.d.ts.map

package/dist/anthropic/common/Anthropic_Constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Anthropic_Constants.d.ts","sourceRoot":"","sources":["../../../src/anthropic/common/Anthropic_Constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,SAAS,cAAc,CAAC"}

package/dist/anthropic/common/Anthropic_JobRunFns.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, TextGenerationTaskInput, TextGenerationTaskOutput, TextRewriterTaskInput, TextRewriterTaskOutput, TextSummaryTaskInput, TextSummaryTaskOutput } from "@workglow/ai";
+import type { AnthropicModelConfig } from "./Anthropic_ModelSchema";
+export declare const Anthropic_TextGeneration: AiProviderRunFn<TextGenerationTaskInput, TextGenerationTaskOutput, AnthropicModelConfig>;
+export declare const Anthropic_TextRewriter: AiProviderRunFn<TextRewriterTaskInput, TextRewriterTaskOutput, AnthropicModelConfig>;
+export declare const Anthropic_TextSummary: AiProviderRunFn<TextSummaryTaskInput, TextSummaryTaskOutput, AnthropicModelConfig>;
+export declare const Anthropic_TextGeneration_Stream: AiProviderStreamFn<TextGenerationTaskInput, TextGenerationTaskOutput, AnthropicModelConfig>;
+export declare const Anthropic_TextRewriter_Stream: AiProviderStreamFn<TextRewriterTaskInput, TextRewriterTaskOutput, AnthropicModelConfig>;
+export declare const Anthropic_TextSummary_Stream: AiProviderStreamFn<TextSummaryTaskInput, TextSummaryTaskOutput, AnthropicModelConfig>;
+export declare const ANTHROPIC_TASKS: Record<string, AiProviderRunFn<any, any, AnthropicModelConfig>>;
+export declare const ANTHROPIC_STREAM_TASKS: Record<string, AiProviderStreamFn<any, any, AnthropicModelConfig>>;
+//# sourceMappingURL=Anthropic_JobRunFns.d.ts.map

package/dist/anthropic/common/Anthropic_JobRunFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Anthropic_JobRunFns.d.ts","sourceRoot":"","sources":["../../../src/anthropic/common/Anthropic_JobRunFns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACxB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAgDpE,eAAO,MAAM,wBAAwB,EAAE,eAAe,CACpD,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,CAqBrB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAClD,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,CAoBrB,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAAe,CACjD,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,CAoBrB,CAAC;AAMF,eAAO,MAAM,+BAA+B,EAAE,kBAAkB,CAC9D,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,CAsBrB,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAC5D,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,CAqBrB,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,kBAAkB,CAC3D,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,CAqBrB,CAAC;AAMF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,oBAAoB,CAAC,CAI3F,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACzC,MAAM,EACN,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,oBAAoB,CAAC,CAKnD,CAAC"}

package/dist/anthropic/common/Anthropic_ModelSchema.d.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FromSchema } from "@workglow/util";
+export declare const AnthropicModelSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly provider: {
+            readonly const: "ANTHROPIC";
+            readonly description: "Discriminator: Anthropic cloud provider.";
+        };
+        readonly provider_config: {
+            readonly type: "object";
+            readonly description: "Anthropic-specific configuration.";
+            readonly properties: {
+                readonly model_name: {
+                    readonly type: "string";
+                    readonly description: "The Anthropic model identifier (e.g., 'claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022').";
+                };
+                readonly api_key: {
+                    readonly type: "string";
+                    readonly description: "Anthropic API key. Falls back to ANTHROPIC_API_KEY environment variable if not set.";
+                    readonly "x-ui-hidden": true;
+                };
+                readonly base_url: {
+                    readonly type: "string";
+                    readonly description: "Base URL for the Anthropic API (optional).";
+                };
+                readonly max_tokens: {
+                    readonly type: "integer";
+                    readonly description: "Default max tokens for responses. Anthropic requires this parameter.";
+                    readonly default: 1024;
+                    readonly minimum: 1;
+                };
+            };
+            readonly required: readonly ["model_name"];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly required: readonly ["provider", "provider_config"];
+    readonly additionalProperties: true;
+};
+export declare const AnthropicModelRecordSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly provider: {
+            readonly const: "ANTHROPIC";
+            readonly description: "Discriminator: Anthropic cloud provider.";
+        };
+        readonly provider_config: {
+            readonly type: "object";
+            readonly description: "Anthropic-specific configuration.";
+            readonly properties: {
+                readonly model_name: {
+                    readonly type: "string";
+                    readonly description: "The Anthropic model identifier (e.g., 'claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022').";
+                };
+                readonly api_key: {
+                    readonly type: "string";
+                    readonly description: "Anthropic API key. Falls back to ANTHROPIC_API_KEY environment variable if not set.";
+                    readonly "x-ui-hidden": true;
+                };
+                readonly base_url: {
+                    readonly type: "string";
+                    readonly description: "Base URL for the Anthropic API (optional).";
+                };
+                readonly max_tokens: {
+                    readonly type: "integer";
+                    readonly description: "Default max tokens for responses. Anthropic requires this parameter.";
+                    readonly default: 1024;
+                    readonly minimum: 1;
+                };
+            };
+            readonly required: readonly ["model_name"];
+            readonly additionalProperties: false;
+        };
+        readonly model_id: {
+            readonly type: "string";
+        };
+        readonly tasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly "x-ui-editor": "multiselect";
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly "x-ui-editor": "textarea";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly default: {};
+            readonly "x-ui-hidden": true;
+        };
+    };
+    readonly required: readonly ["model_id", "tasks", "provider", "title", "description", "provider_config", "metadata", "provider", "provider_config"];
+    readonly additionalProperties: false;
+};
+export type AnthropicModelRecord = FromSchema<typeof AnthropicModelRecordSchema>;
+export declare const AnthropicModelConfigSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly provider: {
+            readonly const: "ANTHROPIC";
+            readonly description: "Discriminator: Anthropic cloud provider.";
+        };
+        readonly provider_config: {
+            readonly type: "object";
+            readonly description: "Anthropic-specific configuration.";
+            readonly properties: {
+                readonly model_name: {
+                    readonly type: "string";
+                    readonly description: "The Anthropic model identifier (e.g., 'claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022').";
+                };
+                readonly api_key: {
+                    readonly type: "string";
+                    readonly description: "Anthropic API key. Falls back to ANTHROPIC_API_KEY environment variable if not set.";
+                    readonly "x-ui-hidden": true;
+                };
+                readonly base_url: {
+                    readonly type: "string";
+                    readonly description: "Base URL for the Anthropic API (optional).";
+                };
+                readonly max_tokens: {
+                    readonly type: "integer";
+                    readonly description: "Default max tokens for responses. Anthropic requires this parameter.";
+                    readonly default: 1024;
+                    readonly minimum: 1;
+                };
+            };
+            readonly required: readonly ["model_name"];
+            readonly additionalProperties: false;
+        };
+        readonly model_id: {
+            readonly type: "string";
+        };
+        readonly tasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly "x-ui-editor": "multiselect";
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly "x-ui-editor": "textarea";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly default: {};
+            readonly "x-ui-hidden": true;
+        };
+    };
+    readonly required: readonly ["provider", "provider_config", "provider", "provider_config"];
+    readonly additionalProperties: false;
+};
+export type AnthropicModelConfig = FromSchema<typeof AnthropicModelConfigSchema>;
+//# sourceMappingURL=Anthropic_ModelSchema.d.ts.map

package/dist/anthropic/common/Anthropic_ModelSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Anthropic_ModelSchema.d.ts","sourceRoot":"","sources":["../../../src/anthropic/common/Anthropic_ModelSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAwB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGlE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCQ,CAAC;AAE1C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQE,CAAC;AAE1C,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEjF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQE,CAAC;AAE1C,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/anthropic/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Anthropic_Worker";
+export * from "./AnthropicProvider";
+export * from "./common/Anthropic_Constants";
+export * from "./common/Anthropic_JobRunFns";
+export * from "./common/Anthropic_ModelSchema";
+//# sourceMappingURL=index.d.ts.map

package/dist/anthropic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/anthropic/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}

package/dist/anthropic/index.js

@@ -0,0 +1,257 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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/Anthropic_Worker.ts
+import { globalServiceRegistry, parentPort, WORKER_SERVER } from "@workglow/util";
+
+// src/anthropic/AnthropicProvider.ts
+import { AiProvider } from "@workglow/ai";
+
+// src/anthropic/common/Anthropic_Constants.ts
+var ANTHROPIC = "ANTHROPIC";
+
+// src/anthropic/AnthropicProvider.ts
+class AnthropicProvider extends AiProvider {
+  name = ANTHROPIC;
+  taskTypes = ["TextGenerationTask", "TextRewriterTask", "TextSummaryTask"];
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
+  }
+}
+
+// src/anthropic/common/Anthropic_JobRunFns.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 apiKey = model?.provider_config?.api_key || (typeof process !== "undefined" ? process.env?.ANTHROPIC_API_KEY : undefined);
+  if (!apiKey) {
+    throw new Error("Missing Anthropic API key: set provider_config.api_key or the ANTHROPIC_API_KEY environment variable.");
+  }
+  return new Anthropic({
+    apiKey,
+    baseURL: model?.provider_config?.base_url || undefined,
+    dangerouslyAllowBrowser: true
+  });
+}
+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;
+}
+var Anthropic_TextGeneration = async (input, model, update_progress, signal) => {
+  update_progress(0, "Starting Anthropic text generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.messages.create({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: getMaxTokens(input, model),
+    temperature: input.temperature,
+    top_p: input.topP
+  }, { signal });
+  const text = response.content[0]?.type === "text" ? response.content[0].text : "";
+  update_progress(100, "Completed Anthropic text generation");
+  return { text };
+};
+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_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_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", 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", 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);
+  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", textDelta: event.delta.text };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+var ANTHROPIC_TASKS = {
+  TextGenerationTask: Anthropic_TextGeneration,
+  TextRewriterTask: Anthropic_TextRewriter,
+  TextSummaryTask: Anthropic_TextSummary
+};
+var ANTHROPIC_STREAM_TASKS = {
+  TextGenerationTask: Anthropic_TextGeneration_Stream,
+  TextRewriterTask: Anthropic_TextRewriter_Stream,
+  TextSummaryTask: Anthropic_TextSummary_Stream
+};
+
+// src/anthropic/Anthropic_Worker.ts
+function ANTHROPIC_WORKER_JOBRUN_REGISTER() {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new AnthropicProvider(ANTHROPIC_TASKS, ANTHROPIC_STREAM_TASKS).registerOnWorkerServer(workerServer);
+  parentPort.postMessage({ type: "ready" });
+  console.log("ANTHROPIC_WORKER_JOBRUN registered");
+}
+// src/anthropic/common/Anthropic_ModelSchema.ts
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai";
+var AnthropicModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: ANTHROPIC,
+      description: "Discriminator: Anthropic cloud provider."
+    },
+    provider_config: {
+      type: "object",
+      description: "Anthropic-specific configuration.",
+      properties: {
+        model_name: {
+          type: "string",
+          description: "The Anthropic model identifier (e.g., 'claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022')."
+        },
+        api_key: {
+          type: "string",
+          description: "Anthropic API key. Falls back to ANTHROPIC_API_KEY environment variable if not set.",
+          "x-ui-hidden": true
+        },
+        base_url: {
+          type: "string",
+          description: "Base URL for the Anthropic API (optional)."
+        },
+        max_tokens: {
+          type: "integer",
+          description: "Default max tokens for responses. Anthropic requires this parameter.",
+          default: 1024,
+          minimum: 1
+        }
+      },
+      required: ["model_name"],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var AnthropicModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...AnthropicModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...AnthropicModelSchema.required],
+  additionalProperties: false
+};
+var AnthropicModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...AnthropicModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...AnthropicModelSchema.required],
+  additionalProperties: false
+};
+export {
+  Anthropic_TextSummary_Stream,
+  Anthropic_TextSummary,
+  Anthropic_TextRewriter_Stream,
+  Anthropic_TextRewriter,
+  Anthropic_TextGeneration_Stream,
+  Anthropic_TextGeneration,
+  AnthropicProvider,
+  AnthropicModelSchema,
+  AnthropicModelRecordSchema,
+  AnthropicModelConfigSchema,
+  ANTHROPIC_WORKER_JOBRUN_REGISTER,
+  ANTHROPIC_TASKS,
+  ANTHROPIC_STREAM_TASKS,
+  ANTHROPIC
+};
+
+//# debugId=EC2382865C58E15164756E2164756E21