@loopstack/ai-module 0.16.3 → 0.18.0-rc.0

package/src/services/ai-provider-registry.service.ts

@@ -0,0 +1,73 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { LanguageModel } from 'ai';
+import {
+  AI_PROVIDER_DECORATOR,
+  AiProviderDecoratorOptions,
+  AiProviderInterface,
+  AiProviderOptions,
+} from '@loopstack/common';
+
+@Injectable()
+export class AiProviderRegistryService implements OnModuleInit {
+  private readonly logger = new Logger(AiProviderRegistryService.name);
+  private readonly providers = new Map<string, AiProviderInterface>();
+
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    private readonly reflector: Reflector,
+  ) {}
+
+  onModuleInit() {
+    this.loadProviders();
+  }
+
+  private loadProviders() {
+    const providers = this.discoveryService.getProviders();
+
+    providers
+      .filter((wrapper) => wrapper.isDependencyTreeStatic())
+      .filter((wrapper) => wrapper.instance)
+      .forEach((wrapper) => {
+        const instance = wrapper.instance as AiProviderInterface;
+        const metadata = this.reflector.get<AiProviderDecoratorOptions>(
+          AI_PROVIDER_DECORATOR,
+          (instance as object).constructor,
+        );
+
+        if (metadata) {
+          this.registerProvider(metadata.name, instance);
+          this.logger.log(`Registered AI provider: ${metadata.name}`);
+        }
+      });
+  }
+
+  private registerProvider(name: string, provider: AiProviderInterface) {
+    if (this.providers.has(name)) {
+      this.logger.warn(`Provider ${name} already exists, overriding...`);
+    }
+    this.providers.set(name.toLowerCase(), provider);
+  }
+
+  createModel(providerName: string, options: AiProviderOptions): LanguageModel {
+    const provider = this.providers.get(providerName.toLowerCase());
+
+    if (!provider) {
+      throw new Error(
+        `AI provider '${providerName}' not found. Available providers: ${this.getAvailableProviders().join(', ')}`,
+      );
+    }
+
+    try {
+      const client: unknown = provider.createClient(options);
+      return provider.getModel(client, options.model) as LanguageModel;
+    } catch (error) {
+      this.logger.error(`Failed to create model for provider ${providerName}:`, error);
+      throw error;
+    }
+  }
+
+  getAvailableProviders(): string[] {
+    return Array.from(this.providers.keys());
+  }
+}

package/src/services/ai-tools-helper.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { WorkflowBase } from '@loopstack/core';
+
+@Injectable()
+export class AiToolsHelperService {
+  getTools(tools: string[], parent: WorkflowBase): Record<string, any> | undefined {
+    // using any instead of ToolSet bc ai sdk types have some nesting issue
+    const toolDefinitions: Record<string, any> = {};
+
+    for (const toolName of tools) {
+      const tool = parent.getTool(toolName);
+      if (!tool) {
+        throw new Error(`Tool with name ${toolName} not available in Workflow context.`);
+      }
+
+      const inputSchema = tool.argsSchema;
+
+      if (inputSchema) {
+        toolDefinitions[toolName] = {
+          description: tool.config.description,
+          inputSchema,
+        } as unknown; // using unknown bc ai sdk types have some nesting issue
+      }
+    }
+
+    return Object.keys(toolDefinitions).length ? toolDefinitions : undefined;
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,4 @@
+export * from './ai-messages-helper.service';
+export * from './ai-provider-model-helper.service';
+export * from './ai-messages-helper.service';
+export * from './ai-tools-helper.service';

package/src/tools/ai-generate-document.tool.ts

@@ -0,0 +1,41 @@
+import { Injectable } from '@nestjs/common';
+import { BlockConfig, Tool, ToolResult, WithArguments } from '@loopstack/common';
+import { ToolBase, WorkflowBase } from '@loopstack/core';
+import { CreateDocument } from '@loopstack/core-ui-module';
+import { WorkflowExecution } from '@loopstack/core/dist/workflow-processor/interfaces/workflow-execution.interface';
+import { AiGenerateObject, AiGenerateObjectArgsType, AiGenerateObjectSchema } from './ai-generate-object.tool';
+
+@Injectable()
+@BlockConfig({
+  config: {
+    description: 'Generates a structured object using a LLM and creates it as document',
+  },
+})
+@WithArguments(AiGenerateObjectSchema)
+export class AiGenerateDocument extends ToolBase<AiGenerateObjectArgsType> {
+  @Tool() private aiGenerateObject!: AiGenerateObject;
+  @Tool() private createDocument!: CreateDocument;
+
+  private getRequiredTool(name: string): ToolBase<any> {
+    const tool = this.getTool(name);
+    if (tool === undefined) {
+      throw new Error(`Tool "${name}" is not available`);
+    }
+    return tool;
+  }
+
+  async execute(args: AiGenerateObjectArgsType, ctx: WorkflowExecution, parent: WorkflowBase): Promise<ToolResult> {
+    const result = await this.getRequiredTool('aiGenerateObject').execute(args, ctx, parent);
+    return this.getRequiredTool('createDocument').execute(
+      {
+        id: args.response.id,
+        document: args.response.document,
+        update: {
+          content: result.data as unknown,
+        },
+      },
+      ctx,
+      parent,
+    );
+  }
+}

package/src/tools/ai-generate-object.tool.ts

@@ -0,0 +1,91 @@
+import { ModelMessage } from '@ai-sdk/provider-utils';
+import { GenerateObjectResult, LanguageModel, generateObject } from 'ai';
+import { z } from 'zod';
+import { BlockConfig, ToolResult, WithArguments } from '@loopstack/common';
+import { ToolBase, WorkflowBase } from '@loopstack/core';
+import { Block } from '@loopstack/core/dist/workflow-processor/abstract/block.abstract';
+import { WorkflowExecution } from '@loopstack/core/dist/workflow-processor/interfaces/workflow-execution.interface';
+import { AiGenerateToolBaseSchema } from '../schemas/ai-generate-tool-base.schema';
+import { AiMessagesHelperService } from '../services';
+import { AiProviderModelHelperService } from '../services';
+
+export const AiGenerateObjectSchema = AiGenerateToolBaseSchema.extend({
+  response: z.object({
+    id: z.string().optional(),
+    document: z.string(),
+  }),
+}).strict();
+
+export type AiGenerateObjectArgsType = z.infer<typeof AiGenerateObjectSchema>;
+
+@BlockConfig({
+  config: {
+    description: 'Generates a structured object using a LLM',
+  },
+})
+@WithArguments(AiGenerateObjectSchema)
+export class AiGenerateObject extends ToolBase<AiGenerateObjectArgsType> {
+  constructor(
+    private readonly aiMessagesHelperService: AiMessagesHelperService,
+    private readonly aiProviderModelHelperService: AiProviderModelHelperService,
+  ) {
+    super();
+  }
+
+  async execute(args: AiGenerateObjectArgsType, ctx: WorkflowExecution, parent: WorkflowBase): Promise<ToolResult> {
+    const model = this.aiProviderModelHelperService.getProviderModel(args.llm);
+
+    const options: {
+      prompt?: string;
+      messages?: ModelMessage[];
+      schema?: z.ZodSchema;
+    } = {};
+
+    if (args.prompt) {
+      options.prompt = args.prompt;
+    } else {
+      options.messages = this.aiMessagesHelperService.getMessages(ctx.state.getMetadata('documents'), {
+        messages: args.messages as ModelMessage[],
+        messagesSearchTag: args.messagesSearchTag,
+      });
+    }
+
+    const document: Block | undefined = parent.getDocument(args.response.document);
+    if (!document) {
+      throw new Error(`Document with name "${args.response.document}" not found in tool execution context.`);
+    }
+    const responseSchema = document.argsSchema;
+    if (!responseSchema) {
+      throw new Error(`AI object generation source document must have a schema.`);
+    }
+
+    options.schema = responseSchema;
+
+    const response = await this.handleGenerateObject(model, options);
+
+    return {
+      data: response.object,
+    };
+  }
+
+  private async handleGenerateObject(
+    model: LanguageModel,
+    options: {
+      prompt?: string;
+      messages?: ModelMessage[];
+      schema?: z.ZodSchema;
+    },
+  ): Promise<GenerateObjectResult<unknown>> {
+    const startTime = performance.now();
+    try {
+      return generateObject({
+        model,
+        ...options,
+      } as Parameters<typeof generateObject>[0]);
+    } catch (error) {
+      const errorResponseTime = performance.now() - startTime;
+      console.error(`Request failed after ${errorResponseTime}ms:`, error);
+      throw error;
+    }
+  }
+}

package/src/tools/ai-generate-text.tool.ts

@@ -0,0 +1,110 @@
+import { ModelMessage } from '@ai-sdk/provider-utils';
+import { Injectable } from '@nestjs/common';
+import { LanguageModel, UIMessage, createUIMessageStream, streamText } from 'ai';
+import { z } from 'zod';
+import { BlockConfig, ToolResult, WithArguments } from '@loopstack/common';
+import { ToolBase, WorkflowBase } from '@loopstack/core';
+import { WorkflowExecution } from '@loopstack/core/dist/workflow-processor/interfaces/workflow-execution.interface';
+import { AiGenerateToolBaseSchema } from '../schemas/ai-generate-tool-base.schema';
+import { AiMessagesHelperService } from '../services';
+import { AiProviderModelHelperService } from '../services';
+import { AiToolsHelperService } from '../services';
+
+export const AiGenerateTextSchema = AiGenerateToolBaseSchema.extend({
+  tools: z.array(z.string()).optional(),
+}).strict();
+
+type AiGenerateTextArgsType = z.infer<typeof AiGenerateTextSchema>;
+
+@Injectable()
+@BlockConfig({
+  config: {
+    description: 'Generates text using a LLM',
+  },
+})
+@WithArguments(AiGenerateTextSchema)
+export class AiGenerateText extends ToolBase<AiGenerateTextArgsType> {
+  constructor(
+    private readonly aiMessagesHelperService: AiMessagesHelperService,
+    private readonly aiToolsHelperService: AiToolsHelperService,
+    private readonly aiProviderModelHelperService: AiProviderModelHelperService,
+  ) {
+    super();
+  }
+
+  async execute(args: AiGenerateTextArgsType, ctx: WorkflowExecution, parent: WorkflowBase): Promise<ToolResult> {
+    const model = this.aiProviderModelHelperService.getProviderModel(args.llm);
+
+    const options: {
+      prompt?: string;
+      messages?: ModelMessage[];
+      tools?: Record<string, unknown>;
+    } = {};
+
+    options.tools = args.tools ? this.aiToolsHelperService.getTools(args.tools, parent) : undefined;
+
+    if (args.prompt) {
+      options.prompt = args.prompt;
+    } else {
+      options.messages = this.aiMessagesHelperService.getMessages(ctx.state.getMetadata('documents'), {
+        messages: args.messages as ModelMessage[],
+        messagesSearchTag: args.messagesSearchTag,
+      });
+    }
+
+    const uiMessage = await this.handleGenerateText(model, options);
+
+    return {
+      data: uiMessage,
+    };
+  }
+
+  private async handleGenerateText(
+    model: LanguageModel,
+    options: {
+      prompt?: string;
+      messages?: ModelMessage[];
+      tools?: Record<string, unknown>;
+    },
+  ): Promise<UIMessage> {
+    const startTime = performance.now();
+    try {
+      const result = streamText({
+        model,
+        ...options,
+      } as Parameters<typeof streamText>[0]);
+
+      return new Promise((resolve, reject) => {
+        const stream = createUIMessageStream({
+          execute({ writer }) {
+            writer.merge(
+              result.toUIMessageStream({
+                sendReasoning: true,
+              }),
+            );
+          },
+          onFinish: (data) => {
+            resolve(data.responseMessage);
+          },
+        });
+
+        // Consume the stream to trigger execution
+        void (async () => {
+          try {
+            const reader = stream.getReader();
+            while (true) {
+              const { done } = await reader.read();
+              if (done) break;
+            }
+          } catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        })();
+      });
+    } catch (error) {
+      const errorResponseTime = performance.now() - startTime;
+      console.error(`Request failed after ${errorResponseTime}ms:`, error);
+      throw error;
+    }
+  }
+}

package/src/tools/delegate-tool-call.tool.ts

@@ -0,0 +1,72 @@
+import { ToolUIPart, UIMessage } from 'ai';
+import { z } from 'zod';
+import { BlockConfig, ToolResult, WithArguments } from '@loopstack/common';
+import { ToolBase, WorkflowBase } from '@loopstack/core';
+import { WorkflowExecution } from '@loopstack/core/dist/workflow-processor/interfaces/workflow-execution.interface';
+
+const DelegateToolCallsToolSchema = z.object({
+  message: z.object({
+    id: z.string(),
+    parts: z.array(
+      z.object({
+        type: z.string(),
+        input: z.any().optional(),
+        toolCallId: z.string().optional(),
+      }),
+    ),
+  }),
+});
+
+type DelegateToolCallsToolArgs = z.infer<typeof DelegateToolCallsToolSchema>;
+
+@BlockConfig({
+  config: {
+    description: 'Delegate a tool call.',
+  },
+})
+@WithArguments(DelegateToolCallsToolSchema)
+export class DelegateToolCall extends ToolBase<DelegateToolCallsToolArgs> {
+  async execute(args: DelegateToolCallsToolArgs, ctx: WorkflowExecution, parent: WorkflowBase): Promise<ToolResult> {
+    const parts = args.message.parts;
+    const resultParts: ToolUIPart[] = [];
+
+    for (const part of parts) {
+      if (!part.type.startsWith('tool-')) {
+        continue;
+      }
+
+      if (!part.toolCallId) {
+        throw new Error(`No toolCallId provided`);
+      }
+
+      const toolName = part.type.replace(/^tool-/, '');
+
+      const tool = parent.getTool(toolName);
+      if (!tool) {
+        throw new Error(`Tool ${toolName} not found.`);
+      }
+      const result: ToolResult = await tool.execute(part.input as Record<string, unknown>, ctx, parent);
+
+      resultParts.push({
+        type: part.type as ToolUIPart['type'],
+        toolCallId: part.toolCallId,
+        output: {
+          type: result.type || 'text',
+          value: result.data as unknown,
+        },
+        input: part.input as Record<string, unknown>,
+        state: 'output-available',
+      } satisfies ToolUIPart);
+    }
+
+    const resultMessage: UIMessage = {
+      id: args.message.id,
+      role: 'assistant',
+      parts: resultParts,
+    };
+
+    return {
+      data: resultMessage,
+    };
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,4 @@
+export * from './ai-generate-document.tool';
+export * from './ai-generate-text.tool';
+export * from './ai-generate-object.tool';
+export * from './delegate-tool-call.tool';

package/.prettierrc

@@ -1,4 +0,0 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all"
-}

package/LICENSE

@@ -1,19 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-Copyright 2025 Loopstack GmbH
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this skeleton application except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
-}