@illuma-ai/agents 1.1.25 → 1.3.0

package/src/memory/types.ts

@@ -0,0 +1,185 @@
+/**
+ * Autonomous memory — core types.
+ *
+ * Ported from upstream's memory-core pattern, adapted for Postgres + pgvector
+ * and shaped so a future graph-backend layer (Graphiti, Neo4j agent-memory, etc.)
+ * can be added alongside the vector store without changing the tool contracts.
+ *
+ * Architectural boundary: the LLM tools ({@link MemoryBackend}) never talk to
+ * Postgres directly — they go through an interface that a vector store,
+ * a graph store, or a composite of both can satisfy.
+ */
+
+/**
+ * Scope key for memory isolation.
+ *
+ * Two-tier model:
+ *   - Agent-tier rows (`memory/agent/*`) are stored with `user_id = NULL`
+ *     and are shared across every user of the agent.
+ *   - User-tier rows (`memory/user/*`) are stored with the caller's
+ *     `userId` and are private to that caller; other users of the same
+ *     agent never see them.
+ *
+ * Every read query applies `WHERE agent_id = $1 AND (user_id IS NULL OR
+ * user_id = $caller)`, so the caller sees shared rows plus their own.
+ * `userId` is therefore both the write target (for user-tier paths) AND
+ * the read filter. An absent `userId` is legal — it just means this
+ * scope is isolated/autonomous and the user tier is inert.
+ *
+ * Captured at tool construction time in a closure and NEVER exposed as
+ * tool parameters. The LLM cannot override either field.
+ */
+export interface MemoryScope {
+  agentId: string;
+  /**
+   * The caller's identity, used for user-tier writes AND the layered
+   * read filter. Undefined/null for isolated/autonomous agents — in
+   * that case only agent-tier rows are visible and writable.
+   */
+  userId?: string | null;
+}
+
+/**
+ * One retrieved memory record.
+ *
+ * `score` is a unit-interval hybrid score (0..1): 0.7 * cosine + 0.3 * text
+ * rank in the default pgvector backend. A graph backend is free to produce
+ * its own score as long as it stays within that range.
+ */
+export interface MemoryEntry {
+  id: string;
+  path: string;
+  content: string;
+  score: number;
+  createdAt: Date;
+  /**
+   * Which backend surfaced this entry. Lets a composite store tag results so
+   * downstream consumers (tests, telemetry, UI) can distinguish vector hits
+   * from graph hits without inspecting the ID format.
+   */
+  source?: MemoryBackendKind;
+  /**
+   * Which tier the row belongs to — derived from the path at read time.
+   * See `./paths.ts` for the whitelist. UI groups rows by this field
+   * so users can see which memories are shared (agent tier) vs private
+   * (user tier).
+   */
+  tier?: 'agent' | 'user';
+  /** Citation marker (Phase 2) — e.g. `memory/agent/playbook.md#L1-L8`. */
+  citation?: string;
+  /** 1-indexed start/end line range used to build the citation. */
+  startLine?: number;
+  endLine?: number;
+}
+
+export type MemoryBackendKind = 'vector' | 'graph' | 'composite';
+
+export interface MemorySearchOptions {
+  maxResults?: number;
+  minScore?: number;
+  /**
+   * Phase 2 toggles — when the backend supports them. Each is independently
+   * opt-in; all false = upstream Phase 1 behavior.
+   */
+  mmr?: { enabled?: boolean; lambda?: number };
+  temporalDecay?: { enabled?: boolean; halfLifeDays?: number };
+  /** Citation mode: 'on' decorates; 'off' strips; 'auto' = on for direct chat. */
+  citations?: 'on' | 'off' | 'auto';
+}
+
+export interface MemoryGetOptions {
+  path: string;
+  from?: number;
+  lines?: number;
+}
+
+export interface MemoryReadResult {
+  path: string;
+  text: string;
+}
+
+export interface MemoryAppendInput {
+  /** Must begin with "memory/". Enforced by the append tool wrapper. */
+  path: string;
+  content: string;
+}
+
+export interface MemoryHealth {
+  ok: boolean;
+  backend: MemoryBackendKind;
+  error?: string;
+}
+
+/**
+ * The contract every memory backend implements.
+ *
+ * A Phase 1 pgvector store satisfies this directly. A Phase 4 graph store
+ * (Graphiti / Neo4j agent-memory) will implement the same interface and plug
+ * into a {@link CompositeMemoryBackend} without touching the tools.
+ */
+export interface MemoryBackend {
+  readonly kind: MemoryBackendKind;
+  search(
+    scope: MemoryScope,
+    query: string,
+    opts?: MemorySearchOptions
+  ): Promise<MemoryEntry[]>;
+  get(
+    scope: MemoryScope,
+    opts: MemoryGetOptions
+  ): Promise<MemoryReadResult | null>;
+  append(scope: MemoryScope, input: MemoryAppendInput): Promise<void>;
+  health(): Promise<MemoryHealth>;
+}
+
+/**
+ * Historical alias kept for one release so external consumers can still import
+ * the name used in the plan doc. New code should prefer {@link MemoryBackend}.
+ *
+ * @deprecated use {@link MemoryBackend}
+ */
+export type MemoryStore = MemoryBackend;
+
+/**
+ * Optional configuration bundle plumbed through `createAgentNode`.
+ * Missing config = memory fully disabled, no tools attached.
+ */
+export interface MemoryConfig {
+  backend: MemoryBackend;
+  scope: MemoryScope;
+  flush?: {
+    softThresholdTokens?: number;
+    reserveFloorTokens?: number;
+    windowTokens?: number;
+    enabled?: boolean;
+  };
+  search?: {
+    maxResults?: number;
+    maxInjectedChars?: number;
+    /** Phase 2 — enable MMR reranking (upstream-aligned defaults when true). */
+    mmr?: { enabled?: boolean; lambda?: number };
+    /** Phase 2 — enable temporal decay on dated memory files. */
+    temporalDecay?: { enabled?: boolean; halfLifeDays?: number };
+    /** Phase 2 — citation mode. Defaults to 'auto'. */
+    citations?: 'on' | 'off' | 'auto';
+  };
+  /**
+   * Phase 2 — optional recall tracker. When set, memory_search fires a
+   * best-effort recall record after each successful call. Failures are
+   * swallowed so recall tracking never blocks the tool result.
+   */
+  recallTracker?: {
+    record(params: {
+      agentId: string;
+      query: string;
+      hits: Array<{ id: string; path: string; score: number }>;
+    }): Promise<void>;
+  };
+  /**
+   * Phase state accessor. Returns the current phase so the append-tool wrapper
+   * can gate writes to the reflection phase. Supplied by the graph runtime.
+   */
+  getPhase?: () => MemoryPhase;
+}
+
+export type MemoryPhase = 'normal' | 'memory_flushing';

package/src/nodes/ApprovalGateNode.ts

@@ -50,15 +50,9 @@ export interface ApprovalGateInterrupt {
 export function createApprovalGateNode(
   config: ApprovalGateConfig,
   sourceAgentId: string,
-  destinationAgentId: string,
+  destinationAgentId: string
 ) {
-  const {
-    gateId,
-    channel = 'chat',
-    prompt,
-    approver,
-    timeoutMs,
-  } = config;
+  const { gateId, channel = 'chat', prompt, approver, timeoutMs } = config;
 
   /**
    * The gate node function. Receives the current graph state,
@@ -67,7 +61,7 @@ export function createApprovalGateNode(
    */
   return async function approvalGateNode(
     state: BaseGraphState,
-    runnableConfig?: RunnableConfig,
+    runnableConfig?: RunnableConfig
   ): Promise<Partial<BaseGraphState>> {
     const interruptPayload: ApprovalGateInterrupt = {
       type: 'approval_gate',
@@ -87,7 +81,7 @@ export function createApprovalGateNode(
     safeDispatchCustomEvent(
       GraphEvents.ON_APPROVAL_GATE,
       interruptPayload,
-      runnableConfig,
+      runnableConfig
     );
 
     // Pause the graph — state is checkpointed by the MongoDBSaver.

package/src/nodes/__tests__/ApprovalGateNode.test.ts

@@ -81,7 +81,7 @@ describe('ApprovalGateNode', () => {
     // First invoke: Agent A runs, then gate interrupts
     const result = await compiled.invoke(
       { messages: [new HumanMessage('start')] },
-      config,
+      config
     );
 
     // Check that the graph was interrupted (Agent B should NOT have run)
@@ -92,13 +92,13 @@ describe('ApprovalGateNode', () => {
     // Agent A should have run
     const messages = result.messages as BaseMessage[];
     const hasAgentA = messages.some(
-      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent A done',
+      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent A done'
     );
     expect(hasAgentA).toBe(true);
 
     // Agent B should NOT have run
     const hasAgentB = messages.some(
-      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent B done',
+      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent B done'
     );
     expect(hasAgentB).toBe(false);
   });
@@ -114,21 +114,18 @@ describe('ApprovalGateNode', () => {
     };
 
     // First invoke: hits gate interrupt
-    await compiled.invoke(
-      { messages: [new HumanMessage('start')] },
-      config,
-    );
+    await compiled.invoke({ messages: [new HumanMessage('start')] }, config);
 
     // Resume with approval
     const result = await compiled.invoke(
       new Command({ resume: { approved: true } }),
-      config,
+      config
     );
 
     // Agent B should have run after approval
     const messages = result.messages as BaseMessage[];
     const hasAgentB = messages.some(
-      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent B done',
+      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent B done'
     );
     expect(hasAgentB).toBe(true);
   });
@@ -145,10 +142,7 @@ describe('ApprovalGateNode', () => {
       configurable: { thread_id: 'test-thread-3' },
     };
 
-    await compiled.invoke(
-      { messages: [new HumanMessage('start')] },
-      config,
-    );
+    await compiled.invoke({ messages: [new HumanMessage('start')] }, config);
 
     // safeDispatchCustomEvent should have been called with gate data
     expect(safeDispatchCustomEvent).toHaveBeenCalledWith(
@@ -162,7 +156,7 @@ describe('ApprovalGateNode', () => {
         sourceAgentId: 'agent_a',
         destinationAgentId: 'agent_b',
       }),
-      expect.anything(),
+      expect.anything()
     );
   });
 
@@ -176,15 +170,12 @@ describe('ApprovalGateNode', () => {
     };
 
     // First invoke: hits gate interrupt
-    await compiled.invoke(
-      { messages: [new HumanMessage('start')] },
-      config,
-    );
+    await compiled.invoke({ messages: [new HumanMessage('start')] }, config);
 
     // Resume with denial
     const result = await compiled.invoke(
       new Command({ resume: { approved: false, feedback: 'Not ready' } }),
-      config,
+      config
     );
 
     // Agent B still runs (the gate doesn't block — it's the host's
@@ -192,7 +183,7 @@ describe('ApprovalGateNode', () => {
     // In the current implementation, the gate node returns {} regardless.
     const messages = result.messages as BaseMessage[];
     const hasAgentB = messages.some(
-      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent B done',
+      (m: any) => m._getType?.() === 'ai' && m.content === 'Agent B done'
     );
     expect(hasAgentB).toBe(true);
   });

package/src/prompts/memoryFlushPrompt.ts

@@ -0,0 +1,78 @@
+/**
+ * Memory-flush prompt resolver.
+ *
+ * The raw prompt strings live in `src/memory/constants.ts` and contain a
+ * single `{{MEMORY_PATHS_RUBRIC}}` placeholder. This module substitutes
+ * the caller-scoped rubric (produced by `renderPathsRubric()` in
+ * `src/memory/paths.ts`) into that placeholder at flush time, so:
+ *
+ *   - a collaborative agent with a real caller sees all 8 paths
+ *   - an isolated/autonomous agent sees only the 4 agent-tier paths
+ *     (user-tier rows are physically omitted from the rubric the LLM
+ *      sees, so it cannot route writes there even by mistake)
+ *
+ * ## Why this lives in prompts/ and not memory/constants.ts
+ *
+ * The constants file is pure strings — no imports, no runtime work.
+ * Injecting the rubric needs access to `renderPathsRubric()` which
+ * needs `MemoryScope`, so the substitution has to happen one layer up.
+ * Keeping the placeholder in constants and the substitution here means
+ * tests of the raw prompt (no scope) and tests of the rendered prompt
+ * (scope-aware) stay independent.
+ */
+import {
+  DEFAULT_MEMORY_FLUSH_PROMPT,
+  DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT,
+  FLUSH_PROMPT_RUBRIC_PLACEHOLDER,
+} from '@/memory/constants';
+import { renderPathsRubric } from '@/memory/paths';
+import type { MemoryScope } from '@/memory/types';
+
+export { DEFAULT_MEMORY_FLUSH_PROMPT, DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT };
+
+/** Back-compat alias so existing callers keep working. */
+export const MEMORY_FLUSH_SYSTEM_PROMPT = DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT;
+
+/** Minimum scope shape needed to render the rubric. */
+export interface ResolveFlushPromptsOptions {
+  /**
+   * The scope the memory tools were built with. Only `userId` matters
+   * for rubric rendering — if absent, the user-tier paths are filtered
+   * out of the rubric the LLM sees.
+   */
+  scope: Pick<MemoryScope, 'userId'>;
+}
+
+/**
+ * Result shape returned to `runMemoryFlush`. `prompt` goes in the
+ * HumanMessage, `systemPrompt` goes in the SystemMessage. Both already
+ * have the rubric substituted — the caller should pass them through
+ * verbatim.
+ */
+export interface ResolvedFlushPrompts {
+  prompt: string;
+  systemPrompt: string;
+}
+
+/**
+ * Substitutes the paths rubric into the raw prompts for a given scope.
+ *
+ * Idempotent (calling it twice on already-resolved strings is a no-op
+ * because the placeholder will have been replaced already). Safe to
+ * call per-flush; no caching needed — the string concat is microseconds.
+ */
+export function resolveFlushPrompts(
+  options: ResolveFlushPromptsOptions
+): ResolvedFlushPrompts {
+  const rubric = renderPathsRubric(options.scope);
+  return {
+    prompt: DEFAULT_MEMORY_FLUSH_PROMPT.replaceAll(
+      FLUSH_PROMPT_RUBRIC_PLACEHOLDER,
+      rubric
+    ),
+    systemPrompt: DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT.replaceAll(
+      FLUSH_PROMPT_RUBRIC_PLACEHOLDER,
+      rubric
+    ),
+  };
+}

package/src/run.ts

@@ -47,6 +47,7 @@ export class Run<_T extends t.BaseGraphState> {
   Graph: StandardGraph | MultiAgentGraph | undefined;
   returnContent: boolean = false;
   private skipCleanup: boolean = false;
+  private _originalCallbacksSnapshot?: t.ProvidedCallbacks;
 
   private constructor(config: Partial<t.RunConfig>) {
     const runId = config.runId ?? '';
@@ -280,7 +281,19 @@ export class Run<_T extends t.BaseGraphState> {
     /** Custom event callback to intercept and handle custom events */
     const customEventCallback = this.createCustomEventCallback();
 
-    const baseCallbacks = (config.callbacks as t.ProvidedCallbacks) ?? [];
+    // IMPORTANT: snapshot the ORIGINAL caller-provided callbacks once and
+    // reuse that snapshot on every invocation. Previously we read
+    // `config.callbacks` on each call and concat'd onto it — but the same
+    // `config` object is passed back to processStream() on HITL resume, so
+    // the previous run's appended callbacks became the new "base" and we
+    // ended up stacking duplicate stream + custom handlers on every cycle.
+    // That produced N-times duplicated message_delta events on the SSE
+    // stream (character-interleaved text in the UI after tool approval).
+    if (!this._originalCallbacksSnapshot) {
+      this._originalCallbacksSnapshot =
+        (config.callbacks as t.ProvidedCallbacks) ?? [];
+    }
+    const baseCallbacks = this._originalCallbacksSnapshot;
     const streamCallbacks = streamOptions?.callbacks
       ? this.getCallbacks(streamOptions.callbacks)
       : [];
@@ -435,15 +448,13 @@ export class Run<_T extends t.BaseGraphState> {
    * Requires a checkpointer to be configured — without one, interrupt state
    * is not persisted and this always returns false.
    */
-  async hasInterrupts(
-    config: Partial<RunnableConfig>
-  ): Promise<boolean> {
+  async hasInterrupts(config: Partial<RunnableConfig>): Promise<boolean> {
     if (!this.graphRunnable) {
       return false;
     }
     try {
       const state = await this.graphRunnable.getState(config);
-      return state.tasks?.some((task) => task.interrupts?.length > 0) ?? false;
+      return state.tasks.some((task) => task.interrupts.length > 0) ?? false;
     } catch {
       return false;
     }
@@ -463,7 +474,7 @@ export class Run<_T extends t.BaseGraphState> {
     try {
       const state = await this.graphRunnable.getState(config);
       return (
-        state.tasks?.flatMap((task) =>
+        state.tasks.flatMap((task) =>
           (task.interrupts ?? []).map((i) => i.value)
         ) ?? []
       );

package/src/scripts/test-bedrock-handoff-autonomous.ts

@@ -18,7 +18,12 @@
 import { config } from 'dotenv';
 config();
 import { resolve } from 'path';
-config({ path: resolve(process.cwd(), '..', 'ranger', '.env'), override: false });
+if (process.env.AGENTS_TEST_ENV_PATH) {
+  config({
+    path: resolve(process.env.AGENTS_TEST_ENV_PATH),
+    override: false,
+  });
+}
 
 // Disable observability for this test (requires @illuma-ai/observability-node)
 delete process.env.ILLUMA_SECRET_KEY;
@@ -34,7 +39,9 @@ import type * as t from '@/types';
 import type { RunnableConfig } from '@langchain/core/runnables';
 
 const bedrockRegion =
-  process.env.BEDROCK_AWS_REGION ?? process.env.BEDROCK_AWS_DEFAULT_REGION ?? 'us-east-1';
+  process.env.BEDROCK_AWS_REGION ??
+  process.env.BEDROCK_AWS_DEFAULT_REGION ??
+  'us-east-1';
 
 const bedrockOptions = {
   model: 'us.anthropic.claude-3-5-haiku-20241022-v1:0',
@@ -116,7 +123,10 @@ Do NOT delegate or transfer. Just write the content and respond.`
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP]: {
       handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({ event: event as GraphEvents, data: data as t.RunStep });
+        aggregateContent({
+          event: event as GraphEvents,
+          data: data as t.RunStep,
+        });
       },
     },
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
@@ -129,7 +139,10 @@ Do NOT delegate or transfer. Just write the content and respond.`
     },
     [GraphEvents.ON_MESSAGE_DELTA]: {
       handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({ event: event as GraphEvents, data: data as t.MessageDeltaEvent });
+        aggregateContent({
+          event: event as GraphEvents,
+          data: data as t.MessageDeltaEvent,
+        });
       },
     },
   };
@@ -145,7 +158,10 @@ Do NOT delegate or transfer. Just write the content and respond.`
     returnContent: true,
   });
 
-  const streamConfig: Partial<RunnableConfig> & { version: 'v1' | 'v2'; streamMode: string } = {
+  const streamConfig: Partial<RunnableConfig> & {
+    version: 'v1' | 'v2';
+    streamMode: string;
+  } = {
     configurable: { thread_id: 'bedrock-autonomous-test' },
     streamMode: 'values',
     version: 'v2',
@@ -153,25 +169,34 @@ Do NOT delegate or transfer. Just write the content and respond.`
 
   // ── Test 1: Single handoff (Orchestrator → Researcher → back) ──
   console.log('\n--- Test 1: Single Handoff (Research) ---');
-  console.log('Query: "What are the top 3 trends in enterprise AI adoption in 2025?"');
+  console.log(
+    'Query: "What are the top 3 trends in enterprise AI adoption in 2025?"'
+  );
 
   const messages1 = [
-    new HumanMessage('What are the top 3 trends in enterprise AI adoption in 2025?'),
+    new HumanMessage(
+      'What are the top 3 trends in enterprise AI adoption in 2025?'
+    ),
   ];
 
   try {
     await run.processStream({ messages: messages1 }, streamConfig);
 
     const finalMessages = run.getRunMessages();
-    console.log(`\n✓ Graph completed. Total messages: ${finalMessages?.length ?? 0}`);
+    console.log(
+      `\n✓ Graph completed. Total messages: ${finalMessages?.length ?? 0}`
+    );
 
     // Check that a handoff happened
     const lastMsg = finalMessages?.[finalMessages.length - 1];
     if (lastMsg) {
-      const content = typeof lastMsg.content === 'string'
-        ? lastMsg.content
-        : JSON.stringify(lastMsg.content);
-      console.log(`\n✓ Final response (first 500 chars):\n${content.slice(0, 500)}`);
+      const content =
+        typeof lastMsg.content === 'string'
+          ? lastMsg.content
+          : JSON.stringify(lastMsg.content);
+      console.log(
+        `\n✓ Final response (first 500 chars):\n${content.slice(0, 500)}`
+      );
     }
 
     // Verify last active agent tracking
@@ -186,7 +211,9 @@ Do NOT delegate or transfer. Just write the content and respond.`
 
   // ── Test 2: Multi-hop (Orchestrator → Researcher → back → Writer → back) ──
   console.log('\n\n--- Test 2: Multi-Hop Handoff (Research → Write) ---');
-  console.log('Query: "Research AI agent frameworks and write a brief summary email"');
+  console.log(
+    'Query: "Research AI agent frameworks and write a brief summary email"'
+  );
 
   const run2 = await Run.create({
     runId: `bedrock-autonomous-handoff-2-${Date.now()}`,
@@ -199,27 +226,36 @@ Do NOT delegate or transfer. Just write the content and respond.`
   });
 
   const messages2 = [
-    new HumanMessage('Research the latest AI agent frameworks and write a brief 3-sentence summary.'),
+    new HumanMessage(
+      'Research the latest AI agent frameworks and write a brief 3-sentence summary.'
+    ),
   ];
 
   try {
     await run2.processStream({ messages: messages2 }, streamConfig);
 
     const finalMessages2 = run2.getRunMessages();
-    console.log(`\n✓ Graph completed. Total messages: ${finalMessages2?.length ?? 0}`);
+    console.log(
+      `\n✓ Graph completed. Total messages: ${finalMessages2?.length ?? 0}`
+    );
 
     const lastMsg2 = finalMessages2?.[finalMessages2.length - 1];
     if (lastMsg2) {
-      const content = typeof lastMsg2.content === 'string'
-        ? lastMsg2.content
-        : JSON.stringify(lastMsg2.content);
-      console.log(`\n✓ Final response (first 500 chars):\n${content.slice(0, 500)}`);
+      const content =
+        typeof lastMsg2.content === 'string'
+          ? lastMsg2.content
+          : JSON.stringify(lastMsg2.content);
+      console.log(
+        `\n✓ Final response (first 500 chars):\n${content.slice(0, 500)}`
+      );
     }
 
     const lastActiveAgentId2 = run2.getLastActiveAgentId?.();
     console.log(`\n✓ lastActiveAgentId: ${lastActiveAgentId2}`);
 
-    console.log('\n✅ Test 2 PASSED — Multi-hop handoff completed successfully');
+    console.log(
+      '\n✅ Test 2 PASSED — Multi-hop handoff completed successfully'
+    );
   } catch (err) {
     console.error('\n❌ Test 2 FAILED:', (err as Error).message);
     console.error((err as Error).stack);

package/src/specs/agent-handoffs-bedrock.integration.test.ts

@@ -10,12 +10,15 @@
  */
 import { config } from 'dotenv';
 import { resolve } from 'path';
-// Load from local .env first, then fall back to ranger's .env for Bedrock credentials
+// Load local .env first; optionally fall back to a host-provided env file
+// pointed at by AGENTS_TEST_ENV_PATH.
 config();
-config({
-  path: resolve(process.cwd(), '..', 'ranger', '.env'),
-  override: false,
-});
+if (process.env.AGENTS_TEST_ENV_PATH) {
+  config({
+    path: resolve(process.env.AGENTS_TEST_ENV_PATH),
+    override: false,
+  });
+}
 
 import { HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';

package/src/specs/agent-handoffs.test.ts

@@ -1397,10 +1397,16 @@ describe('Agent Handoffs Tests', () => {
       });
 
       // Override test model to respond directly (no transfer)
-      run.Graph?.overrideTestModel(['I am the writer, continuing your work.'], 10);
+      run.Graph?.overrideTestModel(
+        ['I am the writer, continuing your work.'],
+        10
+      );
 
       const messages = [new HumanMessage('Make the intro shorter')];
-      const config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; streamMode: string } = {
+      const config: Partial<RunnableConfig> & {
+        version: 'v1' | 'v2';
+        streamMode: string;
+      } = {
         configurable: { thread_id: 'resume-exec-test' },
         streamMode: 'values',
         version: 'v2' as const,