Agent parse conversation history

src/__tests__/unit/agents.test.ts

@@ -358,14 +358,98 @@ describe('GuardrailAgent', () => {
 
       // Test the guardrail function
       const guardrailFunction = agent.inputGuardrails[0];
-      const result = await guardrailFunction.execute('test input');
+    const result = await guardrailFunction.execute('test input');
 
-      expect(result).toHaveProperty('outputInfo');
-      expect(result).toHaveProperty('tripwireTriggered');
-      expect(typeof result.tripwireTriggered).toBe('boolean');
+    expect(result).toHaveProperty('outputInfo');
+    expect(result).toHaveProperty('tripwireTriggered');
+    expect(typeof result.tripwireTriggered).toBe('boolean');
+  });
+
+  it('passes the latest user message text to guardrails for conversation inputs', async () => {
+    process.env.OPENAI_API_KEY = 'test';
+    const config = {
+      version: 1,
+      input: {
+        version: 1,
+        guardrails: [{ name: 'Moderation', config: {} }],
+      },
+    };
+
+    const { instantiateGuardrails } = await import('../../runtime');
+    const runSpy = vi.fn().mockResolvedValue({
+      tripwireTriggered: false,
+      info: { guardrail_name: 'Moderation' },
     });
 
-    it('should handle guardrail execution errors based on raiseGuardrailErrors setting', async () => {
+    vi.mocked(instantiateGuardrails).mockImplementationOnce(() =>
+      Promise.resolve([
+        {
+          definition: {
+            name: 'Moderation',
+            description: 'Moderation guardrail',
+            mediaType: 'text/plain',
+            configSchema: z.object({}),
+            checkFn: vi.fn(),
+            metadata: {},
+            ctxRequirements: z.object({}),
+            schema: () => ({}),
+            instantiate: vi.fn(),
+          },
+          config: {},
+          run: runSpy,
+        } as unknown as Parameters<typeof instantiateGuardrails>[0] extends Promise<infer T>
+          ? T extends readonly (infer U)[]
+            ? U
+            : never
+          : never,
+      ])
+    );
+
+    const agent = (await GuardrailAgent.create(
+      config,
+      'Conversation Agent',
+      'Handle multi-turn conversations'
+    )) as MockAgent;
+
+    const guardrail = agent.inputGuardrails[0] as unknown as {
+      execute: (args: { input: unknown; context?: unknown }) => Promise<{
+        outputInfo: Record<string, unknown>;
+        tripwireTriggered: boolean;
+      }>;
+    };
+
+    const conversation = [
+      { role: 'system', content: 'You are helpful.' },
+      { role: 'user', content: [{ type: 'input_text', text: 'First question?' }] },
+      { role: 'assistant', content: [{ type: 'output_text', text: 'An answer.' }] },
+      {
+        role: 'user',
+        content: [
+          { type: 'input_text', text: 'Latest user message' },
+          { type: 'input_text', text: 'with additional context.' },
+        ],
+      },
+    ];
+
+    const result = await guardrail.execute({ input: conversation, context: {} });
+
+    expect(runSpy).toHaveBeenCalledTimes(1);
+    const [ctxArgRaw, dataArg] = runSpy.mock.calls[0] as [unknown, string];
+    const ctxArg = ctxArgRaw as { getConversationHistory?: () => unknown[] };
+    expect(dataArg).toBe('Latest user message with additional context.');
+    expect(typeof ctxArg.getConversationHistory).toBe('function');
+
+    const history = ctxArg.getConversationHistory?.() as Array<{ content?: unknown }> | undefined;
+    expect(Array.isArray(history)).toBe(true);
+    expect(history && history[history.length - 1]?.content).toBe(
+      'Latest user message with additional context.'
+    );
+
+    expect(result.tripwireTriggered).toBe(false);
+    expect(result.outputInfo.input).toBe('Latest user message with additional context.');
+  });
+
+  it('should handle guardrail execution errors based on raiseGuardrailErrors setting', async () => {
       process.env.OPENAI_API_KEY = 'test';
       const config = {
         version: 1,

src/agents.ts

@@ -13,8 +13,7 @@ import type {
   InputGuardrailFunctionArgs,
   OutputGuardrailFunctionArgs,
 } from '@openai/agents-core';
-import { GuardrailLLMContext, GuardrailResult, TextOnlyContent, ContentPart } from './types';
-import { ContentUtils } from './utils/content';
+import { GuardrailLLMContext, GuardrailResult, TextOnlyContent } from './types';
 import {
   loadPipelineBundles,
   instantiateGuardrails,
@@ -250,6 +249,122 @@ function ensureGuardrailContext(
   } as GuardrailLLMContext;
 }
 
+function extractTextFromContentParts(content: unknown): string {
+  if (typeof content === 'string') {
+    return content.trim();
+  }
+
+  if (Array.isArray(content)) {
+    const parts: string[] = [];
+    for (const item of content) {
+      const text = extractTextFromMessageEntry(item);
+      if (text) {
+        parts.push(text);
+      }
+    }
+    return parts.join(' ').trim();
+  }
+
+  if (content && typeof content === 'object') {
+    const record = content as Record<string, unknown>;
+    if (typeof record.text === 'string') {
+      return record.text.trim();
+    }
+    if (record.content !== undefined) {
+      const nested = extractTextFromContentParts(record.content);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+
+  return '';
+}
+
+function extractTextFromMessageEntry(entry: unknown): string {
+  if (entry == null) {
+    return '';
+  }
+
+  if (typeof entry === 'string') {
+    return entry.trim();
+  }
+
+  if (Array.isArray(entry)) {
+    return extractTextFromContentParts(entry);
+  }
+
+  if (typeof entry === 'object') {
+    const record = entry as Record<string, unknown>;
+    if (record.content !== undefined) {
+      const contentText = extractTextFromContentParts(record.content);
+      if (contentText) {
+        return contentText;
+      }
+    }
+
+    if (typeof record.text === 'string') {
+      return record.text.trim();
+    }
+  }
+
+  return '';
+}
+
+function extractTextFromAgentInput(input: unknown): string {
+  if (typeof input === 'string') {
+    return input.trim();
+  }
+
+  if (Array.isArray(input)) {
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+      const candidate = input[idx];
+      if (candidate && typeof candidate === 'object') {
+        const record = candidate as Record<string, unknown>;
+        if (record.role === 'user') {
+          const text = extractTextFromMessageEntry(candidate);
+          if (text) {
+            return text;
+          }
+        }
+      } else {
+        const text = extractTextFromMessageEntry(candidate);
+        if (text) {
+          return text;
+        }
+      }
+    }
+    return '';
+  }
+
+  if (input && typeof input === 'object') {
+    const record = input as Record<string, unknown>;
+    if (record.role === 'user') {
+      const text = extractTextFromMessageEntry(record);
+      if (text) {
+        return text;
+      }
+    }
+
+    if (record.content !== undefined) {
+      const contentText = extractTextFromContentParts(record.content);
+      if (contentText) {
+        return contentText;
+      }
+    }
+
+    if (typeof record.text === 'string') {
+      return record.text.trim();
+    }
+  }
+
+  if (input == null) {
+    return '';
+  }
+
+  return String(input);
+}
+
 function extractLatestUserText(history: NormalizedConversationEntry[]): string {
   for (let i = history.length - 1; i >= 0; i -= 1) {
     const entry = history[i];
@@ -261,20 +376,9 @@ function extractLatestUserText(history: NormalizedConversationEntry[]): string {
 }
 
 function resolveInputText(input: unknown, history: NormalizedConversationEntry[]): string {
-  if (typeof input === 'string') {
-    return input;
-  }
-
-  if (input && typeof input === 'object' && 'content' in (input as Record<string, unknown>)) {
-    const content = (input as { content: string | ContentPart[] }).content;
-    const message = {
-      role: 'user',
-      content,
-    };
-    const extracted = ContentUtils.extractTextFromMessage(message);
-    if (extracted) {
-      return extracted;
-    }
+  const directText = extractTextFromAgentInput(input);
+  if (directText) {
+    return directText;
   }
 
   return extractLatestUserText(history);