@easynet/agent-runtime 1.0.3 → 1.0.4

package/agent-runtime/scripts/resolve-deps.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * resolve-deps.js
+ *
+ * Run automatically via `preinstall` npm hook.
+ * In CI (CI=true), rewrites file: references in package.json to npm versions
+ * so that `npm install` can resolve them without local sibling directories.
+ *
+ * Local development: no-op (CI env var is not set).
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgPath = resolve(__dirname, '..', 'package.json');
+
+if (!process.env.CI) {
+  process.exit(0);
+}
+
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+let changed = false;
+
+// agent-skill is a private package — use git ref in CI
+const AGENT_SKILL_TOKEN = process.env.AGENT_SKILL_READ_TOKEN || process.env.GITHUB_TOKEN || '';
+
+for (const section of ['dependencies', 'devDependencies']) {
+  const deps = pkg[section];
+  if (!deps) continue;
+  for (const [name, version] of Object.entries(deps)) {
+    if (name.startsWith('@easynet/') && typeof version === 'string' && version.startsWith('file:')) {
+      let resolved;
+      if (name === '@easynet/agent-skill') {
+        if (!AGENT_SKILL_TOKEN) {
+          console.error('[resolve-deps] Missing AGENT_SKILL_READ_TOKEN (or GITHUB_TOKEN) for @easynet/agent-skill.');
+          process.exit(1);
+        }
+        resolved = `git+https://x-access-token:${AGENT_SKILL_TOKEN}@github.com/easynet-world/agent-skill.git#master`;
+      } else {
+        resolved = 'latest';
+      }
+      deps[name] = resolved;
+      changed = true;
+      console.log(`[resolve-deps] ${name}: file: → ${name === '@easynet/agent-skill' ? 'git+https://...' : resolved}`);
+    }
+  }
+}
+
+if (changed) {
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+  console.log('[resolve-deps] package.json updated for CI.');
+}

package/agent-runtime/src/agents/deep-agent.ts

@@ -0,0 +1,165 @@
+import {
+  createDeepAgent as createDeepAgentRuntime,
+  StateBackend,
+} from "deepagents";
+import { asObject, extractLastMessageText } from "@easynet/agent-common";
+import type { BaseAgentConfig, BotContext } from "../core/context.js";
+
+export interface DeepAgentRuntime {
+  agent: unknown;
+  run: (userMessage: string) => Promise<{ text: string; messages?: unknown }>;
+}
+
+export interface DeepAgentOptions {
+  agentName?: string;
+  systemPrompt?: string;
+  recursionLimit?: number;
+  autoWriteMemory?: boolean;
+  printSteps?: boolean;
+  fallbackText?: string;
+  commandWindowLabel?: string;
+}
+
+type Publish = (name: string, from: string, to: string, payload?: unknown) => void;
+
+interface DeepRuntimeConfig {
+  recursionLimit?: number;
+  printSteps: boolean;
+  fallbackText: string;
+  commandWindowLabel?: string;
+  namespace?: string;
+  autoWriteMemory: boolean;
+  autoWriteScope: "thread" | "cross_thread" | "knowledge" | "auto";
+  autoWriteMaxChars: number;
+  autoWriteUser: boolean;
+  autoWriteAssistant: boolean;
+  systemPrompt?: string;
+}
+
+function readAppString(appConfig: unknown, key: string): string | undefined {
+  const app = asObject(appConfig);
+  const value = app?.[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function readAppBoolean(appConfig: unknown, key: string): boolean | undefined {
+  const app = asObject(appConfig);
+  const value = app?.[key];
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function pickFirstAgentName(config: BaseAgentConfig | undefined): string | undefined {
+  return Object.keys(config?.app?.agent ?? {})[0];
+}
+
+function pickAgentConfig(config: BaseAgentConfig | undefined, agentName?: string) {
+  if (!agentName) return undefined;
+  return config?.app?.agent?.[agentName];
+}
+
+function resolveConfig<TConfig extends BaseAgentConfig>(ctx: BotContext<TConfig>, options: DeepAgentOptions): DeepRuntimeConfig {
+  const agentName = options.agentName ?? pickFirstAgentName(ctx.config);
+  const configDeep = pickAgentConfig(ctx.config, agentName);
+  const appConfig = ctx.config.app;
+  return {
+    recursionLimit: options.recursionLimit ?? configDeep?.recursionLimit,
+    printSteps: options.printSteps ?? configDeep?.printSteps ?? readAppBoolean(appConfig, "printSteps") ?? false,
+    fallbackText: options.fallbackText ?? configDeep?.fallbackText ?? readAppString(appConfig, "fallbackText") ?? "",
+    commandWindowLabel: options.commandWindowLabel ?? configDeep?.commandWindowLabel ?? readAppString(appConfig, "commandWindowLabel"),
+    namespace: configDeep?.memory?.namespace,
+    autoWriteMemory: options.autoWriteMemory ?? (configDeep?.memory?.auto_write ?? true),
+    autoWriteScope: configDeep?.memory?.auto_write_scope ?? "thread",
+    autoWriteMaxChars: configDeep?.memory?.auto_write_max_chars ?? 2400,
+    autoWriteUser: configDeep?.memory?.auto_write_user ?? true,
+    autoWriteAssistant: configDeep?.memory?.auto_write_assistant ?? true,
+    systemPrompt: options.systemPrompt ?? configDeep?.systemPrompt,
+  };
+}
+
+function resolveFinalText(text: string, fallbackText: string, commandWindowLabel?: string): string {
+  if (text.trim().length > 0) return text;
+  if (fallbackText.trim().length > 0) return fallbackText;
+  return commandWindowLabel ? `Command sent to ${commandWindowLabel}.` : text;
+}
+
+async function autoWriteIfNeeded<TConfig extends BaseAgentConfig>(
+  ctx: BotContext<TConfig>,
+  config: DeepRuntimeConfig,
+  userMessage: string,
+  finalText: string,
+  publish: Publish,
+): Promise<void> {
+  if (!config.namespace || !config.autoWriteMemory) return;
+
+  const scope = config.autoWriteScope === "auto" ? "thread" : config.autoWriteScope;
+  const writeItems: string[] = [];
+  if (config.autoWriteUser && userMessage.trim().length > 0) writeItems.push(`[user]\n${userMessage.trim()}`);
+  if (config.autoWriteAssistant && finalText.trim().length > 0) writeItems.push(`[assistant]\n${finalText.trim()}`);
+
+  const content = writeItems.join("\n\n").slice(0, Math.max(0, config.autoWriteMaxChars));
+  if (!content.length) return;
+
+  try {
+    publish("agent.deep.memory.write.start", "deep-agent", "memory", { type: scope, auto: true });
+    await ctx.memory.memorize(config.namespace, scope, content);
+    publish("agent.deep.memory.write.done", "memory", "deep-agent", { type: scope, auto: true });
+  } catch (err) {
+    publish("agent.deep.memory.write.error", "memory", "deep-agent", {
+      auto: true,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+}
+
+function updateConversation(history: Array<{ role: "user" | "assistant"; content: string }>, userMessage: string, finalText: string): void {
+  history.push({ role: "user", content: userMessage });
+  if (finalText.trim().length > 0) history.push({ role: "assistant", content: finalText });
+  if (history.length > 24) history.splice(0, history.length - 24);
+}
+
+function createAgent<TConfig extends BaseAgentConfig>(ctx: BotContext<TConfig>, systemPrompt?: string) {
+  type BackendConfig = { state: unknown };
+  return createDeepAgentRuntime({
+    model: ctx.llm,
+    tools: ctx.tools as unknown as Array<Record<string, unknown>>,
+    backend: (config: BackendConfig) => new StateBackend(config),
+    systemPrompt,
+  } as never) as unknown as {
+    invoke: (input: { messages: Array<{ role: "user" | "assistant"; content: string }> }) => Promise<unknown>;
+    withConfig?: (config: { recursionLimit: number }) => { invoke: (input: unknown) => Promise<unknown> };
+  };
+}
+
+export async function createDeepAgent<TConfig extends BaseAgentConfig>(ctx: BotContext<TConfig>, options: DeepAgentOptions = {}) {
+  const publish: Publish = (name, from, to, payload) => {
+    ctx.events.publish({ name, from, to, payload });
+  };
+
+  publish("agent.deep.init.start", "app", "deep-agent");
+  const config = resolveConfig(ctx, options);
+  const agent = createAgent(ctx, config.systemPrompt);
+  const conversationHistory: Array<{ role: "user" | "assistant"; content: string }> = [];
+  publish("agent.deep.init.done", "deep-agent", "app");
+
+  return {
+    agent,
+    async run(userMessage: string): Promise<{ text: string; messages?: unknown }> {
+      publish("agent.deep.run.start", "user", "deep-agent", { userMessage });
+      if (config.printSteps) console.error(`[deep] user: ${userMessage}`);
+
+      const runnable = typeof config.recursionLimit === "number"
+        ? (agent.withConfig?.({ recursionLimit: config.recursionLimit }) ?? agent)
+        : agent;
+      const result = await runnable.invoke({ messages: [...conversationHistory, { role: "user", content: userMessage }] });
+      const messages = (result as { messages?: unknown } | null | undefined)?.messages ?? result;
+      const finalText = resolveFinalText(extractLastMessageText(result), config.fallbackText, config.commandWindowLabel);
+
+      updateConversation(conversationHistory, userMessage, finalText);
+      await autoWriteIfNeeded(ctx, config, userMessage, finalText, publish);
+      if (config.printSteps) console.error(`[deep] assistant: ${finalText}`);
+
+      publish("agent.deep.run.done", "deep-agent", "user", { text: finalText });
+      return { text: finalText, messages };
+    },
+  };
+}

package/agent-runtime/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("");
+}