fix unit tests

Author: mme

sdks/typescript/packages/client/src/agent/agent.ts

@@ -30,6 +30,8 @@ export abstract class AbstractAgent {
   public subscribers: AgentSubscriber[] = [];
   private middlewares: Middleware[] = [];
 
+  public readonly maxVersion: string = "*";
+
   constructor({
     agentId,
     description,
@@ -94,10 +96,11 @@ export abstract class AbstractAgent {
         }
 
         const chainedAgent = this.middlewares.reduceRight(
-          (nextAgent: AbstractAgent, middleware) => ({
-            run: (i: RunAgentInput) => middleware.run(i, nextAgent),
-          } as AbstractAgent),
-          this // Original agent is the final 'next'
+          (nextAgent: AbstractAgent, middleware) =>
+            ({
+              run: (i: RunAgentInput) => middleware.run(i, nextAgent),
+            }) as AbstractAgent,
+          this, // Original agent is the final 'next'
         );
 
         return chainedAgent.run(input);
@@ -447,10 +450,11 @@ export abstract class AbstractAgent {
       }
 
       const chainedAgent = this.middlewares.reduceRight(
-        (nextAgent: AbstractAgent, middleware) => ({
-          run: (i: RunAgentInput) => middleware.run(i, nextAgent)
-        } as AbstractAgent),
-        this
+        (nextAgent: AbstractAgent, middleware) =>
+          ({
+            run: (i: RunAgentInput) => middleware.run(i, nextAgent),
+          }) as AbstractAgent,
+        this,
       );
 
       return chainedAgent.run(input);

sdks/typescript/packages/client/src/middleware/__tests__/function-middleware.test.ts

@@ -39,25 +39,31 @@ describe("FunctionMiddleware", () => {
 
     const middlewareFn: MiddlewareFunction = (middlewareInput, next) => {
       return new Observable<BaseEvent>((subscriber) => {
-        subscriber.next({
-          type: EventType.RUN_STARTED,
-          threadId: middlewareInput.threadId,
-          runId: middlewareInput.runId,
-        });
-
-        next.run(middlewareInput).subscribe({
+        const subscription = next.run(middlewareInput).subscribe({
           next: (event) => {
+            if (event.type === EventType.RUN_STARTED) {
+              subscriber.next({
+                ...event,
+                metadata: { ...(event as any).metadata, fromMiddleware: true },
+              });
+              return;
+            }
+
             if (event.type === EventType.RUN_FINISHED) {
               subscriber.next({
                 ...event,
                 result: { success: true },
               });
-            } else {
-              subscriber.next(event);
+              return;
             }
+
+            subscriber.next(event);
           },
+          error: (error) => subscriber.error(error),
           complete: () => subscriber.complete(),
         });
+
+        return () => subscription.unsubscribe();
       });
     };
 
@@ -73,6 +79,7 @@ describe("FunctionMiddleware", () => {
 
     expect(events.length).toBe(2);
     expect(events[0].type).toBe(EventType.RUN_STARTED);
+    expect((events[0] as any).metadata).toEqual({ fromMiddleware: true });
     expect(events[1].type).toBe(EventType.RUN_FINISHED);
     expect((events[1] as any).result).toEqual({ success: true });
   });

sdks/typescript/packages/client/src/middleware/__tests__/middleware-live-events.test.ts

@@ -42,17 +42,27 @@ describe("Middleware live events", () => {
   class CustomMiddleware extends Middleware {
     run(input: RunAgentInput, next: AbstractAgent): Observable<BaseEvent> {
       return new Observable<BaseEvent>((subscriber) => {
-        subscriber.next({
-          type: EventType.RUN_STARTED,
-          threadId: input.threadId,
-          runId: input.runId,
-          metadata: { custom: true },
-        } as RunStartedEvent);
+        const subscription = next.run(input).subscribe({
+          next: (event) => {
+            if (event.type === EventType.RUN_STARTED) {
+              const started = event as RunStartedEvent;
+              subscriber.next({
+                ...started,
+                metadata: {
+                  ...(started.metadata ?? {}),
+                  custom: true,
+                },
+              });
+              return;
+            }
 
-        next.run(input).subscribe({
-          next: (event) => subscriber.next(event),
+            subscriber.next(event);
+          },
+          error: (error) => subscriber.error(error),
           complete: () => subscriber.complete(),
         });
+
+        return () => subscription.unsubscribe();
       });
     }
   }
@@ -82,7 +92,7 @@ describe("Middleware live events", () => {
     expect(events.length).toBe(3);
     expect(events[0].type).toBe(EventType.RUN_STARTED);
     expect((events[0] as RunStartedEvent).metadata).toEqual({ custom: true });
-    expect(events[1].type).toBe(EventType.RUN_STARTED);
-    expect(events[2].type).toBe(EventType.TEXT_MESSAGE_CHUNK);
+    expect(events[1].type).toBe(EventType.TEXT_MESSAGE_CHUNK);
+    expect(events[2].type).toBe(EventType.RUN_FINISHED);
   });
 });

sdks/typescript/packages/client/src/middleware/__tests__/middleware-with-state.test.ts

@@ -73,9 +73,11 @@ describe("Middleware runNextWithState", () => {
       });
     });
 
-    expect(events.length).toBe(3);
+    expect(events.length).toBe(5);
     expect(events[0].type).toBe(EventType.RUN_STARTED);
-    expect(events[1].type).toBe(EventType.TEXT_MESSAGE_CHUNK);
-    expect(events[2].type).toBe(EventType.RUN_FINISHED);
+    expect(events[1].type).toBe(EventType.TEXT_MESSAGE_START);
+    expect(events[2].type).toBe(EventType.TEXT_MESSAGE_CONTENT);
+    expect(events[3].type).toBe(EventType.TEXT_MESSAGE_END);
+    expect(events[4].type).toBe(EventType.RUN_FINISHED);
   });
 });

sdks/typescript/packages/client/src/middleware/__tests__/middleware.test.ts

@@ -28,17 +28,23 @@ describe("Middleware", () => {
   class TestMiddleware extends Middleware {
     run(input: RunAgentInput, next: AbstractAgent): Observable<BaseEvent> {
       return new Observable<BaseEvent>((subscriber) => {
-        subscriber.next({
-          type: EventType.RUN_STARTED,
-          threadId: input.threadId,
-          runId: input.runId,
-          metadata: { middleware: true },
-        });
+        const subscription = next.run(input).subscribe({
+          next: (event) => {
+            if (event.type === EventType.RUN_STARTED) {
+              subscriber.next({
+                ...event,
+                metadata: { ...(event as any).metadata, middleware: true },
+              });
+              return;
+            }
 
-        next.run(input).subscribe({
-          next: (event) => subscriber.next(event),
+            subscriber.next(event);
+          },
+          error: (error) => subscriber.error(error),
           complete: () => subscriber.complete(),
         });
+
+        return () => subscription.unsubscribe();
       });
     }
   }
@@ -65,11 +71,10 @@ describe("Middleware", () => {
       });
     });
 
-    expect(events.length).toBe(3);
+    expect(events.length).toBe(2);
     expect(events[0].type).toBe(EventType.RUN_STARTED);
     expect((events[0] as any).metadata).toEqual({ middleware: true });
-    expect(events[1].type).toBe(EventType.RUN_STARTED);
-    expect(events[2].type).toBe(EventType.RUN_FINISHED);
-    expect((events[2] as any).result).toEqual({ success: true });
+    expect(events[1].type).toBe(EventType.RUN_FINISHED);
+    expect((events[1] as any).result).toEqual({ success: true });
   });
 });