@garrix82/reactgenie-dsl 1.0.1 → 1.0.2

package/lib/nl/nl-parser-groq.ts

@@ -1,510 +0,0 @@
-import { AgentResponsePayload, PromptGen } from "./prompt-gen";
-import { getLLMMonitor, type LLMMonitor } from "./llm-monitoring";
-import {
-  buildCommandRepairMessages,
-  buildFallbackAgentResponse,
-  CommandValidator,
-  createJsonChatCompletion,
-  DEFAULT_SEMANTIC_PARSER_SAMPLING,
-  extractStructuredAgentResponse,
-  extractStructuredCommand,
-  getStructuredAgentResponseFormat,
-  getStructuredResponseFormat,
-  normalizeAgentResponse,
-  normalizeBaseUrl,
-  SamplingParams,
-} from "./nl-parser-utils";
-export type { SamplingParams } from "./nl-parser-utils";
-
-function buildChatCompletionsEndpoint(baseUrl?: string): string {
-  const resolvedBase =
-    normalizeBaseUrl(baseUrl && baseUrl.trim().length > 0
-      ? baseUrl
-      : "https://api.groq.com/openai/v1");
-
-  if (resolvedBase.endsWith("/chat/completions")) {
-    return resolvedBase;
-  }
-  if (resolvedBase.endsWith("/openai/v1") || resolvedBase.endsWith("/v1")) {
-    return `${resolvedBase}/chat/completions`;
-  }
-  return `${resolvedBase}/openai/v1/chat/completions`;
-}
-
-function asFiniteNumber(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function extractCostMetrics(response: any): {
-  inputCost?: number;
-  outputCost?: number;
-  totalCost?: number;
-} {
-  const usage = response?.usage ?? response?.usage_metadata ?? {};
-  const inputCost =
-    asFiniteNumber(usage?.input_cost) ??
-    asFiniteNumber(usage?.prompt_cost) ??
-    asFiniteNumber(usage?.prompt_cost_usd);
-  const outputCost =
-    asFiniteNumber(usage?.output_cost) ??
-    asFiniteNumber(usage?.completion_cost) ??
-    asFiniteNumber(usage?.completion_cost_usd);
-  const totalCost =
-    asFiniteNumber(usage?.total_cost) ??
-    asFiniteNumber(usage?.cost) ??
-    asFiniteNumber(usage?.total_cost_usd) ??
-    (typeof inputCost === "number" && typeof outputCost === "number"
-      ? inputCost + outputCost
-      : undefined);
-
-  return {
-    ...(typeof inputCost === "number" ? { inputCost } : {}),
-    ...(typeof outputCost === "number" ? { outputCost } : {}),
-    ...(typeof totalCost === "number" ? { totalCost } : {}),
-  };
-}
-
-export class NlParserGroq {
-  private chatCompletionsEndpoint: string;
-  private samplingParams: SamplingParams;
-  private llmMonitor!: LLMMonitor;
-
-  constructor(
-    public prompt: PromptGen,
-    private apiKey: string,
-    private model: string = process.env.SEMANTIC_MODEL || "llama-3.3-70b-versatile",
-    samplingParams?: SamplingParams,
-    private baseURL?: string,
-    langsmithApiKey?: string,
-    langsmithProject?: string,
-    langsmithEndpoint?: string,
-    private validateCommand?: CommandValidator
-  ) {
-    this.chatCompletionsEndpoint = buildChatCompletionsEndpoint(this.baseURL);
-
-    this.llmMonitor = getLLMMonitor({
-      apiKey: langsmithApiKey,
-      project: langsmithProject,
-      endpoint: langsmithEndpoint,
-    });
-    
-    // Default parameters optimized for semantic parsing
-    this.samplingParams = {
-      ...DEFAULT_SEMANTIC_PARSER_SAMPLING,
-      ...samplingParams,
-    };
-  }
-
-  private async createChatCompletion(body: Record<string, unknown>): Promise<any> {
-    return createJsonChatCompletion({
-      endpoint: this.chatCompletionsEndpoint,
-      apiKey: this.apiKey,
-      body,
-      provider: "groq",
-      requestLabel: "LLM proxy request failed",
-      invalidPayloadLabel: "LLM proxy returned an invalid JSON payload",
-    });
-  }
-
-  async oldParse(nl: string): Promise<string | null> {
-    const promptText = this.prompt.prompt(nl);
-    const startTime = Date.now();
-    
-    try {
-      const response = await this.llmMonitor.traceCall(
-        "oldParse",
-        { model: this.model, provider: "groq" },
-        async () => {
-          return await this.runStructuredCommandMessages(
-            [
-              {
-                role: "user",
-                content: promptText,
-              },
-            ],
-            false
-          );
-        }
-      );
-
-      const completion = await this.validateOrRepairCommand(
-        "oldParse",
-        "legacy_prompt",
-        promptText,
-        response.command,
-        promptText
-      );
-
-      // Log metrics
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        promptTokens: response.response.usage?.prompt_tokens,
-        completionTokens: response.response.usage?.completion_tokens,
-        totalTokens: response.response.usage?.total_tokens,
-        ...extractCostMetrics(response.response),
-        prompt: promptText,
-        completion,
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-      });
-
-      return completion;
-    } catch (error) {
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        prompt: promptText,
-        completion: null,
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async parse(nl: string): Promise<string | null> {
-    const startTime = Date.now();
-
-    const promptVariants: Array<{ label: string; text: string }> = [];
-    const defaultPrompt = this.prompt.zero_shot_prompt(nl);
-    promptVariants.push({ label: "filtered", text: defaultPrompt });
-
-    let usedPromptText = defaultPrompt;
-    let completion: string | null = null;
-    let response: any;
-    let lastError: unknown;
-    
-    try {
-      const runParse = async (strict: boolean, promptText: string) => {
-        return this.runStructuredCommandMessages(
-          [
-            {
-              role: "user",
-              content: promptText,
-            },
-          ],
-          strict
-        );
-      };
-
-      for (const promptVariant of promptVariants) {
-        usedPromptText = promptVariant.text;
-        try {
-          const result = await this.llmMonitor.traceCall(
-            `parse_${promptVariant.label}`,
-            { model: this.model, provider: "groq" },
-            async () => runParse(false, promptVariant.text)
-          );
-          response = result.response;
-          completion = await this.validateOrRepairCommand(
-            "parse",
-            promptVariant.label,
-            nl,
-            result.command,
-            usedPromptText
-          );
-          break;
-        } catch (error) {
-          try {
-            const result = await this.llmMonitor.traceCall(
-              `parse_${promptVariant.label}`,
-              { model: this.model, provider: "groq" },
-              async () => runParse(true, promptVariant.text)
-            );
-            response = result.response;
-            completion = await this.validateOrRepairCommand(
-              "parse",
-              promptVariant.label,
-              nl,
-              result.command,
-              usedPromptText
-            );
-            break;
-          } catch (strictError) {
-            lastError = strictError;
-          }
-        }
-      }
-
-      if (!completion || !response) {
-        throw (lastError instanceof Error
-          ? lastError
-          : new Error("Groq parse failed for filtered prompt"));
-      }
-      
-      // Log metrics
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        promptTokens: response.usage?.prompt_tokens,
-        completionTokens: response.usage?.completion_tokens,
-        totalTokens: response.usage?.total_tokens,
-        ...extractCostMetrics(response),
-        prompt: usedPromptText,
-        completion,
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-      });
-
-      return completion;
-    } catch (error) {
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        prompt: usedPromptText,
-        completion: null,
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async parseGpt4(nl: string): Promise<string | null> {
-    const promptText = this.prompt.prompt(nl);
-    const startTime = Date.now();
-    
-    try {
-      const runParse = async (strict: boolean) => {
-        return this.runStructuredCommandMessages(
-          [
-            {
-              role: "system",
-              content: "only generate one line of code",
-            },
-            {
-              role: "user",
-              content: promptText,
-            },
-          ],
-          strict
-        );
-      };
-
-      let response: any;
-      let completion: string | null = null;
-
-      try {
-        const result = await this.llmMonitor.traceCall(
-          "parseGpt4",
-          { model: this.model, provider: "groq" },
-          async () => runParse(false)
-        );
-        response = result.response;
-        completion = result.command;
-      } catch (error) {
-        const result = await this.llmMonitor.traceCall(
-          "parseGpt4",
-          { model: this.model, provider: "groq" },
-          async () => runParse(true)
-        );
-        response = result.response;
-        completion = result.command;
-      }
-      
-      const validatedCompletion = completion
-          ? await this.validateOrRepairCommand(
-            "parseGpt4",
-            "legacy_prompt",
-            nl,
-            completion,
-            promptText
-          )
-        : completion;
-
-      // Log metrics
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        promptTokens: response.usage?.prompt_tokens,
-        completionTokens: response.usage?.completion_tokens,
-        totalTokens: response.usage?.total_tokens,
-        ...extractCostMetrics(response),
-        prompt: promptText,
-        completion: validatedCompletion,
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-      });
-
-      return validatedCompletion;
-    } catch (error) {
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        prompt: promptText,
-        completion: null,
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async respond(
-    nl: string,
-    parsed: string,
-    result: string
-  ): Promise<AgentResponsePayload | null> {
-    const promptText = this.prompt.response_prompt(nl, parsed, result);
-    const startTime = Date.now();
-    
-    try {
-      const runRespond = async (strict: boolean) => {
-        const response = await this.createChatCompletion({
-          model: this.model,
-          messages: [
-            {
-              role: "system",
-              content: "Return only a strict JSON object for agent_response_json.",
-            },
-            {
-              role: "user",
-              content: promptText,
-            },
-          ],
-          temperature: this.samplingParams.temperature,
-          max_tokens: 256,
-          top_p: this.samplingParams.top_p,
-          frequency_penalty: this.samplingParams.frequency_penalty,
-          presence_penalty: this.samplingParams.presence_penalty,
-          response_format: getStructuredAgentResponseFormat(strict),
-        });
-
-        const raw = response.choices[0]?.message?.content ?? null;
-        const payload = extractStructuredAgentResponse(raw);
-        if (!payload) {
-          throw new Error("Groq structured output missing agent response payload");
-        }
-        return { response, payload };
-      };
-
-      let response: any;
-      let completion: AgentResponsePayload | null = null;
-
-      try {
-        const result = await this.llmMonitor.traceCall(
-          "respond",
-          { model: this.model, provider: "groq" },
-          async () => runRespond(false)
-        );
-        response = result.response;
-        completion = result.payload;
-      } catch {
-        const result = await this.llmMonitor.traceCall(
-          "respond",
-          { model: this.model, provider: "groq" },
-          async () => runRespond(true)
-        );
-        response = result.response;
-        completion = result.payload;
-      }
-
-      const normalizedCompletion = completion
-        ? normalizeAgentResponse(completion)
-        : buildFallbackAgentResponse(parsed, result);
-      
-      // Log metrics
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        promptTokens: response.usage?.prompt_tokens,
-        completionTokens: response.usage?.completion_tokens,
-        totalTokens: response.usage?.total_tokens,
-        ...extractCostMetrics(response),
-        prompt: promptText,
-        completion: JSON.stringify(normalizedCompletion),
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-      });
-
-      return normalizedCompletion;
-    } catch (error) {
-      const fallbackResponse = buildFallbackAgentResponse(parsed, result);
-      await this.llmMonitor.logCall({
-        model: this.model,
-        provider: "groq",
-        prompt: promptText,
-        completion: JSON.stringify(fallbackResponse),
-        latency: Date.now() - startTime,
-        timestamp: new Date(),
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return fallbackResponse;
-    }
-  }
-
-  private async runStructuredCommandMessages(
-    messages: ReadonlyArray<{
-      role: "system" | "user" | "assistant";
-      content: string;
-    }>,
-    strict: boolean
-  ): Promise<{ response: any; command: string }> {
-    const response = await this.createChatCompletion({
-      model: this.model,
-      messages: [...messages],
-      temperature: this.samplingParams.temperature,
-      max_tokens: 256,
-      top_p: this.samplingParams.top_p,
-      frequency_penalty: this.samplingParams.frequency_penalty,
-      presence_penalty: this.samplingParams.presence_penalty,
-      response_format: getStructuredResponseFormat(strict),
-    });
-
-    const raw = response.choices[0]?.message?.content ?? null;
-    const command = extractStructuredCommand(raw);
-    if (!command) {
-      throw new Error("Groq structured output missing command");
-    }
-    return { response, command };
-  }
-
-  private async validateOrRepairCommand(
-    traceName: string,
-    promptLabel: string,
-    userUtterance: string,
-    command: string,
-    lastUsedPrompt?: string
-  ): Promise<string> {
-    if (!this.validateCommand) {
-      return command;
-    }
-
-    try {
-      await this.validateCommand(command);
-      return command;
-    } catch (validationError) {
-      const messages = buildCommandRepairMessages(
-        userUtterance,
-        command,
-        validationError instanceof Error ? validationError.message : String(validationError),
-        lastUsedPrompt
-      );
-
-      let lastError: unknown = validationError;
-      for (const strict of [false, true]) {
-        try {
-          const repaired = await this.llmMonitor.traceCall(
-            `${traceName}_${promptLabel}_repair_${strict ? "strict" : "lenient"}`,
-            { model: this.model, provider: "groq" },
-            async () => this.runStructuredCommandMessages(messages, strict)
-          );
-          await this.validateCommand(repaired.command);
-          return repaired.command;
-        } catch (repairError) {
-          lastError = repairError;
-        }
-      }
-
-      throw (
-        lastError instanceof Error
-          ? lastError
-          : new Error("Groq repair failed after semantic validation")
-      );
-    }
-  }
-}