@wellze/integration-ai 0.0.0

package/dist/generate.d.mts

@@ -0,0 +1,190 @@
+import { z } from "zod";
+import * as _wellze_workflow_core0 from "@wellze/workflow-core";
+
+//#region src/generate.d.ts
+declare const generateTextOpenAI: _wellze_workflow_core0.StepWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>, generateTextOpenAITool: _wellze_workflow_core0.ToolWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, readonly [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>;
+declare const generateTextAnthropic: _wellze_workflow_core0.StepWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>, generateTextAnthropicTool: _wellze_workflow_core0.ToolWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, readonly [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>;
+declare const generateObjectOpenAI: _wellze_workflow_core0.StepWithMetadata<{
+    prompt: string;
+    schema: Record<string, unknown>;
+    model?: string | undefined;
+    system?: string | undefined;
+    schemaName?: string | undefined;
+    schemaDescription?: string | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+  }, {
+    object: Record<string, unknown>;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>, generateObjectOpenAITool: _wellze_workflow_core0.ToolWithMetadata<{
+    prompt: string;
+    schema: Record<string, unknown>;
+    model?: string | undefined;
+    system?: string | undefined;
+    schemaName?: string | undefined;
+    schemaDescription?: string | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+  }, {
+    object: Record<string, unknown>;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, readonly [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>;
+declare const generateObjectAnthropic: _wellze_workflow_core0.StepWithMetadata<{
+    prompt: string;
+    schema: Record<string, unknown>;
+    model?: string | undefined;
+    system?: string | undefined;
+    schemaName?: string | undefined;
+    schemaDescription?: string | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+  }, {
+    object: Record<string, unknown>;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>, generateObjectAnthropicTool: _wellze_workflow_core0.ToolWithMetadata<{
+    prompt: string;
+    schema: Record<string, unknown>;
+    model?: string | undefined;
+    system?: string | undefined;
+    schemaName?: string | undefined;
+    schemaDescription?: string | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+  }, {
+    object: Record<string, unknown>;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, readonly [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>;
+//#endregion
+export { generateObjectAnthropic, generateObjectAnthropicTool, generateObjectOpenAI, generateObjectOpenAITool, generateTextAnthropic, generateTextAnthropicTool, generateTextOpenAI, generateTextOpenAITool };

package/dist/generate.mjs

@@ -0,0 +1,172 @@
+import { a as generateTextResponseSchema, d as defineAIOperation, f as createAnthropicProvider, l as anthropic, p as createOpenAIProvider, t as aiMessageSchema, u as openai } from "./schemas-Dd9H2hSI.mjs";
+import { generateObject, generateText } from "ai";
+import { z } from "zod";
+
+//#region src/generate.ts
+/**
+* ai/generate.ts
+*
+* Steps for text generation and structured object generation using the AI SDK.
+*
+* Provides steps for both OpenAI and Anthropic providers. Each step wraps
+* the AI SDK's `generateText` function with type-safe credential injection.
+*/
+/** Map AI SDK usage to our schema shape. */
+function mapUsage(usage) {
+	const input = usage.inputTokens ?? 0;
+	const output = usage.outputTokens ?? 0;
+	return {
+		promptTokens: input,
+		completionTokens: output,
+		totalTokens: input + output
+	};
+}
+const { step: generateTextOpenAI, tool: generateTextOpenAITool } = defineAIOperation({
+	name: "Generate Text (OpenAI)",
+	description: "Generate text using an OpenAI model via the AI SDK",
+	integration: openai,
+	input: z.object({
+		model: z.string().optional(),
+		system: z.string().optional(),
+		prompt: z.string().optional(),
+		messages: z.array(aiMessageSchema).optional(),
+		maxOutputTokens: z.number().optional(),
+		temperature: z.number().optional(),
+		topP: z.number().optional(),
+		stopSequences: z.array(z.string()).optional()
+	}),
+	output: generateTextResponseSchema,
+	run: async (input, credentials) => {
+		const result = await generateText({
+			model: createOpenAIProvider(credentials)(input.model ?? "gpt-4o"),
+			system: input.system,
+			...input.messages ? { messages: input.messages } : { prompt: input.prompt ?? "" },
+			maxOutputTokens: input.maxOutputTokens,
+			temperature: input.temperature,
+			topP: input.topP,
+			stopSequences: input.stopSequences
+		});
+		return {
+			text: result.text,
+			finishReason: result.finishReason,
+			usage: mapUsage(result.usage)
+		};
+	}
+});
+const { step: generateTextAnthropic, tool: generateTextAnthropicTool } = defineAIOperation({
+	name: "Generate Text (Anthropic)",
+	description: "Generate text using an Anthropic Claude model via the AI SDK",
+	integration: anthropic,
+	input: z.object({
+		model: z.string().optional(),
+		system: z.string().optional(),
+		prompt: z.string().optional(),
+		messages: z.array(aiMessageSchema).optional(),
+		maxOutputTokens: z.number().optional(),
+		temperature: z.number().optional(),
+		topP: z.number().optional(),
+		stopSequences: z.array(z.string()).optional()
+	}),
+	output: generateTextResponseSchema,
+	run: async (input, credentials) => {
+		const result = await generateText({
+			model: createAnthropicProvider(credentials)(input.model ?? "claude-sonnet-4-20250514"),
+			system: input.system,
+			...input.messages ? { messages: input.messages } : { prompt: input.prompt ?? "" },
+			maxOutputTokens: input.maxOutputTokens ?? 4096,
+			temperature: input.temperature,
+			topP: input.topP,
+			stopSequences: input.stopSequences
+		});
+		return {
+			text: result.text,
+			finishReason: result.finishReason,
+			usage: mapUsage(result.usage)
+		};
+	}
+});
+const { step: generateObjectOpenAI, tool: generateObjectOpenAITool } = defineAIOperation({
+	name: "Generate Object (OpenAI)",
+	description: "Generate a structured JSON object using an OpenAI model via the AI SDK",
+	integration: openai,
+	input: z.object({
+		model: z.string().optional(),
+		system: z.string().optional(),
+		prompt: z.string(),
+		schema: z.record(z.string(), z.unknown()),
+		schemaName: z.string().optional(),
+		schemaDescription: z.string().optional(),
+		maxOutputTokens: z.number().optional(),
+		temperature: z.number().optional()
+	}),
+	output: z.object({
+		object: z.record(z.string(), z.unknown()),
+		finishReason: z.string(),
+		usage: z.object({
+			promptTokens: z.number(),
+			completionTokens: z.number(),
+			totalTokens: z.number()
+		})
+	}),
+	run: async (input, credentials) => {
+		const result = await generateObject({
+			model: createOpenAIProvider(credentials)(input.model ?? "gpt-4o"),
+			system: input.system,
+			prompt: input.prompt,
+			schema: z.object(Object.fromEntries(Object.entries(input.schema).map(([key]) => [key, z.unknown()]))),
+			schemaName: input.schemaName,
+			schemaDescription: input.schemaDescription,
+			maxOutputTokens: input.maxOutputTokens,
+			temperature: input.temperature
+		});
+		return {
+			object: result.object,
+			finishReason: result.finishReason,
+			usage: mapUsage(result.usage)
+		};
+	}
+});
+const { step: generateObjectAnthropic, tool: generateObjectAnthropicTool } = defineAIOperation({
+	name: "Generate Object (Anthropic)",
+	description: "Generate a structured JSON object using an Anthropic model via the AI SDK",
+	integration: anthropic,
+	input: z.object({
+		model: z.string().optional(),
+		system: z.string().optional(),
+		prompt: z.string(),
+		schema: z.record(z.string(), z.unknown()),
+		schemaName: z.string().optional(),
+		schemaDescription: z.string().optional(),
+		maxOutputTokens: z.number().optional(),
+		temperature: z.number().optional()
+	}),
+	output: z.object({
+		object: z.record(z.string(), z.unknown()),
+		finishReason: z.string(),
+		usage: z.object({
+			promptTokens: z.number(),
+			completionTokens: z.number(),
+			totalTokens: z.number()
+		})
+	}),
+	run: async (input, credentials) => {
+		const result = await generateObject({
+			model: createAnthropicProvider(credentials)(input.model ?? "claude-sonnet-4-20250514"),
+			system: input.system,
+			prompt: input.prompt,
+			schema: z.object(Object.fromEntries(Object.entries(input.schema).map(([key]) => [key, z.unknown()]))),
+			schemaName: input.schemaName,
+			schemaDescription: input.schemaDescription,
+			maxOutputTokens: input.maxOutputTokens ?? 4096,
+			temperature: input.temperature
+		});
+		return {
+			object: result.object,
+			finishReason: result.finishReason,
+			usage: mapUsage(result.usage)
+		};
+	}
+});
+
+//#endregion
+export { generateObjectAnthropic, generateObjectAnthropicTool, generateObjectOpenAI, generateObjectOpenAITool, generateTextAnthropic, generateTextAnthropicTool, generateTextOpenAI, generateTextOpenAITool };

package/dist/index.d.mts

@@ -0,0 +1,140 @@
+import { generateObjectAnthropic, generateObjectAnthropicTool, generateObjectOpenAI, generateObjectOpenAITool, generateTextAnthropic, generateTextAnthropicTool, generateTextOpenAI, generateTextOpenAITool } from "./generate.mjs";
+import { streamTextAnthropic, streamTextAnthropicTool, streamTextOpenAI, streamTextOpenAITool } from "./stream.mjs";
+import * as _ai_sdk_anthropic0 from "@ai-sdk/anthropic";
+import * as _ai_sdk_openai0 from "@ai-sdk/openai";
+import { z } from "zod";
+import * as _wellze_workflow_core0 from "@wellze/workflow-core";
+import { CredentialsOf } from "@wellze/workflow-core";
+
+//#region src/integration.d.ts
+/**
+ * OpenAI integration — passthrough auth via API key.
+ */
+declare const openai: _wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+  OPENAI_API_KEY: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * Anthropic integration — passthrough auth via API key.
+ */
+declare const anthropic: _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+  ANTHROPIC_API_KEY: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * Credentials injected into steps after resolution.
+ *
+ * Derived from the integration definitions — not hardcoded. If the integration
+ * auth output schemas change, these types update automatically.
+ */
+type OpenAICredentials = CredentialsOf<typeof openai>;
+type AnthropicCredentials = CredentialsOf<typeof anthropic>;
+//#endregion
+//#region src/client.d.ts
+/**
+ * Create an OpenAI provider from resolved credentials.
+ *
+ * @param credentials - Resolved credentials containing the API key
+ * @returns A configured `@ai-sdk/openai` provider instance
+ */
+declare function createOpenAIProvider(credentials: OpenAICredentials): _ai_sdk_openai0.OpenAIProvider;
+/**
+ * Create an Anthropic provider from resolved credentials.
+ *
+ * @param credentials - Resolved credentials containing the API key
+ * @returns A configured `@ai-sdk/anthropic` provider instance
+ */
+declare function createAnthropicProvider(credentials: AnthropicCredentials): _ai_sdk_anthropic0.AnthropicProvider;
+/**
+ * Types of the configured provider instances.
+ */
+type OpenAIProvider = ReturnType<typeof createOpenAIProvider>;
+type AnthropicProvider = ReturnType<typeof createAnthropicProvider>;
+//#endregion
+//#region src/schemas.d.ts
+/**
+ * Token usage information returned by the AI SDK.
+ */
+declare const tokenUsageSchema: z.ZodObject<{
+  promptTokens: z.ZodNumber;
+  completionTokens: z.ZodNumber;
+  totalTokens: z.ZodNumber;
+}, z.core.$strip>;
+type TokenUsage = z.infer<typeof tokenUsageSchema>;
+/**
+ * Schema for generateText response.
+ */
+declare const generateTextResponseSchema: z.ZodObject<{
+  text: z.ZodString;
+  finishReason: z.ZodString;
+  usage: z.ZodObject<{
+    promptTokens: z.ZodNumber;
+    completionTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type GenerateTextResponse = z.infer<typeof generateTextResponseSchema>;
+/**
+ * Schema factory for generateObject responses.
+ * The object shape is determined by the caller's schema.
+ */
+declare function generateObjectResponseSchema<T extends z.ZodTypeAny>(objectSchema: T): z.ZodObject<{
+  object: T;
+  finishReason: z.ZodString;
+  usage: z.ZodObject<{
+    promptTokens: z.ZodNumber;
+    completionTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Schema for streamText collected response (after stream completes).
+ */
+declare const streamTextResponseSchema: z.ZodObject<{
+  text: z.ZodString;
+  finishReason: z.ZodString;
+  usage: z.ZodObject<{
+    promptTokens: z.ZodNumber;
+    completionTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type StreamTextResponse = z.infer<typeof streamTextResponseSchema>;
+/**
+ * Supported provider names.
+ */
+declare const aiProviderName: z.ZodEnum<{
+  openai: "openai";
+  anthropic: "anthropic";
+}>;
+type AIProviderName = z.infer<typeof aiProviderName>;
+/**
+ * Common model identifiers for convenience.
+ */
+declare const openaiModels: z.ZodEnum<{
+  "gpt-4-turbo": "gpt-4-turbo";
+  "gpt-4o-mini": "gpt-4o-mini";
+  "gpt-4o": "gpt-4o";
+  o1: "o1";
+  "o3-mini": "o3-mini";
+  "o1-mini": "o1-mini";
+}>;
+type OpenAIModel = z.infer<typeof openaiModels>;
+declare const anthropicModels: z.ZodEnum<{
+  "claude-opus-4-5-20251101": "claude-opus-4-5-20251101";
+  "claude-sonnet-4-20250514": "claude-sonnet-4-20250514";
+  "claude-haiku-3-5-20241022": "claude-haiku-3-5-20241022";
+}>;
+type AnthropicModel = z.infer<typeof anthropicModels>;
+/**
+ * Schema for a message in a conversation.
+ */
+declare const aiMessageSchema: z.ZodObject<{
+  role: z.ZodEnum<{
+    system: "system";
+    user: "user";
+    assistant: "assistant";
+  }>;
+  content: z.ZodString;
+}, z.core.$strip>;
+type AIMessage = z.infer<typeof aiMessageSchema>;
+//#endregion
+export { type AIMessage, type AIProviderName, type AnthropicCredentials, type AnthropicModel, type AnthropicProvider, type GenerateTextResponse, type OpenAICredentials, type OpenAIModel, type OpenAIProvider, type StreamTextResponse, type TokenUsage, aiMessageSchema, aiProviderName, anthropic, anthropicModels, createAnthropicProvider, createOpenAIProvider, generateObjectAnthropic, generateObjectAnthropicTool, generateObjectOpenAI, generateObjectOpenAITool, generateObjectResponseSchema, generateTextAnthropic, generateTextAnthropicTool, generateTextOpenAI, generateTextOpenAITool, generateTextResponseSchema, openai, openaiModels, streamTextAnthropic, streamTextAnthropicTool, streamTextOpenAI, streamTextOpenAITool, streamTextResponseSchema, tokenUsageSchema };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { a as generateTextResponseSchema, c as tokenUsageSchema, f as createAnthropicProvider, i as generateObjectResponseSchema, l as anthropic, n as aiProviderName, o as openaiModels, p as createOpenAIProvider, r as anthropicModels, s as streamTextResponseSchema, t as aiMessageSchema, u as openai } from "./schemas-Dd9H2hSI.mjs";
+import { generateObjectAnthropic, generateObjectAnthropicTool, generateObjectOpenAI, generateObjectOpenAITool, generateTextAnthropic, generateTextAnthropicTool, generateTextOpenAI, generateTextOpenAITool } from "./generate.mjs";
+import { streamTextAnthropic, streamTextAnthropicTool, streamTextOpenAI, streamTextOpenAITool } from "./stream.mjs";
+
+export { aiMessageSchema, aiProviderName, anthropic, anthropicModels, createAnthropicProvider, createOpenAIProvider, generateObjectAnthropic, generateObjectAnthropicTool, generateObjectOpenAI, generateObjectOpenAITool, generateObjectResponseSchema, generateTextAnthropic, generateTextAnthropicTool, generateTextOpenAI, generateTextOpenAITool, generateTextResponseSchema, openai, openaiModels, streamTextAnthropic, streamTextAnthropicTool, streamTextOpenAI, streamTextOpenAITool, streamTextResponseSchema, tokenUsageSchema };

package/dist/schemas-Dd9H2hSI.mjs

@@ -0,0 +1,187 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { z } from "zod";
+import { defineIntegration, defineStep } from "@wellze/workflow-core";
+import { defineTool } from "@wellze/workflow-core/agent/tool";
+
+//#region src/client.ts
+/**
+* ai/client.ts
+*
+* Provider factory functions that create AI SDK provider instances
+* from resolved credentials.
+*
+* Keeps SDK instantiation in one place so steps don't need to import
+* provider packages directly.
+*/
+/**
+* Create an OpenAI provider from resolved credentials.
+*
+* @param credentials - Resolved credentials containing the API key
+* @returns A configured `@ai-sdk/openai` provider instance
+*/
+function createOpenAIProvider(credentials) {
+	return createOpenAI({ apiKey: credentials.OPENAI_API_KEY });
+}
+/**
+* Create an Anthropic provider from resolved credentials.
+*
+* @param credentials - Resolved credentials containing the API key
+* @returns A configured `@ai-sdk/anthropic` provider instance
+*/
+function createAnthropicProvider(credentials) {
+	return createAnthropic({ apiKey: credentials.ANTHROPIC_API_KEY });
+}
+
+//#endregion
+//#region src/factory.ts
+/**
+* Factory function that creates both a step and a tool from a single definition.
+* Accepts an integration parameter to support both OpenAI and Anthropic.
+* Produces scope-agnostic bindings (no scope set at factory level).
+*/
+function defineAIOperation(config) {
+	const { name, description, integration, input, output, run, needsApproval } = config;
+	const binding = { integration };
+	return {
+		step: defineStep({
+			name,
+			description,
+			integrations: [binding],
+			input,
+			output,
+			run: async (input, credentials) => {
+				return run(input, credentials);
+			}
+		}),
+		tool: defineTool({
+			name,
+			description,
+			integrations: [binding],
+			input,
+			output,
+			needsApproval,
+			run: async (input, credentials) => {
+				return run(input, credentials);
+			}
+		})
+	};
+}
+
+//#endregion
+//#region src/integration.ts
+/**
+* ai/integration.ts
+*
+* AI provider integration definitions — passthrough auth via API keys.
+*
+* Defines separate integrations for each supported LLM provider.
+* Credentials are API keys that get injected into steps for
+* provider instantiation.
+*/
+/**
+* OpenAI integration — passthrough auth via API key.
+*/
+const openai = defineIntegration({
+	name: "openai",
+	namespace: "wellze",
+	description: "OpenAI — GPT models for text generation, structured output, and streaming",
+	auth: {
+		credentials: z.object({ OPENAI_API_KEY: z.string() }),
+		output: z.object({ OPENAI_API_KEY: z.string() }),
+		resolve: async (creds) => ({ OPENAI_API_KEY: creds.OPENAI_API_KEY })
+	}
+});
+/**
+* Anthropic integration — passthrough auth via API key.
+*/
+const anthropic = defineIntegration({
+	name: "anthropic",
+	namespace: "wellze",
+	description: "Anthropic — Claude models for text generation, structured output, and streaming",
+	auth: {
+		credentials: z.object({ ANTHROPIC_API_KEY: z.string() }),
+		output: z.object({ ANTHROPIC_API_KEY: z.string() }),
+		resolve: async (creds) => ({ ANTHROPIC_API_KEY: creds.ANTHROPIC_API_KEY })
+	}
+});
+
+//#endregion
+//#region src/schemas.ts
+/**
+* ai/schemas.ts
+*
+* Zod schemas for AI SDK response shapes.
+*
+* These schemas define the output types for generate and stream steps.
+* Types are inferred from schemas — never define types separately.
+*/
+/**
+* Token usage information returned by the AI SDK.
+*/
+const tokenUsageSchema = z.object({
+	promptTokens: z.number(),
+	completionTokens: z.number(),
+	totalTokens: z.number()
+});
+/**
+* Schema for generateText response.
+*/
+const generateTextResponseSchema = z.object({
+	text: z.string(),
+	finishReason: z.string(),
+	usage: tokenUsageSchema
+});
+/**
+* Schema factory for generateObject responses.
+* The object shape is determined by the caller's schema.
+*/
+function generateObjectResponseSchema(objectSchema) {
+	return z.object({
+		object: objectSchema,
+		finishReason: z.string(),
+		usage: tokenUsageSchema
+	});
+}
+/**
+* Schema for streamText collected response (after stream completes).
+*/
+const streamTextResponseSchema = z.object({
+	text: z.string(),
+	finishReason: z.string(),
+	usage: tokenUsageSchema
+});
+/**
+* Supported provider names.
+*/
+const aiProviderName = z.enum(["openai", "anthropic"]);
+/**
+* Common model identifiers for convenience.
+*/
+const openaiModels = z.enum([
+	"gpt-4o",
+	"gpt-4o-mini",
+	"gpt-4-turbo",
+	"o1",
+	"o1-mini",
+	"o3-mini"
+]);
+const anthropicModels = z.enum([
+	"claude-opus-4-5-20251101",
+	"claude-sonnet-4-20250514",
+	"claude-haiku-3-5-20241022"
+]);
+/**
+* Schema for a message in a conversation.
+*/
+const aiMessageSchema = z.object({
+	role: z.enum([
+		"system",
+		"user",
+		"assistant"
+	]),
+	content: z.string()
+});
+
+//#endregion
+export { generateTextResponseSchema as a, tokenUsageSchema as c, defineAIOperation as d, createAnthropicProvider as f, generateObjectResponseSchema as i, anthropic as l, aiProviderName as n, openaiModels as o, createOpenAIProvider as p, anthropicModels as r, streamTextResponseSchema as s, aiMessageSchema as t, openai as u };

package/dist/stream.d.mts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import * as _wellze_workflow_core0 from "@wellze/workflow-core";
+
+//#region src/stream.d.ts
+declare const streamTextOpenAI: _wellze_workflow_core0.StepWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>, streamTextOpenAITool: _wellze_workflow_core0.ToolWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, readonly [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>;
+declare const streamTextAnthropic: _wellze_workflow_core0.StepWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>, streamTextAnthropicTool: _wellze_workflow_core0.ToolWithMetadata<{
+    model?: string | undefined;
+    system?: string | undefined;
+    prompt?: string | undefined;
+    messages?: {
+      role: "system" | "user" | "assistant";
+      content: string;
+    }[] | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    stopSequences?: string[] | undefined;
+  }, {
+    text: string;
+    finishReason: string;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }, readonly [_wellze_workflow_core0.IntegrationBinding<_wellze_workflow_core0.IntegrationDefinition<"openai", z.ZodObject<{
+    OPENAI_API_KEY: z.ZodString;
+  }, z.core.$strip>> | _wellze_workflow_core0.IntegrationDefinition<"anthropic", z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+  }, z.core.$strip>>>]>;
+//#endregion
+export { streamTextAnthropic, streamTextAnthropicTool, streamTextOpenAI, streamTextOpenAITool };

package/dist/stream.mjs

@@ -0,0 +1,95 @@
+import { d as defineAIOperation, f as createAnthropicProvider, l as anthropic, p as createOpenAIProvider, s as streamTextResponseSchema, t as aiMessageSchema, u as openai } from "./schemas-Dd9H2hSI.mjs";
+import { streamText } from "ai";
+import { z } from "zod";
+
+//#region src/stream.ts
+/**
+* ai/stream.ts
+*
+* Steps for streaming text generation using the AI SDK.
+*
+* These steps collect the full stream and return the completed result.
+* For true streaming in HTTP responses, consumers should use the AI SDK
+* directly with `streamText().toTextStreamResponse()`.
+*/
+const { step: streamTextOpenAI, tool: streamTextOpenAITool } = defineAIOperation({
+	name: "Stream Text (OpenAI)",
+	description: "Stream text generation using an OpenAI model, returning the collected result",
+	integration: openai,
+	input: z.object({
+		model: z.string().optional(),
+		system: z.string().optional(),
+		prompt: z.string().optional(),
+		messages: z.array(aiMessageSchema).optional(),
+		maxOutputTokens: z.number().optional(),
+		temperature: z.number().optional(),
+		topP: z.number().optional(),
+		stopSequences: z.array(z.string()).optional()
+	}),
+	output: streamTextResponseSchema,
+	run: async (input, credentials) => {
+		const result = streamText({
+			model: createOpenAIProvider(credentials)(input.model ?? "gpt-4o"),
+			system: input.system,
+			...input.messages ? { messages: input.messages } : { prompt: input.prompt ?? "" },
+			maxOutputTokens: input.maxOutputTokens,
+			temperature: input.temperature,
+			topP: input.topP,
+			stopSequences: input.stopSequences
+		});
+		const text = await result.text;
+		const finishReason = await result.finishReason;
+		const usage = await result.usage;
+		return {
+			text,
+			finishReason,
+			usage: {
+				promptTokens: usage.inputTokens ?? 0,
+				completionTokens: usage.outputTokens ?? 0,
+				totalTokens: (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0)
+			}
+		};
+	}
+});
+const { step: streamTextAnthropic, tool: streamTextAnthropicTool } = defineAIOperation({
+	name: "Stream Text (Anthropic)",
+	description: "Stream text generation using an Anthropic model, returning the collected result",
+	integration: anthropic,
+	input: z.object({
+		model: z.string().optional(),
+		system: z.string().optional(),
+		prompt: z.string().optional(),
+		messages: z.array(aiMessageSchema).optional(),
+		maxOutputTokens: z.number().optional(),
+		temperature: z.number().optional(),
+		topP: z.number().optional(),
+		stopSequences: z.array(z.string()).optional()
+	}),
+	output: streamTextResponseSchema,
+	run: async (input, credentials) => {
+		const result = streamText({
+			model: createAnthropicProvider(credentials)(input.model ?? "claude-sonnet-4-20250514"),
+			system: input.system,
+			...input.messages ? { messages: input.messages } : { prompt: input.prompt ?? "" },
+			maxOutputTokens: input.maxOutputTokens ?? 4096,
+			temperature: input.temperature,
+			topP: input.topP,
+			stopSequences: input.stopSequences
+		});
+		const text = await result.text;
+		const finishReason = await result.finishReason;
+		const usage = await result.usage;
+		return {
+			text,
+			finishReason,
+			usage: {
+				promptTokens: usage.inputTokens ?? 0,
+				completionTokens: usage.outputTokens ?? 0,
+				totalTokens: (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0)
+			}
+		};
+	}
+});
+
+//#endregion
+export { streamTextAnthropic, streamTextAnthropicTool, streamTextOpenAI, streamTextOpenAITool };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@wellze/integration-ai",
+  "version": "0.0.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./generate": {
+      "types": "./dist/generate.d.mts",
+      "default": "./dist/generate.mjs"
+    },
+    "./stream": {
+      "types": "./dist/stream.d.mts",
+      "default": "./dist/stream.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.45",
+    "@ai-sdk/openai": "^3.0.30",
+    "ai": "^6.0.91",
+    "zod": "^4.3.6",
+    "@wellze/workflow-core": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.11",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "@wellze/test-utils": "0.0.0",
+    "@wellze/typescript-config": "0.0.0"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "wellze",
+    "integration",
+    "openai",
+    "anthropic"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/wellze",
+    "directory": "packages/integration-ai"
+  },
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsgo --build",
+    "build": "tsdown",
+    "lint": "biome check --write .",
+    "test:unit": "vitest run --passWithNoTests"
+  }
+}