@easynet/agent-runtime 1.0.2 → 1.0.4

package/src/agents/react-agent.helpers.ts

@@ -0,0 +1,227 @@
+import type { BaseMessageLike } from "@langchain/core/messages";
+import type { LanguageModelLike } from "@langchain/core/language_models/base";
+import { asObject } from "@easynet/agent-common";
+import type { BaseAgentConfig } from "../core/context.js";
+
+export interface MessageLike {
+  type?: string;
+  role?: string;
+  content?: string | unknown;
+  tool_calls?: Array<{ name?: string; args?: unknown; id?: string }>;
+  name?: string;
+  tool_call_id?: string;
+}
+
+export interface ToolRunStats {
+  invoked: number;
+  succeeded: number;
+  failed: number;
+  lastError?: string;
+}
+
+function toMessageText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => {
+      if (typeof block === "string") return block;
+      if (typeof block === "object" && block !== null && "text" in block) {
+        const text = (block as { text?: unknown }).text;
+        return typeof text === "string" ? text : "";
+      }
+      return "";
+    })
+    .join("");
+}
+
+export function inferMemoryTypeByStructure(content: string): "thread" | "cross_thread" {
+  const text = content.trim();
+  if (!text) return "thread";
+
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const duplicateRatio = lines.length > 0 ? 1 - new Set(lines).size / lines.length : 0;
+  const symbolCount = (text.match(/[^\p{L}\p{N}\s]/gu) ?? []).length;
+  const symbolRatio = symbolCount / Math.max(1, text.length);
+
+  if (text.length > 1200) return "thread";
+  if (lines.length > 18) return "thread";
+  if (duplicateRatio > 0.35) return "thread";
+  if (symbolRatio > 0.22) return "thread";
+  return "cross_thread";
+}
+
+export async function inferMemoryTypeWithModel(
+  llm: LanguageModelLike,
+  content: string,
+): Promise<"thread" | "cross_thread" | null> {
+  const classifierPrompt = [
+    "Classify memory scope for an AI agent.",
+    "Return strict JSON only: {\"type\":\"thread|cross_thread\",\"confidence\":0..1}.",
+    "Decision policy:",
+    "- thread: temporary session context, command output, logs, transient task state, step-by-step investigation details.",
+    "- cross_thread: stable user preferences, durable profile facts, long-lived constraints reusable in future sessions.",
+    "Use semantic judgment, not keyword matching.",
+  ].join("\n");
+
+  try {
+    const response = await llm.invoke([
+      { role: "system", content: classifierPrompt },
+      { role: "user", content },
+    ]);
+    const text = toMessageText((response as { content?: unknown }).content).trim();
+    const jsonBlob = text.match(/\{[\s\S]*\}/)?.[0] ?? text;
+    const parsed = JSON.parse(jsonBlob) as { type?: unknown; confidence?: unknown };
+    const type = parsed.type === "thread" || parsed.type === "cross_thread" ? parsed.type : null;
+    const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
+    return type && confidence >= 0.6 ? type : null;
+  } catch {
+    return null;
+  }
+}
+
+export function deriveFallbackTextFromMessages(
+  messages: BaseMessageLike[],
+  opts: { fallbackText: string; commandWindowLabel?: string },
+): string {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i] as MessageLike;
+    const type = msg?.type ?? msg?.role ?? "";
+    if (type !== "tool" && !msg?.tool_call_id) continue;
+
+    const raw = typeof msg.content === "string"
+      ? msg.content
+      : msg.content != null
+        ? String(msg.content)
+        : "";
+    if (!raw.trim()) continue;
+
+    try {
+      const parsed = JSON.parse(raw) as {
+        result?: { command?: string; windowId?: number; tabIndex?: number; to?: string; serviceType?: string };
+        evidence?: Array<{ summary?: string }>;
+      };
+
+      const summary = parsed.evidence?.find((item) => item?.summary)?.summary;
+      if (typeof summary === "string" && summary.trim()) return summary.trim();
+
+      const to = parsed.result?.to?.trim();
+      const serviceType = parsed.result?.serviceType?.trim();
+      if (to) return serviceType ? `Sent ${serviceType} message to ${to}.` : `Sent message to ${to}.`;
+
+      const command = parsed.result?.command?.trim();
+      if (!command) continue;
+      const windowId = parsed.result?.windowId;
+      const tabIndex = parsed.result?.tabIndex;
+      if (typeof windowId === "number" && typeof tabIndex === "number") {
+        return `Executed command in ${opts.commandWindowLabel ?? "window"} ${windowId}, tab ${tabIndex}: ${command}`;
+      }
+      return `Executed command: ${command}`;
+    } catch {
+      return raw.length > 200 ? `${raw.slice(0, 200)}...` : raw;
+    }
+  }
+  return opts.fallbackText;
+}
+
+export function hasToolMessages(messages: unknown): boolean {
+  const list = Array.isArray(messages) ? messages : [];
+  for (const item of list) {
+    const msg = item as MessageLike;
+    const type = msg?.type ?? msg?.role ?? "";
+    if (type === "tool" || Boolean(msg?.tool_call_id) || (msg?.tool_calls?.length ?? 0) > 0) return true;
+  }
+  return false;
+}
+
+export function extractSchemaKeys(schema: unknown): string[] {
+  if (!schema || typeof schema !== "object") return [];
+  const rec = schema as Record<string, unknown>;
+  const properties = rec.properties;
+  if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+    return Object.keys(properties as Record<string, unknown>);
+  }
+  const shape = rec.shape;
+  if (shape && typeof shape === "object" && !Array.isArray(shape)) {
+    return Object.keys(shape as Record<string, unknown>);
+  }
+  return [];
+}
+
+export function buildPtcHint(input: { taskIntent: string; stats: ToolRunStats; toolSignatures: string[] }): string {
+  return [
+    "[PTC_FEEDBACK]",
+    `TaskIntent: ${input.taskIntent}`,
+    `ToolStats: invoked=${input.stats.invoked}, succeeded=${input.stats.succeeded}, failed=${input.stats.failed}`,
+    input.stats.lastError ? `LastToolError: ${input.stats.lastError}` : "",
+    "Action: Retry using available tools. Do not claim tools are unavailable.",
+    "Action: If previous tool args were invalid, correct arguments strictly by schema.",
+    "Action: If a tool is needed, emit a valid tool call instead of plain explanation.",
+    `AvailableTools: ${input.toolSignatures.join("; ")}`,
+  ].filter((line) => line.length > 0).join("\n");
+}
+
+export function readAppString(appConfig: unknown, key: string): string | undefined {
+  const app = asObject(appConfig);
+  const value = app?.[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+export function readAppBoolean(appConfig: unknown, key: string): boolean | undefined {
+  const app = asObject(appConfig);
+  const value = app?.[key];
+  return typeof value === "boolean" ? value : undefined;
+}
+
+export function pickFirstAgentName(config: BaseAgentConfig | undefined): string | undefined {
+  return Object.keys(config?.app?.agent ?? {})[0];
+}
+
+export function pickAgentConfig(config: BaseAgentConfig | undefined, agentName?: string) {
+  if (!agentName) return undefined;
+  return config?.app?.agent?.[agentName];
+}
+
+export function printReactSteps(messages: unknown): void {
+  const list = Array.isArray(messages) ? messages : [];
+  let stepIndex = 0;
+
+  for (let i = 0; i < list.length; i += 1) {
+    const msg = list[i] as MessageLike;
+    const type = msg?.type ?? msg?.role ?? "";
+    const content = msg?.content;
+    const contentStr = typeof content === "string"
+      ? content
+      : typeof content === "object" && content !== null && Array.isArray(content)
+        ? (content as { text?: string }[]).map((block) => block.text ?? JSON.stringify(block)).join("")
+        : content != null
+          ? String(content)
+          : "";
+
+    if (type === "human" || (type === "user" && !msg.tool_calls)) {
+      if (contentStr.trim()) console.error(`\n--- Step (user) ---\n${contentStr.trim()}`);
+      continue;
+    }
+
+    if (type === "ai" || type === "assistant") {
+      if (!msg.tool_calls?.length) continue;
+      stepIndex += 1;
+      if (contentStr.trim()) console.error(`\n--- ReAct Step ${stepIndex}: Thought ---\n${contentStr.trim()}`);
+      for (const toolCall of msg.tool_calls) {
+        const name = toolCall?.name ?? "?";
+        const args = typeof toolCall?.args === "object" && toolCall?.args !== null
+          ? JSON.stringify(toolCall.args)
+          : String(toolCall?.args ?? "");
+        console.error(`--- ReAct Step ${stepIndex}: Action ---\n${name}(${args})`);
+      }
+      continue;
+    }
+
+    if (type === "tool" || msg?.tool_call_id) {
+      const toolName = msg?.name ?? "tool";
+      const observation = contentStr.length > 200 ? `${contentStr.slice(0, 200)}...` : contentStr;
+      console.error(`--- ReAct Step ${stepIndex}: Observation (${toolName}) ---\n${observation || "(empty)"}`);
+    }
+  }
+
+  console.error("");
+}