Add 0.0.39 backwards compatibility middleware

Author: mme

sdks/typescript/packages/client/src/__tests__/parse-semver.test.ts

@@ -3,14 +3,15 @@ import { parseSemanticVersion } from "../utils";
 describe("parseSemanticVersion", () => {
   it("parses full semantic versions", () => {
     const parsed = parseSemanticVersion("1.2.3");
-    expect(parsed).toEqual({
+    expect(parsed).toMatchObject({
       major: 1,
       minor: 2,
       patch: 3,
       prerelease: [],
       build: [],
       source: "1.2.3",
     });
+    expect(parsed.compare(parsed)).toBe(0);
   });
 
   it("defaults missing segments to zero", () => {
@@ -20,14 +21,15 @@ describe("parseSemanticVersion", () => {
 
   it("parses prerelease and build metadata", () => {
     const parsed = parseSemanticVersion("2.0.1-alpha.1+build.5");
-    expect(parsed).toEqual({
+    expect(parsed).toMatchObject({
       major: 2,
       minor: 0,
       patch: 1,
       prerelease: ["alpha", "1"],
       build: ["build", "5"],
       source: "2.0.1-alpha.1+build.5",
     });
+    expect(parsed.compare(parseSemanticVersion("2.0.1-alpha.2"))).toBeLessThan(0);
   });
 
   it("rejects non-semantic labels like latest", () => {

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

@@ -14,7 +14,12 @@ import { lastValueFrom } from "rxjs";
 import { transformChunks } from "@/chunks";
 import { AgentStateMutation, AgentSubscriber, runSubscribersWithMutation } from "./subscriber";
 import { AGUIConnectNotImplementedError } from "@ag-ui/core";
-import { Middleware, MiddlewareFunction, FunctionMiddleware } from "@/middleware";
+import {
+  Middleware,
+  MiddlewareFunction,
+  FunctionMiddleware,
+  BackwardCompatibility_0_0_39,
+} from "@/middleware";
 import packageJson from "../../package.json";
 
 export interface RunAgentResult {
@@ -48,7 +53,12 @@ export abstract class AbstractAgent {
     this.messages = structuredClone_(initialMessages ?? []);
     this.state = structuredClone_(initialState ?? {});
     this.debug = debug ?? false;
-    parseSemanticVersion(this.maxVersion);
+
+    const parsedMaxVersion = parseSemanticVersion(this.maxVersion);
+
+    if (parsedMaxVersion.compare(parseSemanticVersion("0.0.39")) <= 0) {
+      this.middlewares.unshift(new BackwardCompatibility_0_0_39());
+    }
   }
 
   public subscribe(subscriber: AgentSubscriber) {
@@ -62,7 +72,6 @@ export abstract class AbstractAgent {
 
   abstract run(input: RunAgentInput): Observable<BaseEvent>;
 
-
   public use(...middlewares: (Middleware | MiddlewareFunction)[]): this {
     const normalizedMiddlewares = middlewares.map((middleware) =>
       typeof middleware === "function" ? new FunctionMiddleware(middleware) : middleware,
@@ -71,7 +80,6 @@ export abstract class AbstractAgent {
     return this;
   }
 
-
   public async runAgent(
     parameters?: RunAgentParameters,
     subscriber?: AgentSubscriber,

sdks/typescript/packages/client/src/middleware/index.ts

@@ -1,3 +1,4 @@
 export { Middleware, FunctionMiddleware } from "./middleware";
 export type { MiddlewareFunction } from "./middleware";
 export { FilterToolCallsMiddleware } from "./filter-tool-calls";
+export { BackwardCompatibility_0_0_39 } from "./backward-compatibility-0-0-39";

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

@@ -27,10 +27,12 @@ export interface ParsedSemanticVersion {
   prerelease: string[];
   build: string[];
   source: string;
+  compare(other: ParsedSemanticVersion): number;
 }
 
 const SEMVER_PATTERN =
   /^(?<major>0|[1-9]\d*)(?:\.(?<minor>0|[1-9]\d*)(?:\.(?<patch>0|[1-9]\d*))?)?(?:-(?<prerelease>(?:0|[1-9A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9A-Za-z-][0-9A-Za-z-]*))*))?(?:\+(?<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+const NUMERIC_IDENTIFIER_PATTERN = /^\d+$/;
 
 /**
  * Parses a semantic version string into its numeric components.
@@ -56,12 +58,79 @@ export function parseSemanticVersion(version: string): ParsedSemanticVersion {
   const prerelease = match.groups.prerelease ? match.groups.prerelease.split(".") : [];
   const build = match.groups.build ? match.groups.build.split(".") : [];
 
-  return {
+  const parsed: ParsedSemanticVersion = {
     major,
     minor,
     patch,
     prerelease,
     build,
     source: version,
+    compare(this: ParsedSemanticVersion, other: ParsedSemanticVersion): number {
+      if (this.major !== other.major) {
+        return this.major - other.major;
+      }
+
+      if (this.minor !== other.minor) {
+        return this.minor - other.minor;
+      }
+
+      if (this.patch !== other.patch) {
+        return this.patch - other.patch;
+      }
+
+      if (this.prerelease.length === 0 && other.prerelease.length === 0) {
+        return 0;
+      }
+
+      if (this.prerelease.length === 0) {
+        return 1;
+      }
+
+      if (other.prerelease.length === 0) {
+        return -1;
+      }
+
+      const length = Math.max(this.prerelease.length, other.prerelease.length);
+      for (let index = 0; index < length; index++) {
+        const aIdentifier = this.prerelease[index];
+        const bIdentifier = other.prerelease[index];
+
+        if (aIdentifier === undefined) {
+          return -1;
+        }
+
+        if (bIdentifier === undefined) {
+          return 1;
+        }
+
+        const aIsNumeric = NUMERIC_IDENTIFIER_PATTERN.test(aIdentifier);
+        const bIsNumeric = NUMERIC_IDENTIFIER_PATTERN.test(bIdentifier);
+
+        if (aIsNumeric && bIsNumeric) {
+          const diff = Number(aIdentifier) - Number(bIdentifier);
+          if (diff !== 0) {
+            return diff;
+          }
+          continue;
+        }
+
+        if (aIsNumeric) {
+          return -1;
+        }
+
+        if (bIsNumeric) {
+          return 1;
+        }
+
+        const lexicalComparison = aIdentifier.localeCompare(bIdentifier);
+        if (lexicalComparison !== 0) {
+          return lexicalComparison;
+        }
+      }
+
+      return 0;
+    },
   };
+
+  return parsed;
 }