veryfront 0.1.144 → 0.1.145

package/src/src/agent/runtime/resume-session.ts

@@ -0,0 +1,319 @@
+import * as dntShim from "../../../_dnt.shims.js";
+export type RunSessionStatus = "running" | "waiting" | "completed" | "cancelled" | "failed";
+
+export class RunCancelledError extends Error {
+  constructor(message = "Run cancelled") {
+    super(message);
+    this.name = "RunCancelledError";
+  }
+}
+
+export class RunAlreadyExistsError extends Error {
+  constructor(runId: string) {
+    super(`Run "${runId}" is already active`);
+    this.name = "RunAlreadyExistsError";
+  }
+}
+
+export class RunNotActiveError extends Error {
+  constructor(runId: string) {
+    super(`Run "${runId}" is not active`);
+    this.name = "RunNotActiveError";
+  }
+}
+
+export class WaitNotPendingError extends Error {
+  constructor(runId: string, waitKey: string) {
+    super(`Run "${runId}" is not waiting for "${waitKey}"`);
+    this.name = "WaitNotPendingError";
+  }
+}
+
+export class WaitConflictError extends Error {
+  constructor(runId: string, waitKey: string) {
+    super(`Conflicting resume value for run "${runId}" and wait key "${waitKey}"`);
+    this.name = "WaitConflictError";
+  }
+}
+
+export interface SubmitResumeValueOutcome {
+  accepted: true;
+  duplicate?: true;
+}
+
+type SubmittedValue<T> = {
+  value: T;
+  key: string;
+};
+
+type WaitingState<T> = {
+  waitKey: string;
+  resolve: (value: SubmittedValue<T>) => void;
+  reject: (reason?: unknown) => void;
+};
+
+type RunSession<T> = {
+  runId: string;
+  status: RunSessionStatus;
+  abortController: AbortController;
+  waitingState: WaitingState<T> | null;
+  submittedValues: Map<string, SubmittedValue<T>>;
+  waitingTimeoutId: number | null;
+  sessionTimeoutId: number | null;
+};
+
+const DEFAULT_WAITING_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_MAX_CONCURRENT_SESSIONS = 100;
+
+export interface RunResumeSessionManagerOptions<T> {
+  waitingTtlMs?: number;
+  sessionTtlMs?: number | null;
+  maxConcurrentSessions?: number;
+  setTimeoutFn?: typeof dntShim.setTimeout;
+  clearTimeoutFn?: typeof clearTimeout;
+  getConflictKey?: (value: T) => string;
+}
+
+function defaultConflictKey(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+export class RunResumeSessionManager<T> {
+  private readonly sessions = new Map<string, RunSession<T>>();
+
+  constructor(
+    private readonly options: RunResumeSessionManagerOptions<T> = {},
+  ) {}
+
+  private get waitingTtlMs(): number {
+    return this.options.waitingTtlMs ?? DEFAULT_WAITING_TTL_MS;
+  }
+
+  private get sessionTtlMs(): number | null {
+    return this.options.sessionTtlMs ?? null;
+  }
+
+  private get maxConcurrentSessions(): number {
+    return this.options.maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
+  }
+
+  private get setTimeoutFn(): typeof dntShim.setTimeout {
+    return this.options.setTimeoutFn ?? dntShim.dntGlobalThis.setTimeout.bind(dntShim.dntGlobalThis);
+  }
+
+  private get clearTimeoutFn(): typeof clearTimeout {
+    return this.options.clearTimeoutFn ?? globalThis.clearTimeout.bind(dntShim.dntGlobalThis);
+  }
+
+  private getConflictKey(value: T): string {
+    const createConflictKey = this.options.getConflictKey ?? defaultConflictKey;
+    return createConflictKey(value);
+  }
+
+  private clearWaitingTimeout(session: RunSession<T>): void {
+    if (session.waitingTimeoutId === null) return;
+    this.clearTimeoutFn(session.waitingTimeoutId);
+    session.waitingTimeoutId = null;
+  }
+
+  private clearSessionTimeout(session: RunSession<T>): void {
+    if (session.sessionTimeoutId === null) return;
+    this.clearTimeoutFn(session.sessionTimeoutId);
+    session.sessionTimeoutId = null;
+  }
+
+  private scheduleSessionTimeout(session: RunSession<T>): void {
+    if (this.sessionTtlMs === null) return;
+    this.clearSessionTimeout(session);
+    session.sessionTimeoutId = this.setTimeoutFn(() => {
+      this.cancelRun(session.runId);
+    }, this.sessionTtlMs) as unknown as number;
+  }
+
+  private scheduleWaitingTimeout(session: RunSession<T>): void {
+    this.clearWaitingTimeout(session);
+    session.waitingTimeoutId = this.setTimeoutFn(() => {
+      this.cancelRun(session.runId);
+    }, this.waitingTtlMs) as unknown as number;
+  }
+
+  private touchSession(session: RunSession<T>): void {
+    if (session.status === "running" || session.status === "waiting") {
+      this.scheduleSessionTimeout(session);
+    }
+  }
+
+  private finalizeSession(
+    session: RunSession<T>,
+    status: Exclude<RunSessionStatus, "running" | "waiting">,
+  ): void {
+    session.status = status;
+    this.clearWaitingTimeout(session);
+    this.clearSessionTimeout(session);
+    session.waitingState = null;
+    this.sessions.delete(session.runId);
+  }
+
+  startRun(input: { runId: string; threadId: string }): AbortSignal {
+    const existing = this.sessions.get(input.runId);
+    if (existing && (existing.status === "running" || existing.status === "waiting")) {
+      throw new RunAlreadyExistsError(input.runId);
+    }
+
+    if (this.sessions.size >= this.maxConcurrentSessions) {
+      throw new Error(
+        `Maximum concurrent sessions (${this.maxConcurrentSessions}) reached`,
+      );
+    }
+
+    const session: RunSession<T> = {
+      runId: input.runId,
+      status: "running",
+      abortController: new AbortController(),
+      waitingState: null,
+      submittedValues: new Map(),
+      waitingTimeoutId: null,
+      sessionTimeoutId: null,
+    };
+
+    this.sessions.set(input.runId, session);
+    this.touchSession(session);
+    return session.abortController.signal;
+  }
+
+  async waitForSignal(runId: string, waitKey: string): Promise<T> {
+    const session = this.sessions.get(runId);
+    if (!session || session.status === "completed" || session.status === "failed") {
+      throw new RunNotActiveError(runId);
+    }
+
+    if (session.abortController.signal.aborted || session.status === "cancelled") {
+      throw new RunCancelledError();
+    }
+
+    const existingValue = session.submittedValues.get(waitKey);
+    if (existingValue) {
+      session.status = "running";
+      this.touchSession(session);
+      return existingValue.value;
+    }
+
+    if (session.waitingState && session.waitingState.waitKey !== waitKey) {
+      throw new WaitNotPendingError(runId, waitKey);
+    }
+
+    session.status = "waiting";
+    this.scheduleWaitingTimeout(session);
+    this.touchSession(session);
+
+    return await new Promise<T>((resolve, reject) => {
+      const abortHandler = () => {
+        this.clearWaitingTimeout(session);
+        session.waitingState = null;
+        session.status = "cancelled";
+        reject(new RunCancelledError());
+      };
+
+      session.abortController.signal.addEventListener("abort", abortHandler, { once: true });
+      session.waitingState = {
+        waitKey,
+        resolve: (value) => {
+          session.abortController.signal.removeEventListener("abort", abortHandler);
+          this.clearWaitingTimeout(session);
+          session.waitingState = null;
+          session.status = "running";
+          this.touchSession(session);
+          resolve(value.value);
+        },
+        reject: (reason) => {
+          session.abortController.signal.removeEventListener("abort", abortHandler);
+          this.clearWaitingTimeout(session);
+          session.waitingState = null;
+          reject(reason);
+        },
+      };
+    });
+  }
+
+  submitSignal(
+    runId: string,
+    input: { waitKey: string; value: T },
+  ): SubmitResumeValueOutcome {
+    const session = this.sessions.get(runId);
+    if (!session) {
+      throw new RunNotActiveError(runId);
+    }
+
+    const normalized: SubmittedValue<T> = {
+      value: input.value,
+      key: this.getConflictKey(input.value),
+    };
+
+    const existingValue = session.submittedValues.get(input.waitKey);
+    if (existingValue) {
+      if (existingValue.key === normalized.key) {
+        return { accepted: true, duplicate: true };
+      }
+
+      throw new WaitConflictError(runId, input.waitKey);
+    }
+
+    if (
+      session.status === "completed" || session.status === "failed" ||
+      session.status === "cancelled"
+    ) {
+      throw new RunNotActiveError(runId);
+    }
+
+    if (!session.waitingState || session.waitingState.waitKey !== input.waitKey) {
+      throw new WaitNotPendingError(runId, input.waitKey);
+    }
+
+    session.submittedValues.set(input.waitKey, normalized);
+    this.touchSession(session);
+    session.waitingState.resolve(normalized);
+    return { accepted: true };
+  }
+
+  cancelRun(runId: string): boolean {
+    const session = this.sessions.get(runId);
+    if (!session) return false;
+
+    if (
+      session.status === "completed" || session.status === "failed" ||
+      session.status === "cancelled"
+    ) {
+      return false;
+    }
+
+    const waitingState = session.waitingState;
+    session.abortController.abort(new RunCancelledError());
+    waitingState?.reject(new RunCancelledError());
+    this.finalizeSession(session, "cancelled");
+    return true;
+  }
+
+  completeRun(runId: string): void {
+    const session = this.sessions.get(runId);
+    if (!session) return;
+    this.finalizeSession(session, "completed");
+  }
+
+  failRun(runId: string): void {
+    const session = this.sessions.get(runId);
+    if (!session) return;
+    this.finalizeSession(session, "failed");
+  }
+
+  getRunStatus(runId: string): RunSessionStatus | null {
+    return this.sessions.get(runId)?.status ?? null;
+  }
+
+  reset(): void {
+    for (const session of this.sessions.values()) {
+      this.clearWaitingTimeout(session);
+      this.clearSessionTimeout(session);
+    }
+    this.sessions.clear();
+  }
+}

package/src/src/agent/runtime/tool-helpers.ts

@@ -6,7 +6,7 @@
  * @module ai/agent/runtime/tool-helpers
  */
 
-import type { Tool, ToolDefinition, ToolExecutionContext } from "../../tool/index.js";
+import type { RemoteToolSource, Tool, ToolDefinition, ToolExecutionContext } from "../../tool/index.js";
 import { executeTool, toolRegistry } from "../../tool/index.js";
 import { toolToProviderDefinition } from "../../tool/registry.js";
 import { SKILL_TOOL_IDS } from "../../skill/types.js";
@@ -101,21 +101,90 @@ function throwUnknownConfiguredToolsError(
 async function getRemoteToolDefinitions(options?: {
   includeIntegrationTools?: boolean;
   allowedRemoteToolNames?: string[];
+  remoteToolSources?: RemoteToolSource[];
+  remoteToolContext?: ToolExecutionContext;
 }): Promise<ToolDefinition[]> {
+  const remoteToolContext = options?.remoteToolContext;
+  const definitions: ToolDefinition[] = [];
+  const seenToolNames = new Set<string>();
+
+  const addDefinition = (definition: ToolDefinition): void => {
+    if (seenToolNames.has(definition.name)) {
+      return;
+    }
+    if (
+      options?.allowedRemoteToolNames &&
+      !options.allowedRemoteToolNames.includes(definition.name)
+    ) {
+      return;
+    }
+    seenToolNames.add(definition.name);
+    definitions.push(definition);
+  };
+
+  for (const source of options?.remoteToolSources ?? []) {
+    try {
+      const sourceDefs = await source.listTools(remoteToolContext);
+      for (const def of sourceDefs) {
+        addDefinition(def);
+      }
+    } catch (error) {
+      logger.warn("Failed to fetch remote tool definitions from source", {
+        sourceId: source.id,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   if (options?.includeIntegrationTools === false) {
-    return [];
+    return definitions;
   }
 
   try {
     const { getRemoteIntegrationToolDefinitions } = await import(
       "../../integrations/remote-tools.js"
     );
-    return (await getRemoteIntegrationToolDefinitions()).filter((def) =>
-      !options?.allowedRemoteToolNames || options.allowedRemoteToolNames.includes(def.name)
-    );
+    for (const def of await getRemoteIntegrationToolDefinitions()) {
+      addDefinition(def);
+    }
   } catch {
-    return [];
+    return definitions;
+  }
+
+  return definitions;
+}
+
+async function sourceHasTool(
+  source: RemoteToolSource,
+  toolName: string,
+  context?: ToolExecutionContext,
+): Promise<boolean> {
+  return (await source.listTools(context)).some((definition) => definition.name === toolName);
+}
+
+async function executeRemoteToolFromSources(
+  toolName: string,
+  input: Record<string, unknown>,
+  context: ToolExecutionContext | undefined,
+  allowedRemoteToolNames: string[] | undefined,
+  remoteToolSources: RemoteToolSource[] | undefined,
+): Promise<{ handled: boolean; result?: unknown }> {
+  for (const source of remoteToolSources ?? []) {
+    if (!(await sourceHasTool(source, toolName, context))) {
+      continue;
+    }
+
+    if (allowedRemoteToolNames && !allowedRemoteToolNames.includes(toolName)) {
+      throw new Error(`Tool "${toolName}" is not allowed for this run`);
+    }
+
+    return {
+      handled: true,
+      result: await source.executeTool(toolName, input, context),
+    };
   }
+
+  return { handled: false };
 }
 
 export function resolveConfiguredTool(
@@ -148,6 +217,7 @@ export async function executeConfiguredTool(
   toolsConfig: true | Record<string, ToolConfigEntry> | undefined,
   context?: ToolExecutionContext,
   allowedRemoteToolNames?: string[],
+  remoteToolSources?: RemoteToolSource[],
 ): Promise<unknown> {
   const configuredTool = resolveConfiguredTool(toolsConfig, toolName);
   if (configuredTool) {
@@ -160,6 +230,17 @@ export async function executeConfiguredTool(
     return await registryTool.execute(input, context);
   }
 
+  const remoteSourceResult = await executeRemoteToolFromSources(
+    toolName,
+    input,
+    context,
+    allowedRemoteToolNames,
+    remoteToolSources,
+  );
+  if (remoteSourceResult.handled) {
+    return remoteSourceResult.result;
+  }
+
   // Fall back to remote execution for integration tools (e.g., github:list-repos)
   if (isRemoteIntegrationTool(toolName)) {
     if (allowedRemoteToolNames && !allowedRemoteToolNames.includes(toolName)) {
@@ -207,6 +288,8 @@ export async function getAvailableTools(
     includeSkillTools?: boolean;
     includeIntegrationTools?: boolean;
     allowedRemoteToolNames?: string[];
+    remoteToolSources?: RemoteToolSource[];
+    remoteToolContext?: ToolExecutionContext;
   },
 ): Promise<ToolDefinition[]> {
   if (!toolsConfig) return [];

package/src/src/agent/types.ts

@@ -4,7 +4,7 @@
 import * as dntShim from "../../_dnt.shims.js";
 
 
-import type { Tool } from "../tool/index.js";
+import type { RemoteToolSource, Tool } from "../tool/index.js";
 import { INVALID_ARGUMENT } from "../errors/error-registry.js";
 import type { Memory } from "./memory/memory-interface.js";
 
@@ -79,6 +79,7 @@ export interface AgentConfig {
   model?: ModelString;
   system: string | (() => string) | (() => Promise<string>);
   tools?: true | Record<string, Tool | boolean>;
+  remoteTools?: RemoteToolSource[];
   maxSteps?: number;
   streaming?: boolean;
   memory?: MemoryConfig;