@q1k-oss/behaviour-tree-workflows 0.0.2 → 0.0.3

package/dist/ai-sdk/index.cjs

@@ -0,0 +1,296 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ai-sdk/index.ts
+var ai_sdk_exports = {};
+__export(ai_sdk_exports, {
+  createAIActivities: () => createAIActivities
+});
+module.exports = __toCommonJS(ai_sdk_exports);
+
+// src/ai-sdk/llm-chat-activity.ts
+var import_ai = require("ai");
+var import_ai2 = require("ai");
+
+// src/ai-sdk/provider-resolver.ts
+function resolveModel(providers, provider, modelId) {
+  const providerFn = providers[provider];
+  if (!providerFn) {
+    const configured = Object.keys(providers).filter(
+      (k) => providers[k] != null
+    );
+    throw new Error(
+      `Provider "${provider}" is not configured. Configured providers: [${configured.join(", ") || "none"}]. Pass it in createAIActivities({ providers: { ${provider}: ... } })`
+    );
+  }
+  return providerFn(modelId);
+}
+
+// src/ai-sdk/message-mapper.ts
+function mapLLMMessages(messages, systemPrompt) {
+  const result = [];
+  if (systemPrompt) {
+    result.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system" && systemPrompt) continue;
+    result.push({ role: msg.role, content: msg.content });
+  }
+  return result;
+}
+function mapAgentMessages(messages, systemPrompt) {
+  const result = [];
+  if (systemPrompt) {
+    result.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      if (!systemPrompt) {
+        result.push({ role: "system", content: msg.content });
+      }
+      continue;
+    }
+    if (typeof msg.content === "string") {
+      result.push({
+        role: msg.role,
+        content: msg.content
+      });
+      continue;
+    }
+    const blocks = msg.content;
+    if (msg.role === "assistant") {
+      mapAssistantMessage(blocks, result);
+    } else if (msg.role === "user") {
+      mapUserMessage(blocks, result);
+    }
+  }
+  return result;
+}
+function mapAssistantMessage(blocks, result) {
+  const contentParts = [];
+  for (const block of blocks) {
+    if (block.type === "text") {
+      contentParts.push({ type: "text", text: block.text });
+    } else if (block.type === "tool_use") {
+      contentParts.push({
+        type: "tool-call",
+        toolCallId: block.id,
+        toolName: block.name,
+        input: block.input
+      });
+    }
+  }
+  if (contentParts.length > 0) {
+    result.push({ role: "assistant", content: contentParts });
+  }
+}
+function mapUserMessage(blocks, result) {
+  const toolResults = blocks.filter(
+    (b) => b.type === "tool_result"
+  );
+  if (toolResults.length > 0) {
+    const toolResultParts = toolResults.map((b) => ({
+      type: "tool-result",
+      toolCallId: b.tool_use_id,
+      toolName: b.tool_use_id,
+      // AI SDK v6 requires toolName; use toolCallId as fallback
+      output: b.is_error ? { type: "error-text", value: b.content } : { type: "text", value: b.content }
+    }));
+    result.push({ role: "tool", content: toolResultParts });
+  } else {
+    const text = blocks.filter(
+      (b) => b.type === "text"
+    ).map((b) => b.text).join("\n");
+    result.push({ role: "user", content: text });
+  }
+}
+
+// src/ai-sdk/llm-chat-activity.ts
+var FINISH_REASON_MAP = {
+  stop: "stop",
+  length: "length",
+  "content-filter": "content_filter",
+  "tool-calls": "tool_calls",
+  error: "error"
+};
+function mapUsage(usage) {
+  return {
+    promptTokens: usage?.inputTokens ?? 0,
+    completionTokens: usage?.outputTokens ?? 0,
+    totalTokens: usage?.totalTokens ?? (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
+  };
+}
+function createLLMChatActivity(options) {
+  return async (request) => {
+    const model = resolveModel(options.providers, request.provider, request.model);
+    const messages = mapLLMMessages(request.messages, request.systemPrompt);
+    const timeout = request.timeout ?? options.defaultTimeout ?? 6e4;
+    const abortController = new AbortController();
+    const timer = setTimeout(() => abortController.abort(), timeout);
+    try {
+      if (request.responseFormat === "json" && request.jsonSchema) {
+        const result2 = await (0, import_ai.generateObject)({
+          model,
+          messages,
+          schema: (0, import_ai2.jsonSchema)(request.jsonSchema),
+          temperature: request.temperature,
+          maxOutputTokens: request.maxTokens,
+          abortSignal: abortController.signal
+        });
+        return {
+          content: JSON.stringify(result2.object),
+          parsed: result2.object,
+          usage: mapUsage(result2.usage),
+          model: request.model,
+          finishReason: FINISH_REASON_MAP[result2.finishReason] ?? "stop"
+        };
+      }
+      const result = await (0, import_ai.generateText)({
+        model,
+        messages,
+        temperature: request.temperature,
+        maxOutputTokens: request.maxTokens,
+        abortSignal: abortController.signal
+      });
+      let parsed;
+      if (request.responseFormat === "json") {
+        try {
+          parsed = JSON.parse(result.text);
+        } catch {
+        }
+      }
+      return {
+        content: result.text,
+        parsed,
+        usage: mapUsage(result.usage),
+        model: request.model,
+        finishReason: FINISH_REASON_MAP[result.finishReason] ?? "stop"
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+
+// src/ai-sdk/agent-loop-turn-activity.ts
+var import_ai4 = require("ai");
+
+// src/ai-sdk/tool-mapper.ts
+var import_ai3 = require("ai");
+function mapToolDefinitions(tools) {
+  const result = {};
+  for (const t of tools) {
+    result[t.name] = (0, import_ai3.tool)({
+      description: t.description,
+      inputSchema: (0, import_ai3.jsonSchema)(t.inputSchema)
+    });
+  }
+  return result;
+}
+
+// src/ai-sdk/agent-loop-turn-activity.ts
+function mapStopReason(finishReason) {
+  if (finishReason === "tool-calls") return "tool_use";
+  if (finishReason === "length") return "max_tokens";
+  return "end_turn";
+}
+function extractToolCalls(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) return void 0;
+  return toolCalls.map((tc) => ({
+    id: tc.toolCallId,
+    name: tc.toolName,
+    input: tc.input
+  }));
+}
+function mapUsage2(usage) {
+  return {
+    promptTokens: usage?.inputTokens ?? 0,
+    completionTokens: usage?.outputTokens ?? 0,
+    totalTokens: usage?.totalTokens ?? (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
+  };
+}
+function createAgentLoopTurnActivity(options) {
+  return async (request) => {
+    const model = resolveModel(
+      options.providers,
+      request.provider,
+      request.model
+    );
+    const messages = mapAgentMessages(request.messages, request.systemPrompt);
+    const tools = request.tools && request.tools.length > 0 ? mapToolDefinitions(request.tools) : void 0;
+    if (request.streamChannelId && options.onStreamToken) {
+      return executeWithStreaming(
+        model,
+        messages,
+        tools,
+        request,
+        options
+      );
+    }
+    const result = await (0, import_ai4.generateText)({
+      model,
+      messages,
+      tools,
+      temperature: request.temperature,
+      maxOutputTokens: request.maxTokens
+    });
+    return {
+      content: result.text,
+      toolCalls: extractToolCalls(result.toolCalls),
+      stopReason: mapStopReason(result.finishReason),
+      usage: mapUsage2(result.usage)
+    };
+  };
+}
+async function executeWithStreaming(model, messages, tools, request, options) {
+  const channelId = request.streamChannelId;
+  const result = (0, import_ai4.streamText)({
+    model,
+    messages,
+    tools,
+    temperature: request.temperature,
+    maxOutputTokens: request.maxTokens
+  });
+  for await (const chunk of result.textStream) {
+    options.onStreamToken(channelId, chunk);
+  }
+  options.onStreamComplete?.(channelId);
+  const finalText = await result.text;
+  const finalToolCalls = await result.toolCalls;
+  const finalFinishReason = await result.finishReason;
+  const finalUsage = await result.usage;
+  return {
+    content: finalText,
+    toolCalls: extractToolCalls(finalToolCalls),
+    stopReason: mapStopReason(finalFinishReason),
+    usage: mapUsage2(finalUsage)
+  };
+}
+
+// src/ai-sdk/index.ts
+function createAIActivities(options) {
+  return {
+    llmChat: createLLMChatActivity(options),
+    agentLoopTurn: createAgentLoopTurnActivity(options)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAIActivities
+});

package/dist/ai-sdk/index.d.cts

@@ -0,0 +1,82 @@
+import { B as BtreeActivities } from '../types-BJPlUisg.cjs';
+import { LanguageModel } from 'ai';
+
+/**
+ * Configuration types for the AI SDK activity factory
+ */
+
+/**
+ * Provider configuration — maps provider names to AI SDK model factories.
+ * Each entry is a function that takes a model ID and returns a LanguageModel.
+ *
+ * @example
+ * ```typescript
+ * import { createAnthropic } from "@ai-sdk/anthropic";
+ * import { createOpenAI } from "@ai-sdk/openai";
+ *
+ * const providers: AIProviderConfig = {
+ *   anthropic: createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY }),
+ *   openai: createOpenAI({ apiKey: process.env.OPENAI_API_KEY }),
+ * };
+ * ```
+ */
+interface AIProviderConfig {
+    anthropic?: (modelId: string) => LanguageModel;
+    openai?: (modelId: string) => LanguageModel;
+    google?: (modelId: string) => LanguageModel;
+    ollama?: (modelId: string) => LanguageModel;
+}
+/**
+ * Options for creating AI SDK-based activity implementations
+ */
+interface CreateAIActivitiesOptions {
+    /** Provider configuration — maps provider names to AI SDK model factories */
+    providers: AIProviderConfig;
+    /** Default timeout for LLM calls in milliseconds (default: 60000) */
+    defaultTimeout?: number;
+    /** Callback for streaming tokens — receives (channelId, textDelta) */
+    onStreamToken?: (channelId: string, textDelta: string) => void;
+    /** Callback when stream completes */
+    onStreamComplete?: (channelId: string) => void;
+}
+
+/**
+ * AI SDK Activity Factory
+ *
+ * Creates BtreeActivities implementations for `llmChat` and `agentLoopTurn`
+ * backed by the Vercel AI SDK. Supports Anthropic, OpenAI, Google, and Ollama.
+ *
+ * @example
+ * ```typescript
+ * import { createAIActivities } from "@q1k-oss/behaviour-tree-workflows/ai-sdk";
+ * import { createAnthropic } from "@ai-sdk/anthropic";
+ * import { createOpenAI } from "@ai-sdk/openai";
+ *
+ * const aiActivities = createAIActivities({
+ *   providers: {
+ *     anthropic: createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY }),
+ *     openai: createOpenAI({ apiKey: process.env.OPENAI_API_KEY }),
+ *   },
+ *   onStreamToken: (channelId, text) => {
+ *     ws.send(JSON.stringify({ channel: channelId, text }));
+ *   },
+ * });
+ *
+ * // Merge with other activities
+ * const activities: BtreeActivities = {
+ *   ...aiActivities,
+ *   executeAgentTool: myToolExecutor,
+ * };
+ * ```
+ */
+
+/**
+ * Create AI SDK-based activity implementations for behavior tree LLM nodes.
+ *
+ * Returns a partial BtreeActivities object with `llmChat` and `agentLoopTurn`
+ * implemented using the Vercel AI SDK. Other activities (executeAgentTool,
+ * executePieceAction, etc.) must be provided separately.
+ */
+declare function createAIActivities(options: CreateAIActivitiesOptions): Required<Pick<BtreeActivities, "llmChat" | "agentLoopTurn">>;
+
+export { type AIProviderConfig, type CreateAIActivitiesOptions, createAIActivities };

package/dist/ai-sdk/index.d.ts

@@ -0,0 +1,82 @@
+import { B as BtreeActivities } from '../types-BJPlUisg.js';
+import { LanguageModel } from 'ai';
+
+/**
+ * Configuration types for the AI SDK activity factory
+ */
+
+/**
+ * Provider configuration — maps provider names to AI SDK model factories.
+ * Each entry is a function that takes a model ID and returns a LanguageModel.
+ *
+ * @example
+ * ```typescript
+ * import { createAnthropic } from "@ai-sdk/anthropic";
+ * import { createOpenAI } from "@ai-sdk/openai";
+ *
+ * const providers: AIProviderConfig = {
+ *   anthropic: createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY }),
+ *   openai: createOpenAI({ apiKey: process.env.OPENAI_API_KEY }),
+ * };
+ * ```
+ */
+interface AIProviderConfig {
+    anthropic?: (modelId: string) => LanguageModel;
+    openai?: (modelId: string) => LanguageModel;
+    google?: (modelId: string) => LanguageModel;
+    ollama?: (modelId: string) => LanguageModel;
+}
+/**
+ * Options for creating AI SDK-based activity implementations
+ */
+interface CreateAIActivitiesOptions {
+    /** Provider configuration — maps provider names to AI SDK model factories */
+    providers: AIProviderConfig;
+    /** Default timeout for LLM calls in milliseconds (default: 60000) */
+    defaultTimeout?: number;
+    /** Callback for streaming tokens — receives (channelId, textDelta) */
+    onStreamToken?: (channelId: string, textDelta: string) => void;
+    /** Callback when stream completes */
+    onStreamComplete?: (channelId: string) => void;
+}
+
+/**
+ * AI SDK Activity Factory
+ *
+ * Creates BtreeActivities implementations for `llmChat` and `agentLoopTurn`
+ * backed by the Vercel AI SDK. Supports Anthropic, OpenAI, Google, and Ollama.
+ *
+ * @example
+ * ```typescript
+ * import { createAIActivities } from "@q1k-oss/behaviour-tree-workflows/ai-sdk";
+ * import { createAnthropic } from "@ai-sdk/anthropic";
+ * import { createOpenAI } from "@ai-sdk/openai";
+ *
+ * const aiActivities = createAIActivities({
+ *   providers: {
+ *     anthropic: createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY }),
+ *     openai: createOpenAI({ apiKey: process.env.OPENAI_API_KEY }),
+ *   },
+ *   onStreamToken: (channelId, text) => {
+ *     ws.send(JSON.stringify({ channel: channelId, text }));
+ *   },
+ * });
+ *
+ * // Merge with other activities
+ * const activities: BtreeActivities = {
+ *   ...aiActivities,
+ *   executeAgentTool: myToolExecutor,
+ * };
+ * ```
+ */
+
+/**
+ * Create AI SDK-based activity implementations for behavior tree LLM nodes.
+ *
+ * Returns a partial BtreeActivities object with `llmChat` and `agentLoopTurn`
+ * implemented using the Vercel AI SDK. Other activities (executeAgentTool,
+ * executePieceAction, etc.) must be provided separately.
+ */
+declare function createAIActivities(options: CreateAIActivitiesOptions): Required<Pick<BtreeActivities, "llmChat" | "agentLoopTurn">>;
+
+export { type AIProviderConfig, type CreateAIActivitiesOptions, createAIActivities };