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

package/dist/ai-sdk/index.js

@@ -0,0 +1,269 @@
+// src/ai-sdk/llm-chat-activity.ts
+import { generateText, generateObject } from "ai";
+import { jsonSchema } from "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 generateObject({
+          model,
+          messages,
+          schema: 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 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
+import { generateText as generateText2, streamText } from "ai";
+
+// src/ai-sdk/tool-mapper.ts
+import { tool, jsonSchema as jsonSchema2 } from "ai";
+function mapToolDefinitions(tools) {
+  const result = {};
+  for (const t of tools) {
+    result[t.name] = tool({
+      description: t.description,
+      inputSchema: jsonSchema2(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 generateText2({
+      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 = 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)
+  };
+}
+export {
+  createAIActivities
+};