@hed-hog/core 0.0.362 → 0.0.365

package/src/ai/ai.service.ts

@@ -12,6 +12,7 @@ import {
 import axios from 'axios';
 import { createHash } from 'crypto';
 import pdfParse from 'pdf-parse';
+import { AiExecutionService } from '../ai-instruction/ai-execution.service';
 import { DeleteDTO } from '../dto/delete.dto';
 import { FileService } from '../file/file.service';
 import { buildAiConfigFromIntegration } from '../integration-profile/integration-profile.utils';
@@ -51,6 +52,8 @@ export class AiService implements OnModuleInit {
     private readonly settingService: SettingService,
     @Inject(forwardRef(() => FileService))
     private readonly fileService: FileService,
+    @Inject(forwardRef(() => AiExecutionService))
+    private readonly aiExecution: AiExecutionService,
   ) {}
 
   async onModuleInit() {
@@ -69,35 +72,59 @@ export class AiService implements OnModuleInit {
     const provider = data.provider || 'openai';
     const attachment = await this.resolveAttachment(file, data.file_id);
 
-    if (provider === 'openai') {
-      const model = data.model || 'gpt-4o-mini';
-      const content = await this.chatWithOpenAi({
+    const executionId = await this.aiExecution.start({ trigger: 'api', contextSlug: 'ai-chat' });
+    const stepStart = Date.now();
+
+    try {
+      if (provider === 'openai') {
+        const model = data.model || 'gpt-4o-mini';
+        const { content, usage } = await this.chatWithOpenAi({
+          message: data.message,
+          model,
+          systemPrompt: data.systemPrompt,
+          attachment,
+        });
+
+        await this.aiExecution.recordStep({
+          executionId,
+          stepOrder: 0,
+          type: 'output',
+          provider: 'openai',
+          model,
+          durationMs: Date.now() - stepStart,
+          usage,
+          outputSummary: content.slice(0, 200),
+        });
+        await this.aiExecution.finish(executionId, 'completed');
+
+        return { provider, model, content };
+      }
+
+      const model = data.model || 'gemini-1.5-flash';
+      const { content, usage } = await this.chatWithGemini({
         message: data.message,
         model,
         systemPrompt: data.systemPrompt,
         attachment,
       });
 
-      return {
-        provider,
+      await this.aiExecution.recordStep({
+        executionId,
+        stepOrder: 0,
+        type: 'output',
+        provider: 'gemini',
         model,
-        content,
-      };
-    }
-
-    const model = data.model || 'gemini-1.5-flash';
-    const content = await this.chatWithGemini({
-      message: data.message,
-      model,
-      systemPrompt: data.systemPrompt,
-      attachment,
-    });
+        durationMs: Date.now() - stepStart,
+        usage,
+        outputSummary: content.slice(0, 200),
+      });
+      await this.aiExecution.finish(executionId, 'completed');
 
-    return {
-      provider,
-      model,
-      content,
-    };
+      return { provider, model, content };
+    } catch (err) {
+      await this.aiExecution.finish(executionId, 'failed', String(err));
+      throw err;
+    }
   }
 
   async createAgent(data: CreateAgentDTO) {
@@ -277,7 +304,7 @@ export class AiService implements OnModuleInit {
         };
       }
 
-      const content = await this.chatWithOpenAi({
+      const { content } = await this.chatWithOpenAi({
         message: data.message,
         model: agent.model || this.getDefaultModel('openai'),
         systemPrompt: agent.instructions || undefined,
@@ -292,7 +319,7 @@ export class AiService implements OnModuleInit {
       };
     }
 
-    const content = await this.chatWithGemini({
+    const { content } = await this.chatWithGemini({
       message: data.message,
       model: agent.model || this.getDefaultModel('gemini'),
       systemPrompt: agent.instructions || undefined,
@@ -454,7 +481,7 @@ export class AiService implements OnModuleInit {
     model: string;
     systemPrompt?: string;
     attachment?: AiAttachment | null;
-  }) {
+  }): Promise<{ content: string; usage?: { input: number; output: number; total: number } }> {
     const openai = await this.getAiApiKey('openai');
 
     const messages: Array<any> = [];
@@ -468,10 +495,7 @@ export class AiService implements OnModuleInit {
 
     const response = await axios.post(
       'https://api.openai.com/v1/chat/completions',
-      {
-        model,
-        messages,
-      },
+      { model, messages },
       {
         headers: {
           Authorization: `Bearer ${openai}`,
@@ -480,7 +504,11 @@ export class AiService implements OnModuleInit {
       },
     );
 
-    return response.data?.choices?.[0]?.message?.content || '';
+    const u = response.data?.usage;
+    return {
+      content: response.data?.choices?.[0]?.message?.content || '',
+      usage: u ? { input: u.prompt_tokens ?? 0, output: u.completion_tokens ?? 0, total: u.total_tokens ?? 0 } : undefined,
+    };
   }
 
   private async createOpenAiAssistant({
@@ -620,7 +648,7 @@ export class AiService implements OnModuleInit {
     model: string;
     systemPrompt?: string;
     attachment?: AiAttachment | null;
-  }) {
+  }): Promise<{ content: string; usage?: { input: number; output: number; total: number } }> {
     const gemini = await this.getAiApiKey('gemini');
 
     const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${gemini}`;
@@ -673,7 +701,12 @@ export class AiService implements OnModuleInit {
     });
 
     const parts = response.data?.candidates?.[0]?.content?.parts || [];
-    return parts.map((part: any) => part.text || '').join('');
+    const content = parts.map((part: any) => part.text || '').join('');
+    const u = response.data?.usageMetadata;
+    return {
+      content,
+      usage: u ? { input: u.promptTokenCount ?? 0, output: u.candidatesTokenCount ?? 0, total: u.totalTokenCount ?? 0 } : undefined,
+    };
   }
 
   private async sleep(ms: number) {

package/src/ai-instruction/ai-execution.service.ts

@@ -0,0 +1,244 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import type {
+  AiExecutionRecord,
+  AiExecutionStepType,
+  AiExecutionTrigger,
+  AiModelPricingRecord,
+  AiTokenUsage,
+} from './types/ai-instruction.types';
+
+export type StartExecutionParams = {
+  userId?: number;
+  conversationId?: number;
+  agentId?: number;
+  trigger?: AiExecutionTrigger;
+  contextSlug?: string;
+};
+
+export type RecordStepParams = {
+  executionId: number;
+  stepOrder: number;
+  type: AiExecutionStepType;
+  provider?: string;
+  model?: string;
+  toolName?: string;
+  usage?: AiTokenUsage;
+  durationMs?: number;
+  inputSummary?: string;
+  outputSummary?: string;
+  success?: boolean;
+  error?: string;
+};
+
+@Injectable()
+export class AiExecutionService {
+  private readonly logger = new Logger(AiExecutionService.name);
+  private readonly pricingCache = new Map<string, AiModelPricingRecord>();
+  private pricingLoadedAt = 0;
+  private readonly PRICING_TTL_MS = 60 * 60 * 1000; // 1h
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+  ) {}
+
+  async start(params: StartExecutionParams): Promise<number> {
+    try {
+      const result = await this.prisma.$queryRaw<Array<{ id: number }>>`
+        INSERT INTO ai_execution (user_id, conversation_id, agent_id, trigger, status, context_slug, started_at)
+        VALUES (
+          ${params.userId ?? null},
+          ${params.conversationId ?? null},
+          ${params.agentId ?? null},
+          CAST(${params.trigger ?? 'manual'} AS ai_execution_trigger_enum),
+          'running',
+          ${params.contextSlug ?? null},
+          NOW()
+        )
+        RETURNING id
+      `;
+      return result[0].id;
+    } catch (e) {
+      this.logger.warn(`Failed to start execution record: ${e}`);
+      return 0;
+    }
+  }
+
+  async recordStep(params: RecordStepParams): Promise<void> {
+    if (!params.executionId) return;
+
+    try {
+      const costUsd = await this.estimateCost(
+        params.provider,
+        params.model,
+        params.usage,
+      );
+
+      await this.prisma.$executeRaw`
+        INSERT INTO ai_execution_step (
+          execution_id, step_order, type, provider, model, tool_name,
+          tokens_input, tokens_output, cost_usd, duration_ms,
+          input_summary, output_summary, success, error
+        ) VALUES (
+          ${params.executionId},
+          ${params.stepOrder},
+          CAST(${params.type} AS ai_execution_step_type_enum),
+          ${params.provider ?? null},
+          ${params.model ?? null},
+          ${params.toolName ?? null},
+          ${params.usage?.input ?? 0},
+          ${params.usage?.output ?? 0},
+          ${costUsd},
+          ${params.durationMs ?? 0},
+          ${params.inputSummary ? params.inputSummary.slice(0, 500) : null},
+          ${params.outputSummary ? params.outputSummary.slice(0, 500) : null},
+          ${params.success ?? true},
+          ${params.error ?? null}
+        )
+      `;
+    } catch (e) {
+      this.logger.warn(`Failed to record execution step: ${e}`);
+    }
+  }
+
+  async finish(
+    executionId: number,
+    status: 'completed' | 'failed' | 'cancelled',
+    error?: string,
+  ): Promise<void> {
+    if (!executionId) return;
+
+    try {
+      // Aggregate totals from steps
+      const totals = await this.prisma.$queryRaw<
+        Array<{ tokens_input: bigint; tokens_output: bigint; cost_usd: string }>
+      >`
+        SELECT
+          SUM(tokens_input)  AS tokens_input,
+          SUM(tokens_output) AS tokens_output,
+          SUM(cost_usd)      AS cost_usd
+        FROM ai_execution_step
+        WHERE execution_id = ${executionId}
+      `;
+
+      const t = totals[0];
+      const tokensInput = Number(t?.tokens_input || 0);
+      const tokensOutput = Number(t?.tokens_output || 0);
+      const costUsd = parseFloat(String(t?.cost_usd || 0));
+
+      await this.prisma.$executeRaw`
+        UPDATE ai_execution
+        SET
+          status        = CAST(${status} AS ai_execution_status_enum),
+          tokens_input  = ${tokensInput},
+          tokens_output = ${tokensOutput},
+          tokens_total  = ${tokensInput + tokensOutput},
+          cost_usd      = ${costUsd},
+          finished_at   = NOW(),
+          error         = ${error ?? null},
+          updated_at    = NOW()
+        WHERE id = ${executionId}
+      `;
+    } catch (e) {
+      this.logger.warn(`Failed to finish execution record ${executionId}: ${e}`);
+    }
+  }
+
+  async getExecution(executionId: number): Promise<AiExecutionRecord | null> {
+    const rows = await this.prisma.$queryRaw<AiExecutionRecord[]>`
+      SELECT * FROM ai_execution WHERE id = ${executionId} LIMIT 1
+    `;
+    return rows?.[0] || null;
+  }
+
+  async listExecutions(params: {
+    userId?: number;
+    contextSlug?: string;
+    limit?: number;
+    offset?: number;
+  }) {
+    const limit = Math.min(params.limit ?? 20, 100);
+    const offset = params.offset ?? 0;
+
+    // Use parameterized queries to prevent SQL injection
+    if (params.userId !== undefined && params.contextSlug !== undefined) {
+      return this.prisma.$queryRaw<AiExecutionRecord[]>`
+        SELECT * FROM ai_execution
+        WHERE user_id = ${params.userId} AND context_slug = ${params.contextSlug}
+        ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}
+      `;
+    }
+    if (params.userId !== undefined) {
+      return this.prisma.$queryRaw<AiExecutionRecord[]>`
+        SELECT * FROM ai_execution
+        WHERE user_id = ${params.userId}
+        ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}
+      `;
+    }
+    if (params.contextSlug !== undefined) {
+      return this.prisma.$queryRaw<AiExecutionRecord[]>`
+        SELECT * FROM ai_execution
+        WHERE context_slug = ${params.contextSlug}
+        ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}
+      `;
+    }
+    return this.prisma.$queryRaw<AiExecutionRecord[]>`
+      SELECT * FROM ai_execution
+      ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}
+    `;
+  }
+
+  // ── Cost estimation ───────────────────────────────────────────────────────
+
+  private async estimateCost(
+    provider?: string,
+    model?: string,
+    usage?: AiTokenUsage,
+  ): Promise<number> {
+    if (!provider || !model || !usage || (!usage.input && !usage.output)) {
+      return 0;
+    }
+
+    const pricing = await this.getPricing(provider, model);
+    if (!pricing) return 0;
+
+    const inputCost = (usage.input / 1_000_000) * Number(pricing.price_input_per_million);
+    const outputCost = (usage.output / 1_000_000) * Number(pricing.price_output_per_million);
+    const cachedCost =
+      usage.cached && pricing.price_cached_input_per_million
+        ? (usage.cached / 1_000_000) * Number(pricing.price_cached_input_per_million)
+        : 0;
+
+    return parseFloat((inputCost + outputCost + cachedCost).toFixed(8));
+  }
+
+  private async getPricing(provider: string, model: string): Promise<AiModelPricingRecord | null> {
+    const key = `${provider}:${model}`;
+
+    if (Date.now() - this.pricingLoadedAt > this.PRICING_TTL_MS) {
+      await this.loadPricingCache();
+    }
+
+    return this.pricingCache.get(key) || null;
+  }
+
+  private async loadPricingCache() {
+    try {
+      const rows = await this.prisma.$queryRaw<AiModelPricingRecord[]>`
+        SELECT * FROM ai_model_pricing WHERE is_active = TRUE ORDER BY valid_from DESC
+      `;
+      this.pricingCache.clear();
+      for (const row of rows) {
+        const key = `${row.provider}:${row.model}`;
+        // Only keep the most recent pricing entry per provider+model
+        if (!this.pricingCache.has(key)) {
+          this.pricingCache.set(key, row);
+        }
+      }
+      this.pricingLoadedAt = Date.now();
+    } catch (e) {
+      this.logger.warn(`Failed to load pricing cache: ${e}`);
+    }
+  }
+}

package/src/ai-instruction/ai-instruction.controller.ts

@@ -0,0 +1,73 @@
+import { Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  forwardRef,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { AiInstructionService } from './ai-instruction.service';
+import { CreateAiInstructionDTO } from './dto/create-ai-instruction.dto';
+import { UpdateAiInstructionDTO } from './dto/update-ai-instruction.dto';
+
+@Role()
+@Controller('ai-instruction')
+export class AiInstructionController {
+  constructor(
+    @Inject(forwardRef(() => AiInstructionService))
+    private readonly aiInstructionService: AiInstructionService,
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams) {
+    return this.aiInstructionService.list(paginationParams);
+  }
+
+  @Get(':id')
+  async getById(@Param('id', ParseIntPipe) id: number) {
+    return this.aiInstructionService.getById(id);
+  }
+
+  @Get('slug/:slug')
+  async getBySlug(@Param('slug') slug: string) {
+    return this.aiInstructionService.getBySlug(slug);
+  }
+
+  @Post()
+  async create(@Body() dto: CreateAiInstructionDTO) {
+    return this.aiInstructionService.create(dto);
+  }
+
+  @Patch(':id')
+  async update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateAiInstructionDTO,
+  ) {
+    return this.aiInstructionService.update(id, dto);
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.aiInstructionService.delete(data);
+  }
+
+  @Get(':id/versions')
+  async listVersions(@Param('id', ParseIntPipe) id: number) {
+    return this.aiInstructionService.listVersions(id);
+  }
+
+  @Post(':id/versions/:version/restore')
+  async restoreVersion(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('version', ParseIntPipe) version: number,
+  ) {
+    return this.aiInstructionService.restoreVersion(id, version);
+  }
+}

package/src/ai-instruction/ai-instruction.module.ts

@@ -0,0 +1,14 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { AiExecutionService } from './ai-execution.service';
+import { AiInstructionController } from './ai-instruction.controller';
+import { AiInstructionService } from './ai-instruction.service';
+import { AiPromptBuilderService } from './ai-prompt-builder.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [AiInstructionController],
+  providers: [AiInstructionService, AiExecutionService, AiPromptBuilderService],
+  exports: [AiInstructionService, AiExecutionService, AiPromptBuilderService],
+})
+export class AiInstructionModule {}