fix build errors and use semver library

Author: mme

apps/dojo/src/app/api/copilotkitnext/[integrationId]/[[...slug]]/route.ts

@@ -6,6 +6,7 @@ import {
 import { handle } from "hono/vercel";
 import type { NextRequest } from "next/server";
 import { BasicAgent } from "@copilotkitnext/agent";
+import type { AbstractAgent } from "@ag-ui/client";
 
 type RouteParams = {
   params: Promise<{
@@ -22,11 +23,13 @@ function getHandler(integrationId: string) {
     return cached;
   }
 
+  const defaultAgent = new BasicAgent({
+    model: "openai/gpt-4o",
+  }) as unknown as AbstractAgent; // Cast until upstream marks run() public.
+
   const runtime = new CopilotRuntime({
     agents: {
-      default: new BasicAgent({
-        model: "openai/gpt-4o",
-      }),
+      default: defaultAgent,
     },
     runner: new InMemoryAgentRunner(),
   });

integrations/a2a/typescript/src/agent.ts

@@ -50,7 +50,7 @@ export class A2AAgent extends AbstractAgent {
     return new A2AAgent({ a2aClient: this.a2aClient, debug: this.debug });
   }
 
-  protected run(input: RunAgentInput): Observable<BaseEvent> {
+  public override run(input: RunAgentInput): Observable<BaseEvent> {
     return new Observable<BaseEvent>((subscriber) => {
       const run = async () => {
         const runStarted: RunStartedEvent = {

integrations/mastra/typescript/examples/.gitignore

@@ -2,6 +2,7 @@ output.txt
 node_modules
 dist
 .mastra
+.npm-cache
 .env.development
 .env
 *.db

pnpm-lock.yaml

@@ -25,9 +25,10 @@
   },
   "dependencies": {
     "@ag-ui/core": "workspace:*",
-    "@ag-ui/proto": "workspace:*",
     "@ag-ui/encoder": "workspace:*",
+    "@ag-ui/proto": "workspace:*",
     "@types/uuid": "^10.0.0",
+    "compare-versions": "^6.1.1",
     "fast-json-patch": "^3.1.1",
     "rxjs": "7.8.1",
     "untruncate-json": "^0.0.1",

sdks/typescript/packages/client/package.json

@@ -3,7 +3,8 @@ import { Message, State, RunAgentInput, BaseEvent, ToolCall, AssistantMessage }
 
 import { AgentConfig, RunAgentParameters } from "./types";
 import { v4 as uuidv4 } from "uuid";
-import { structuredClone_, parseSemanticVersion } from "@/utils";
+import { structuredClone_ } from "@/utils";
+import { compareVersions } from "compare-versions";
 import { catchError, map, tap } from "rxjs/operators";
 import { finalize } from "rxjs/operators";
 import { pipe, Observable, from, of, EMPTY } from "rxjs";
@@ -57,9 +58,7 @@ export abstract class AbstractAgent {
     this.state = structuredClone_(initialState ?? {});
     this.debug = debug ?? false;
 
-    const parsedMaxVersion = parseSemanticVersion(this.maxVersion);
-
-    if (parsedMaxVersion.compare(parseSemanticVersion("0.0.39")) <= 0) {
+    if (compareVersions(this.maxVersion, "0.0.39") <= 0) {
       this.middlewares.unshift(new BackwardCompatibility_0_0_39());
     }
   }

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

@@ -20,117 +20,14 @@ export function randomUUID(): string {
   return uuidv4();
 }
 
-export interface ParsedSemanticVersion {
-  major: number;
-  minor: number;
-  patch: number;
-  prerelease: string[];
-  build: string[];
-  source: string;
-  compare(other: ParsedSemanticVersion): number;
-}
+// Note: semver helpers were removed in favor of using
+// the external `compare-versions` library directly at call sites.
 
-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.
  * Supports incomplete versions (e.g. "1", "1.2") by defaulting missing segments to zero.
  *
  * @throws If the version string is not a valid semantic version.
  */
-export function parseSemanticVersion(version: string): ParsedSemanticVersion {
-  const trimmed = version.trim();
-
-  if (trimmed.length === 0) {
-    throw new Error("Semantic version cannot be empty");
-  }
-
-  const match = SEMVER_PATTERN.exec(trimmed);
-  if (!match || !match.groups?.major) {
-    throw new Error(`Invalid semantic version: "${version}"`);
-  }
-
-  const major = Number.parseInt(match.groups.major, 10);
-  const minor = match.groups.minor ? Number.parseInt(match.groups.minor, 10) : 0;
-  const patch = match.groups.patch ? Number.parseInt(match.groups.patch, 10) : 0;
-  const prerelease = match.groups.prerelease ? match.groups.prerelease.split(".") : [];
-  const build = match.groups.build ? match.groups.build.split(".") : [];
-
-  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;
-}
+// (Intentionally left minimal.)