feat(online-eval): support sessionTimeoutMinutes and filters in add/import flows

src/assets/cdk/package.json

@@ -23,7 +23,7 @@
     "typescript": "~5.9.3"
   },
   "dependencies": {
-    "@aws/agentcore-cdk": "^0.1.0-alpha.19",
+    "@aws/agentcore-cdk": "^0.1.0-alpha.29",
     "aws-cdk-lib": "^2.248.0",
     "constructs": "^10.0.0"
   }

src/cli/aws/agentcore-control.ts

@@ -740,6 +740,10 @@ export interface GetOnlineEvalConfigResult {
   outputLogGroupName?: string;
   /** Sampling percentage from the rule config */
   samplingPercentage?: number;
+  /** Session idle timeout in minutes from rule.sessionConfig (if set) */
+  sessionTimeoutMinutes?: number;
+  /** Filter rules from rule.filters (if any) */
+  filters?: import('../../schema').FilterRule[];
   /** Service names from CloudWatch data source config (e.g. "projectName_agentName.DEFAULT") */
   serviceNames?: string[];
   /** Evaluator IDs referenced by this config */
@@ -763,6 +767,19 @@ export async function getOnlineEvaluationConfig(
 
   const logGroupName = response.outputConfig?.cloudWatchConfig?.logGroupName;
   const samplingPercentage = response.rule?.samplingConfig?.samplingPercentage;
+  const sessionTimeoutMinutes = response.rule?.sessionConfig?.sessionTimeoutMinutes;
+  const filters = (response.rule?.filters ?? [])
+    .map(f => {
+      if (!f.key || !f.operator || !f.value) return undefined;
+      const v = f.value;
+      const value: { stringValue?: string; doubleValue?: number; booleanValue?: boolean } = {};
+      if ('stringValue' in v && v.stringValue !== undefined) value.stringValue = v.stringValue;
+      else if ('doubleValue' in v && v.doubleValue !== undefined) value.doubleValue = v.doubleValue;
+      else if ('booleanValue' in v && v.booleanValue !== undefined) value.booleanValue = v.booleanValue;
+      else return undefined; // unknown variant — skip
+      return { key: f.key, operator: f.operator as import('../../schema').FilterOperator, value };
+    })
+    .filter((f): f is import('../../schema').FilterRule => f !== undefined);
   const serviceNames =
     response.dataSourceConfig && 'cloudWatchLogs' in response.dataSourceConfig
       ? response.dataSourceConfig.cloudWatchLogs?.serviceNames
@@ -781,6 +798,8 @@ export async function getOnlineEvaluationConfig(
     failureReason: response.failureReason,
     outputLogGroupName: logGroupName,
     samplingPercentage,
+    ...(sessionTimeoutMinutes !== undefined && { sessionTimeoutMinutes }),
+    ...(filters.length > 0 && { filters }),
     serviceNames,
     evaluatorIds,
   };

src/cli/commands/import/__tests__/import-online-eval.test.ts

@@ -106,6 +106,50 @@ describe('toOnlineEvalConfigSpec', () => {
     expect(result.description).toBeUndefined();
   });
 
+  it('preserves sessionTimeoutMinutes and filters when present', () => {
+    const detail: GetOnlineEvalConfigResult = {
+      configId: 'oec-rich',
+      configArn: 'arn:aws:bedrock-agentcore:us-west-2:123456789012:online-evaluation-config/oec-rich',
+      configName: 'Rich',
+      status: 'ACTIVE',
+      executionStatus: 'ENABLED',
+      samplingPercentage: 30,
+      sessionTimeoutMinutes: 60,
+      filters: [
+        { key: 'userId', operator: 'Equals', value: { stringValue: 'abc' } },
+        { key: 'score', operator: 'GreaterThan', value: { doubleValue: 0.5 } },
+      ],
+      serviceNames: ['agent.DEFAULT'],
+      evaluatorIds: ['eval-1'],
+    };
+
+    const result = toOnlineEvalConfigSpec(detail, 'Rich', 'agent', ['eval_one']);
+
+    expect(result.sessionTimeoutMinutes).toBe(60);
+    expect(result.filters).toEqual([
+      { key: 'userId', operator: 'Equals', value: { stringValue: 'abc' } },
+      { key: 'score', operator: 'GreaterThan', value: { doubleValue: 0.5 } },
+    ]);
+  });
+
+  it('omits sessionTimeoutMinutes and filters when absent on the source config', () => {
+    const detail: GetOnlineEvalConfigResult = {
+      configId: 'oec-bare',
+      configArn: 'arn:aws:bedrock-agentcore:us-west-2:123456789012:online-evaluation-config/oec-bare',
+      configName: 'Bare',
+      status: 'ACTIVE',
+      executionStatus: 'ENABLED',
+      samplingPercentage: 5,
+      serviceNames: ['agent.DEFAULT'],
+      evaluatorIds: ['eval-1'],
+    };
+
+    const result = toOnlineEvalConfigSpec(detail, 'Bare', 'agent', ['eval_one']);
+
+    expect(result.sessionTimeoutMinutes).toBeUndefined();
+    expect(result.filters).toBeUndefined();
+  });
+
   it('throws when sampling percentage is missing', () => {
     const detail: GetOnlineEvalConfigResult = {
       configId: 'oec-no-sampling',

src/cli/commands/import/import-online-eval.ts

@@ -44,6 +44,8 @@ export function toOnlineEvalConfigSpec(
     samplingRate: detail.samplingPercentage,
     ...(detail.description && { description: detail.description }),
     ...(detail.executionStatus === 'ENABLED' && { enableOnCreate: true }),
+    ...(detail.sessionTimeoutMinutes !== undefined && { sessionTimeoutMinutes: detail.sessionTimeoutMinutes }),
+    ...(detail.filters && detail.filters.length > 0 && { filters: detail.filters }),
   };
 }
 

src/cli/operations/dev/web-ui/api-types.ts

@@ -201,6 +201,14 @@
   evaluators: string[];
   samplingRate: number;
   description?: string;
+  /** Session idle timeout in minutes (1-1440). Default: 5 */
+  sessionTimeoutMinutes?: number;
+  /** Optional filter rules limiting which traces are evaluated. */
+  filters?: Array<{
+    key: string;
+    operator: string;
+    value: { stringValue?: string; doubleValue?: number; booleanValue?: boolean };
+  }>;
   deploymentStatus?: ResourceDeploymentStatus;
   deployed?: DeployedOnlineEvalState;
 }

src/cli/primitives/OnlineEvalConfigPrimitive.ts

@@ -1,11 +1,12 @@
 import { findConfigRoot } from '../../lib';
-import type { OnlineEvalConfig } from '../../schema';
+import type { FilterRule, OnlineEvalConfig } from '../../schema';
 import { OnlineEvalConfigSchema } from '../../schema';
 import { getErrorMessage } from '../errors';
 import type { RemovalPreview, RemovalResult, SchemaChange } from '../operations/remove/types';
 import { cliCommandRun } from '../telemetry/cli-command-run.js';
 import { requireTTY } from '../tui/guards/tty';
 import { BasePrimitive } from './BasePrimitive';
+import { parseFilterFlags } from './filter-flag-parser';
 import type { AddResult, AddScreenComponent, RemovableResource } from './types';
 import type { Command } from '@commander-js/extra-typings';
 
@@ -16,6 +17,8 @@ export interface AddOnlineEvalConfigOptions {
   samplingRate: number;
   enableOnCreate?: boolean;
   endpoint?: string;
+  sessionTimeoutMinutes?: number;
+  filters?: FilterRule[];
 }
 
 export type RemovableOnlineEvalConfig = RemovableResource;
@@ -113,6 +116,11 @@ export class OnlineEvalConfigPrimitive extends BasePrimitive<AddOnlineEvalConfig
       .option('--sampling-rate <rate>', 'Sampling percentage (0.01-100) [non-interactive]')
       .option('--endpoint <name>', 'Runtime endpoint name to scope monitoring [non-interactive]')
       .option('--enable-on-create', 'Enable evaluation immediately after deploy [non-interactive]')
+      .option('--session-timeout-minutes <minutes>', 'Session idle timeout in minutes (1-1440) [non-interactive]')
+      .option(
+        '--filter <spec...>',
+        'Filter rule (repeatable). Format: key=<k>,op=<Operator>,type=<string|double|boolean>,value=<v> [non-interactive]'
+      )
       .option('--json', 'Output as JSON [non-interactive]')
       .action(
         async (cliOptions: {
@@ -123,6 +131,8 @@ export class OnlineEvalConfigPrimitive extends BasePrimitive<AddOnlineEvalConfig
           samplingRate?: string;
           endpoint?: string;
           enableOnCreate?: boolean;
+          sessionTimeoutMinutes?: string;
+          filter?: string[];
           json?: boolean;
         }) => {
           if (!findConfigRoot()) {
@@ -149,13 +159,28 @@ export class OnlineEvalConfigPrimitive extends BasePrimitive<AddOnlineEvalConfig
                 );
               }
 
+              let sessionTimeoutMinutes: number | undefined;
+              if (cliOptions.sessionTimeoutMinutes !== undefined) {
+                const parsed = Number(cliOptions.sessionTimeoutMinutes);
+                if (!Number.isInteger(parsed) || parsed < 1 || parsed > 1440) {
+                  throw new Error(
+                    `Invalid --session-timeout-minutes "${cliOptions.sessionTimeoutMinutes}". Must be an integer between 1 and 1440`
+                  );
+                }
+                sessionTimeoutMinutes = parsed;
+              }
+
+              const filters = parseFilterFlags(cliOptions.filter);
+
               const result = await this.add({
                 name: cliOptions.name,
                 agent: cliOptions.runtime,
                 evaluators: allEvaluators,
                 samplingRate,
                 enableOnCreate: cliOptions.enableOnCreate,
                 endpoint: cliOptions.endpoint,
+                ...(sessionTimeoutMinutes !== undefined && { sessionTimeoutMinutes }),
+                ...(filters && filters.length > 0 && { filters }),
               });
 
               if (!result.success) {
@@ -171,6 +196,8 @@ export class OnlineEvalConfigPrimitive extends BasePrimitive<AddOnlineEvalConfig
               return {
                 evaluator_count: allEvaluators.length,
                 enable_on_create: cliOptions.enableOnCreate ?? false,
+                filter_count: filters?.length ?? 0,
+                session_timeout_set: sessionTimeoutMinutes !== undefined,
               };
             });
           } else {
@@ -235,6 +262,8 @@ export class OnlineEvalConfigPrimitive extends BasePrimitive<AddOnlineEvalConfig
       samplingRate: options.samplingRate,
       ...(options.enableOnCreate !== undefined && { enableOnCreate: options.enableOnCreate }),
       ...(options.endpoint && { endpoint: options.endpoint }),
+      ...(options.sessionTimeoutMinutes !== undefined && { sessionTimeoutMinutes: options.sessionTimeoutMinutes }),
+      ...(options.filters && options.filters.length > 0 && { filters: options.filters }),
     };
 
     project.onlineEvalConfigs.push(config);

src/cli/primitives/__tests__/OnlineEvalConfigPrimitive.test.ts

@@ -95,6 +95,76 @@ describe('OnlineEvalConfigPrimitive', () => {
       expect(config.enableOnCreate).toBeUndefined();
     });
 
+    it('persists sessionTimeoutMinutes when provided', async () => {
+      mockReadProjectSpec.mockResolvedValue(makeProject());
+      mockWriteProjectSpec.mockResolvedValue(undefined);
+
+      const result = await primitive.add({
+        name: 'WithTimeout',
+        agent: 'MyAgent',
+        evaluators: ['Builtin.GoalSuccessRate'],
+        samplingRate: 10,
+        sessionTimeoutMinutes: 30,
+      });
+
+      expect(result.success).toBe(true);
+      const config = mockWriteProjectSpec.mock.calls[0]![0].onlineEvalConfigs[0];
+      expect(config.sessionTimeoutMinutes).toBe(30);
+    });
+
+    it('omits sessionTimeoutMinutes when not provided', async () => {
+      mockReadProjectSpec.mockResolvedValue(makeProject());
+      mockWriteProjectSpec.mockResolvedValue(undefined);
+
+      await primitive.add({
+        name: 'NoTimeout',
+        agent: 'MyAgent',
+        evaluators: ['Builtin.GoalSuccessRate'],
+        samplingRate: 10,
+      });
+
+      const config = mockWriteProjectSpec.mock.calls[0]![0].onlineEvalConfigs[0];
+      expect(config.sessionTimeoutMinutes).toBeUndefined();
+    });
+
+    it('persists filters when provided', async () => {
+      mockReadProjectSpec.mockResolvedValue(makeProject());
+      mockWriteProjectSpec.mockResolvedValue(undefined);
+
+      const filters = [
+        { key: 'userId', operator: 'Equals' as const, value: { stringValue: 'abc' } },
+        { key: 'score', operator: 'GreaterThan' as const, value: { doubleValue: 0.5 } },
+      ];
+
+      const result = await primitive.add({
+        name: 'WithFilters',
+        agent: 'MyAgent',
+        evaluators: ['Builtin.GoalSuccessRate'],
+        samplingRate: 10,
+        filters,
+      });
+
+      expect(result.success).toBe(true);
+      const config = mockWriteProjectSpec.mock.calls[0]![0].onlineEvalConfigs[0];
+      expect(config.filters).toEqual(filters);
+    });
+
+    it('omits filters when an empty array is provided', async () => {
+      mockReadProjectSpec.mockResolvedValue(makeProject());
+      mockWriteProjectSpec.mockResolvedValue(undefined);
+
+      await primitive.add({
+        name: 'EmptyFilters',
+        agent: 'MyAgent',
+        evaluators: ['Builtin.GoalSuccessRate'],
+        samplingRate: 10,
+        filters: [],
+      });
+
+      const config = mockWriteProjectSpec.mock.calls[0]![0].onlineEvalConfigs[0];
+      expect(config.filters).toBeUndefined();
+    });
+
     it('supports multiple evaluators including ARNs', async () => {
       mockReadProjectSpec.mockResolvedValue(makeProject());
       mockWriteProjectSpec.mockResolvedValue(undefined);

src/cli/primitives/__tests__/filter-flag-parser.test.ts

@@ -0,0 +1,99 @@
+import { parseFilterFlag, parseFilterFlags } from '../filter-flag-parser';
+import { describe, expect, it } from 'vitest';
+
+describe('parseFilterFlag', () => {
+  it('parses a string filter', () => {
+    expect(parseFilterFlag('key=userId,op=Equals,type=string,value=abc')).toEqual({
+      key: 'userId',
+      operator: 'Equals',
+      value: { stringValue: 'abc' },
+    });
+  });
+
+  it('parses a double filter', () => {
+    expect(parseFilterFlag('key=score,op=GreaterThan,type=double,value=0.75')).toEqual({
+      key: 'score',
+      operator: 'GreaterThan',
+      value: { doubleValue: 0.75 },
+    });
+  });
+
+  it('parses a boolean filter (true)', () => {
+    expect(parseFilterFlag('key=isPremium,op=Equals,type=boolean,value=true')).toEqual({
+      key: 'isPremium',
+      operator: 'Equals',
+      value: { booleanValue: true },
+    });
+  });
+
+  it('parses a boolean filter (false)', () => {
+    expect(parseFilterFlag('key=isPremium,op=NotEquals,type=boolean,value=false')).toEqual({
+      key: 'isPremium',
+      operator: 'NotEquals',
+      value: { booleanValue: false },
+    });
+  });
+
+  it('keeps "true" as a string when type=string', () => {
+    expect(parseFilterFlag('key=k,op=Equals,type=string,value=true')).toEqual({
+      key: 'k',
+      operator: 'Equals',
+      value: { stringValue: 'true' },
+    });
+  });
+
+  it('accepts fields in any order', () => {
+    expect(parseFilterFlag('value=abc,type=string,op=Contains,key=label')).toEqual({
+      key: 'label',
+      operator: 'Contains',
+      value: { stringValue: 'abc' },
+    });
+  });
+
+  it('throws on unknown operator', () => {
+    expect(() => parseFilterFlag('key=k,op=StartsWith,type=string,value=x')).toThrow(/op/);
+  });
+
+  it('throws on unknown type', () => {
+    expect(() => parseFilterFlag('key=k,op=Equals,type=int,value=1')).toThrow(/type/);
+  });
+
+  it('throws on missing required field', () => {
+    expect(() => parseFilterFlag('key=k,op=Equals,type=string')).toThrow(/value/);
+  });
+
+  it('throws on duplicate keys', () => {
+    expect(() => parseFilterFlag('key=k,key=other,op=Equals,type=string,value=v')).toThrow(/Duplicate/);
+  });
+
+  it('throws on invalid double value', () => {
+    expect(() => parseFilterFlag('key=k,op=Equals,type=double,value=notanumber')).toThrow(/double/);
+  });
+
+  it('throws on invalid boolean value', () => {
+    expect(() => parseFilterFlag('key=k,op=Equals,type=boolean,value=yes')).toThrow(/boolean/);
+  });
+
+  it('throws on empty input', () => {
+    expect(() => parseFilterFlag('')).toThrow();
+    expect(() => parseFilterFlag('   ')).toThrow();
+  });
+
+  it('throws on syntactic garbage', () => {
+    expect(() => parseFilterFlag('not_a_kv_pair')).toThrow();
+  });
+});
+
+describe('parseFilterFlags', () => {
+  it('returns undefined for missing/empty input', () => {
+    expect(parseFilterFlags(undefined)).toBeUndefined();
+    expect(parseFilterFlags([])).toBeUndefined();
+  });
+
+  it('parses multiple filters', () => {
+    const out = parseFilterFlags(['key=a,op=Equals,type=string,value=x', 'key=b,op=GreaterThan,type=double,value=2']);
+    expect(out).toHaveLength(2);
+    expect(out![0]!.key).toBe('a');
+    expect(out![1]!.value).toEqual({ doubleValue: 2 });
+  });
+});