@garrix82/reactgenie-dsl 1.0.0

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

@@ -0,0 +1,310 @@
+import { AgentResponsePayload, PromptGen, ResponseSeverity } from "./prompt-gen";
+
+export interface PromptWithBroadFallback extends PromptGen {
+  zero_shot_prompt_broad?: (user_utterance: string) => string;
+}
+
+export type CommandValidator = (command: string) => Promise<void>;
+
+export interface SamplingParams {
+  temperature?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+}
+
+export const DEFAULT_SEMANTIC_PARSER_SAMPLING: Required<SamplingParams> = {
+  temperature: 0.2,
+  top_p: 1,
+  frequency_penalty: 0,
+  presence_penalty: 0,
+};
+
+const DSL_COMMAND_SCHEMA = {
+  name: "dsl_command",
+  schema: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "Single DSL command string to execute.",
+      },
+    },
+    required: ["command"],
+    additionalProperties: false,
+  },
+} as const;
+
+const AGENT_RESPONSE_SCHEMA = {
+  name: "agent_response",
+  schema: {
+    type: "object",
+    properties: {
+      minimalText: {
+        type: "string",
+        description: "Short, speech-friendly response.",
+      },
+      fullText: {
+        type: "string",
+        description: "More informative response for on-screen UI.",
+      },
+      type: {
+        type: "string",
+        enum: ["info", "error", "success", "warning"],
+      },
+      shouldSpeak: {
+        type: "boolean",
+      },
+    },
+    required: ["minimalText", "fullText", "type", "shouldSpeak"],
+    additionalProperties: false,
+  },
+} as const;
+
+export function getStructuredResponseFormat(strict: boolean) {
+  return {
+    type: "json_schema",
+    json_schema: {
+      name: DSL_COMMAND_SCHEMA.name,
+      strict,
+      schema: DSL_COMMAND_SCHEMA.schema,
+    },
+  } as const;
+}
+
+export function getStructuredResponseTextFormat(strict: boolean) {
+  return {
+    type: "json_schema",
+    name: DSL_COMMAND_SCHEMA.name,
+    strict,
+    schema: DSL_COMMAND_SCHEMA.schema,
+  } as const;
+}
+
+export function getStructuredAgentResponseFormat(strict: boolean) {
+  return {
+    type: "json_schema",
+    json_schema: {
+      name: AGENT_RESPONSE_SCHEMA.name,
+      strict,
+      schema: AGENT_RESPONSE_SCHEMA.schema,
+    },
+  } as const;
+}
+
+export function extractStructuredCommand(raw?: string | null): string | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.command === "string") {
+      return parsed.command.trim();
+    }
+  } catch {
+    // ignore parse errors
+  }
+  return null;
+}
+
+export function extractResponseOutputText(response: any): string | null {
+  if (typeof response?.output_text === "string" && response.output_text.trim()) {
+    return response.output_text;
+  }
+
+  const output = Array.isArray(response?.output) ? response.output : [];
+  const parts: string[] = [];
+  for (const item of output) {
+    const content = Array.isArray(item?.content) ? item.content : [];
+    for (const part of content) {
+      if (typeof part?.text === "string" && part.text) {
+        parts.push(part.text);
+      } else if (typeof part?.output_text === "string" && part.output_text) {
+        parts.push(part.output_text);
+      }
+    }
+  }
+
+  return parts.length > 0 ? parts.join("") : null;
+}
+
+export function truncateText(value: string, maxLength: number): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+function normalizeMinimalText(value?: string): string {
+  const collapsed = (value || "Completed").replace(/\s+/g, " ").trim();
+  if (!collapsed) {
+    return "Completed";
+  }
+  const words = collapsed.split(" ").slice(0, 2);
+  return truncateText(words.join(" "), 24);
+}
+
+function normalizeSeverity(value: unknown): ResponseSeverity {
+  if (
+    value === "info" ||
+    value === "error" ||
+    value === "success" ||
+    value === "warning"
+  ) {
+    return value;
+  }
+  return "info";
+}
+
+export function normalizeAgentResponse(
+  payload: Partial<AgentResponsePayload>
+): AgentResponsePayload {
+  const minimal = normalizeMinimalText(payload.minimalText);
+  const full = truncateText(
+    (payload.fullText || payload.minimalText || "Completed").trim(),
+    240
+  );
+  return {
+    minimalText: minimal || "Completed",
+    fullText: full || minimal || "Completed",
+    type: normalizeSeverity(payload.type),
+    shouldSpeak:
+      typeof payload.shouldSpeak === "boolean" ? payload.shouldSpeak : true,
+  };
+}
+
+export function extractStructuredAgentResponse(
+  raw?: string | null
+): AgentResponsePayload | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return normalizeAgentResponse(parsed as Partial<AgentResponsePayload>);
+  } catch {
+    return null;
+  }
+}
+
+export function buildFallbackAgentResponse(
+  parsedDsl: string,
+  resultContext: string
+): AgentResponsePayload {
+  const lowResultContext = resultContext.toLowerCase();
+  const isError =
+    lowResultContext.includes("error") || lowResultContext.includes("failed");
+  const responseType: ResponseSeverity = isError ? "error" : "success";
+  const intent = parsedDsl.split(";")[0]?.trim() || "command";
+
+  if (isError) {
+    return {
+      minimalText: "Retry task",
+      fullText:
+        "I couldn't complete that request. Please try rephrasing or checking the target item.",
+      type: responseType,
+      shouldSpeak: true,
+    };
+  }
+
+  return {
+    minimalText: "Completed",
+    fullText: truncateText(`Done: ${intent}`, 240),
+    type: responseType,
+    shouldSpeak: true,
+  };
+}
+
+export function buildCommandRepairMessages(
+  userUtterance: string,
+  invalidCommand: string,
+  validationError: string,
+  lastUsedPrompt?: string
+) {
+  return [
+    {
+      role: "user",
+      content: lastUsedPrompt || `Original user utterance: ${userUtterance}`,
+    },
+    {
+      role: "assistant",
+      content: invalidCommand,
+    },
+    {
+      role: "user",
+      content:
+        "The previous DSL command is invalid.\n" +
+        `validation_error: ${validationError}\n` +
+        "Rewrite only the DSL command so it satisfies the original user utterance.\n" +
+        "Keep the original intent. Do not explain anything.",
+    },
+  ] as const;
+}
+
+export function buildCommandRepairInputText(
+  userUtterance: string,
+  invalidCommand: string,
+  validationError: string
+): string {
+  return (
+    "The previous DSL command is invalid.\n" +
+    `original_user_utterance: ${userUtterance}\n` +
+    `invalid_command: ${invalidCommand}\n` +
+    `validation_error: ${validationError}\n` +
+    "Rewrite only the DSL command so it satisfies the original user utterance.\n" +
+    "Keep the original intent. Do not explain anything."
+  );
+}
+
+export function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+export async function createJsonChatCompletion(params: {
+  endpoint: string;
+  apiKey: string;
+  body: Record<string, unknown>;
+  provider?: "openai" | "groq";
+  requestLabel: string;
+  invalidPayloadLabel: string;
+}): Promise<any> {
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+  };
+  if (params.apiKey) {
+    headers.authorization = `Bearer ${params.apiKey}`;
+  }
+  if (params.provider) {
+    headers["x-genie-provider"] = params.provider;
+  }
+
+  const response = await fetch(params.endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(params.body),
+  });
+
+  const text = await response.text();
+  let payload: any = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = null;
+  }
+
+  if (!response.ok) {
+    const details = payload?.error
+      ? typeof payload.error === "string"
+        ? payload.error
+        : JSON.stringify(payload.error)
+      : text;
+    throw new Error(
+      `${params.requestLabel} (${response.status})${details ? `: ${details}` : ""}`
+    );
+  }
+
+  if (!payload || typeof payload !== "object") {
+    throw new Error(params.invalidPayloadLabel);
+  }
+
+  return payload;
+}