@copilotkit/shared 1.54.1 → 1.55.0-next.7

package/dist/utils/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/utils/types.ts"],"mappings":";KAAY,YAAA,MAAkB,CAAA,GAAI,WAAA,CAAY,CAAA;AAA9C;;;AAAA,KAKY,cAAA,MACV,CAAA,SAAU,MAAA,0BACA,CAAA,yBAEJ,CAAA;;;;UAMS,gBAAA;EACf,IAAA;EACA,SAAA;EACA,WAAA;AAAA;AAAA,UAGe,WAAA;EACf,OAAA;EACA,MAAA,EAAQ,MAAA,SAAe,gBAAA;EACvB,6BAAA;AAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/utils/types.ts"],"mappings":";KAAY,YAAA,MAAkB,CAAA,GAAI,WAAA,CAAY,CAAA;AAA9C;;;AAAA,KAKY,cAAA,MACV,CAAA,SAAU,MAAA,0BACA,CAAA,yBAEJ,CAAA;;;;UAMS,gBAAA;EACf,IAAA;EACA,SAAA;EACA,WAAA;AAAA;AAAA,KAGU,WAAA;AAAA,cAEC,gBAAA;AAAA,cACA,yBAAA;AAAA,UAEI,uBAAA;EACf,KAAA;AAAA;AAAA,KAGU,oBAAA;AAAA,UAQK,WAAA;EACf,OAAA;EACA,MAAA,EAAQ,MAAA,SAAe,gBAAA;EACvB,6BAAA;EACA,IAAA,EAAM,WAAA;EACN,YAAA,GAAe,uBAAA;EACf,WAAA;EACA,aAAA,GAAgB,oBAAA;AAAA"}

package/dist/utils/types.d.mts

@@ -12,11 +12,22 @@ interface AgentDescription {
   className: string;
   description: string;
 }
+type RuntimeMode = "sse" | "intelligence";
+declare const RUNTIME_MODE_SSE: "sse";
+declare const RUNTIME_MODE_INTELLIGENCE: "intelligence";
+interface IntelligenceRuntimeInfo {
+  wsUrl: string;
+}
+type RuntimeLicenseStatus = "valid" | "none" | "expired" | "expiring" | "invalid" | "unknown";
 interface RuntimeInfo {
   version: string;
   agents: Record<string, AgentDescription>;
   audioFileTranscriptionEnabled: boolean;
+  mode: RuntimeMode;
+  intelligence?: IntelligenceRuntimeInfo;
+  a2uiEnabled?: boolean;
+  licenseStatus?: RuntimeLicenseStatus;
 }
 //#endregion
-export { AgentDescription, MaybePromise, NonEmptyRecord, RuntimeInfo };
+export { AgentDescription, IntelligenceRuntimeInfo, MaybePromise, NonEmptyRecord, RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, RuntimeInfo, RuntimeLicenseStatus, RuntimeMode };
 //# sourceMappingURL=types.d.mts.map

package/dist/utils/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/utils/types.ts"],"mappings":";KAAY,YAAA,MAAkB,CAAA,GAAI,WAAA,CAAY,CAAA;AAA9C;;;AAAA,KAKY,cAAA,MACV,CAAA,SAAU,MAAA,0BACA,CAAA,yBAEJ,CAAA;;;;UAMS,gBAAA;EACf,IAAA;EACA,SAAA;EACA,WAAA;AAAA;AAAA,UAGe,WAAA;EACf,OAAA;EACA,MAAA,EAAQ,MAAA,SAAe,gBAAA;EACvB,6BAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/utils/types.ts"],"mappings":";KAAY,YAAA,MAAkB,CAAA,GAAI,WAAA,CAAY,CAAA;AAA9C;;;AAAA,KAKY,cAAA,MACV,CAAA,SAAU,MAAA,0BACA,CAAA,yBAEJ,CAAA;;;;UAMS,gBAAA;EACf,IAAA;EACA,SAAA;EACA,WAAA;AAAA;AAAA,KAGU,WAAA;AAAA,cAEC,gBAAA;AAAA,cACA,yBAAA;AAAA,UAEI,uBAAA;EACf,KAAA;AAAA;AAAA,KAGU,oBAAA;AAAA,UAQK,WAAA;EACf,OAAA;EACA,MAAA,EAAQ,MAAA,SAAe,gBAAA;EACvB,6BAAA;EACA,IAAA,EAAM,WAAA;EACN,YAAA,GAAe,uBAAA;EACf,WAAA;EACA,aAAA,GAAgB,oBAAA;AAAA"}

package/dist/utils/types.mjs

@@ -0,0 +1,7 @@
+//#region src/utils/types.ts
+const RUNTIME_MODE_SSE = "sse";
+const RUNTIME_MODE_INTELLIGENCE = "intelligence";
+
+//#endregion
+export { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE };
+//# sourceMappingURL=types.mjs.map

package/dist/utils/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/utils/types.ts"],"sourcesContent":["export type MaybePromise<T> = T | PromiseLike<T>;\n\n/**\n * More specific utility for records with at least one key\n */\nexport type NonEmptyRecord<T> =\n  T extends Record<string, unknown>\n    ? keyof T extends never\n      ? never\n      : T\n    : never;\n\n/**\n * Type representing an agent's basic information\n */\nexport interface AgentDescription {\n  name: string;\n  className: string;\n  description: string;\n}\n\nexport type RuntimeMode = \"sse\" | \"intelligence\";\n\nexport const RUNTIME_MODE_SSE = \"sse\" as const;\nexport const RUNTIME_MODE_INTELLIGENCE = \"intelligence\" as const;\n\nexport interface IntelligenceRuntimeInfo {\n  wsUrl: string;\n}\n\nexport type RuntimeLicenseStatus =\n  | \"valid\"\n  | \"none\"\n  | \"expired\"\n  | \"expiring\"\n  | \"invalid\"\n  | \"unknown\";\n\nexport interface RuntimeInfo {\n  version: string;\n  agents: Record<string, AgentDescription>;\n  audioFileTranscriptionEnabled: boolean;\n  mode: RuntimeMode;\n  intelligence?: IntelligenceRuntimeInfo;\n  a2uiEnabled?: boolean;\n  licenseStatus?: RuntimeLicenseStatus;\n}\n"],"mappings":";AAuBA,MAAa,mBAAmB;AAChC,MAAa,4BAA4B"}

package/package.json

@@ -10,7 +10,7 @@
     "access": "public"
   },
   "type": "module",
-  "version": "1.54.1",
+  "version": "1.55.0-next.7",
   "sideEffects": false,
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -27,19 +27,26 @@
   "license": "MIT",
   "devDependencies": {
     "@types/uuid": "^10.0.0",
+    "@valibot/to-json-schema": "^1.5.0",
+    "arktype": "^2.1.29",
     "eslint": "^8.56.0",
     "tsdown": "^0.20.3",
     "typescript": "^5.2.3",
+    "valibot": "^1.2.0",
     "vitest": "^3.2.4",
     "zod-to-json-schema": "^3.23.5",
-    "eslint-config-custom": "1.4.13",
-    "tsconfig": "1.4.13"
+    "eslint-config-custom": "1.4.12",
+    "tsconfig": "1.4.12"
   },
   "dependencies": {
+    "@ag-ui/client": "0.0.47",
     "@segment/analytics-node": "^2.1.2",
+    "@standard-schema/spec": "^1.0.0",
     "chalk": "4.1.2",
     "graphql": "^16.8.1",
-    "uuid": "^10.0.0",
+    "partial-json": "^0.1.7",
+    "uuid": "^11.1.0",
+    "@copilotkit/license-verifier": "0.0.1-a1",
     "zod": "^3.23.3"
   },
   "peerDependencies": {

package/src/__tests__/standard-schema-types.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expectTypeOf } from "vitest";
+import { z } from "zod";
+import * as v from "valibot";
+import { type } from "arktype";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { InferSchemaOutput } from "../standard-schema";
+
+describe("InferSchemaOutput type inference", () => {
+  describe("Zod schemas", () => {
+    it("infers output type from a Zod object schema", () => {
+      const schema = z.object({
+        city: z.string(),
+        count: z.number(),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        city: string;
+        count: number;
+      }>();
+    });
+
+    it("infers output type with optional fields", () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        name: string;
+        age?: number | undefined;
+      }>();
+    });
+
+    it("infers output type with enums", () => {
+      const schema = z.object({
+        unit: z.enum(["celsius", "fahrenheit"]),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        unit: "celsius" | "fahrenheit";
+      }>();
+    });
+
+    it("infers output type with nested objects", () => {
+      const schema = z.object({
+        user: z.object({
+          name: z.string(),
+          email: z.string(),
+        }),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        user: { name: string; email: string };
+      }>();
+    });
+
+    it("infers output type with arrays", () => {
+      const schema = z.object({
+        tags: z.array(z.string()),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        tags: string[];
+      }>();
+    });
+  });
+
+  describe("Valibot schemas", () => {
+    it("infers output type from a Valibot object schema", () => {
+      const schema = v.object({
+        query: v.string(),
+        limit: v.number(),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        query: string;
+        limit: number;
+      }>();
+    });
+
+    it("infers output type with optional fields", () => {
+      const schema = v.object({
+        name: v.string(),
+        age: v.optional(v.number()),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        name: string;
+        age?: number | undefined;
+      }>();
+    });
+
+    it("infers output type with nested objects", () => {
+      const schema = v.object({
+        user: v.object({
+          name: v.string(),
+          email: v.string(),
+        }),
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        user: { name: string; email: string };
+      }>();
+    });
+  });
+
+  describe("ArkType schemas", () => {
+    it("infers output type from an ArkType object schema", () => {
+      const schema = type({
+        query: "string",
+        limit: "number",
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        query: string;
+        limit: number;
+      }>();
+    });
+
+    it("infers output type with optional fields", () => {
+      const schema = type({
+        name: "string",
+        "age?": "number",
+      });
+
+      expectTypeOf<InferSchemaOutput<typeof schema>>().toEqualTypeOf<{
+        name: string;
+        age?: number;
+      }>();
+    });
+  });
+
+  describe("StandardSchemaV1 compatibility", () => {
+    it("all schema types satisfy StandardSchemaV1", () => {
+      expectTypeOf(
+        z.object({ a: z.string() }),
+      ).toMatchTypeOf<StandardSchemaV1>();
+      expectTypeOf(
+        v.object({ a: v.string() }),
+      ).toMatchTypeOf<StandardSchemaV1>();
+      expectTypeOf(type({ a: "string" })).toMatchTypeOf<StandardSchemaV1>();
+    });
+  });
+});

package/src/__tests__/standard-schema.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect } from "vitest";
+import { z } from "zod";
+import * as v from "valibot";
+import { toStandardJsonSchema } from "@valibot/to-json-schema";
+import { type } from "arktype";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { schemaToJsonSchema } from "../standard-schema";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+describe("schemaToJsonSchema", () => {
+  describe("Zod schemas (via injected zodToJsonSchema)", () => {
+    it("converts a simple zod object schema", () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number(),
+      });
+
+      const result = schemaToJsonSchema(schema, { zodToJsonSchema });
+
+      expect(result).toHaveProperty("type", "object");
+      expect(result).toHaveProperty("properties.name.type", "string");
+      expect(result).toHaveProperty("properties.age.type", "number");
+      expect(result).toHaveProperty("required");
+      expect(result.required).toContain("name");
+      expect(result.required).toContain("age");
+    });
+
+    it("converts a zod schema with optional fields", () => {
+      const schema = z.object({
+        city: z.string(),
+        units: z.enum(["celsius", "fahrenheit"]).optional(),
+      });
+
+      const result = schemaToJsonSchema(schema, { zodToJsonSchema });
+
+      expect(result).toHaveProperty("type", "object");
+      expect(result).toHaveProperty("properties.city.type", "string");
+      expect(result.required).toContain("city");
+      expect(result.required).not.toContain("units");
+    });
+
+    it("has vendor 'zod' on ~standard", () => {
+      const schema = z.object({ foo: z.string() });
+      expect(schema["~standard"].vendor).toBe("zod");
+    });
+  });
+
+  describe("Valibot schemas (via toStandardJsonSchema wrapper)", () => {
+    it("has vendor 'valibot' on ~standard", () => {
+      const schema = v.object({ name: v.string() });
+      expect(schema["~standard"].vendor).toBe("valibot");
+    });
+
+    it("satisfies StandardSchemaV1", () => {
+      const schema = v.object({ name: v.string() });
+      const _: StandardSchemaV1 = schema;
+      expect(_["~standard"].version).toBe(1);
+    });
+
+    it("raw valibot schema throws (no ~standard.jsonSchema)", () => {
+      const schema = v.object({ name: v.string() });
+      expect(() => schemaToJsonSchema(schema)).toThrow(
+        /Cannot convert schema to JSON Schema/,
+      );
+    });
+
+    it("converts a valibot schema wrapped with toStandardJsonSchema", () => {
+      const schema = toStandardJsonSchema(
+        v.object({
+          name: v.string(),
+          age: v.number(),
+        }),
+      );
+
+      const result = schemaToJsonSchema(schema);
+
+      expect(result).toHaveProperty("type", "object");
+      expect(result).toHaveProperty("properties.name.type", "string");
+      expect(result).toHaveProperty("properties.age.type", "number");
+      expect(result.required).toContain("name");
+      expect(result.required).toContain("age");
+    });
+
+    it("converts a valibot schema with optional fields", () => {
+      const schema = toStandardJsonSchema(
+        v.object({
+          city: v.string(),
+          units: v.optional(v.picklist(["celsius", "fahrenheit"])),
+        }),
+      );
+
+      const result = schemaToJsonSchema(schema);
+
+      expect(result).toHaveProperty("type", "object");
+      expect(result).toHaveProperty("properties.city");
+      expect(result.required).toContain("city");
+    });
+  });
+
+  describe("ArkType schemas (native ~standard.jsonSchema)", () => {
+    it("has vendor 'arktype' on ~standard", () => {
+      const schema = type({ name: "string" });
+      expect(schema["~standard"].vendor).toBe("arktype");
+    });
+
+    it("satisfies StandardSchemaV1", () => {
+      const schema = type({ name: "string" });
+      const _: StandardSchemaV1 = schema;
+      expect(_["~standard"].version).toBe(1);
+    });
+
+    it("natively implements ~standard.jsonSchema", () => {
+      const schema = type({ name: "string" });
+      const props = schema["~standard"];
+      expect(props.jsonSchema).toBeDefined();
+      expect(typeof props.jsonSchema.input).toBe("function");
+    });
+
+    it("converts an arktype schema directly", () => {
+      const schema = type({
+        name: "string",
+        age: "number",
+      });
+
+      const result = schemaToJsonSchema(schema);
+
+      expect(result).toHaveProperty("type", "object");
+      expect(result).toHaveProperty("properties.name.type", "string");
+      expect(result).toHaveProperty("properties.age.type", "number");
+      expect(result.required).toContain("name");
+      expect(result.required).toContain("age");
+    });
+
+    it("converts an arktype schema without needing zodToJsonSchema fallback", () => {
+      const schema = type({ query: "string" });
+
+      // No zodToJsonSchema option needed — arktype uses Standard JSON Schema V1 natively
+      const result = schemaToJsonSchema(schema);
+
+      expect(result).toHaveProperty("type", "object");
+      expect(result).toHaveProperty("properties.query.type", "string");
+    });
+  });
+
+  describe("Standard JSON Schema V1 protocol (mock)", () => {
+    it("uses ~standard.jsonSchema.input() when present", () => {
+      const mockSchema: StandardSchemaV1 & {
+        "~standard": StandardSchemaV1["~standard"] & {
+          jsonSchema: {
+            input: (opts: { target: string }) => Record<string, unknown>;
+          };
+        };
+      } = {
+        "~standard": {
+          version: 1,
+          vendor: "mock-lib",
+          validate: (value: unknown) => ({ value }),
+          jsonSchema: {
+            input: (opts: { target: string }) => ({
+              type: "object",
+              properties: {
+                query: { type: "string" },
+              },
+              required: ["query"],
+              $generatedBy: "mock-lib",
+              $target: opts.target,
+            }),
+          },
+        },
+      };
+
+      const result = schemaToJsonSchema(mockSchema);
+
+      expect(result).toEqual({
+        type: "object",
+        properties: { query: { type: "string" } },
+        required: ["query"],
+        $generatedBy: "mock-lib",
+        $target: "draft-07",
+      });
+    });
+
+    it("prefers ~standard.jsonSchema over zodToJsonSchema fallback", () => {
+      const mockSchema = {
+        "~standard": {
+          version: 1,
+          vendor: "zod",
+          validate: (value: unknown) => ({ value }),
+          jsonSchema: {
+            input: () => ({
+              type: "object",
+              properties: { fromJsonSchema: { type: "boolean" } },
+            }),
+          },
+        },
+      };
+
+      const zodFallback = () => ({
+        type: "object",
+        properties: { fromZodFallback: { type: "boolean" } },
+      });
+
+      const result = schemaToJsonSchema(mockSchema, {
+        zodToJsonSchema: zodFallback,
+      });
+
+      // Should use ~standard.jsonSchema, not the zod fallback
+      expect(result).toHaveProperty("properties.fromJsonSchema");
+      expect(result).not.toHaveProperty("properties.fromZodFallback");
+    });
+  });
+
+  describe("Error handling", () => {
+    it("throws when schema has no jsonSchema support and no zodToJsonSchema", () => {
+      const mockSchema: StandardSchemaV1 = {
+        "~standard": {
+          version: 1,
+          vendor: "unknown-lib",
+          validate: (value: unknown) => ({ value }),
+        },
+      };
+
+      expect(() => schemaToJsonSchema(mockSchema)).toThrow(
+        /Cannot convert schema to JSON Schema/,
+      );
+      expect(() => schemaToJsonSchema(mockSchema)).toThrow(/unknown-lib/);
+    });
+
+    it("throws for non-zod vendor when zodToJsonSchema is not provided", () => {
+      const mockSchema: StandardSchemaV1 = {
+        "~standard": {
+          version: 1,
+          vendor: "some-other-lib",
+          validate: (value: unknown) => ({ value }),
+        },
+      };
+
+      expect(() => schemaToJsonSchema(mockSchema)).toThrow(
+        /no zodToJsonSchema fallback/,
+      );
+    });
+
+    it("uses zodToJsonSchema fallback for zod vendor schemas", () => {
+      const mockZodSchema: StandardSchemaV1 = {
+        "~standard": {
+          version: 1,
+          vendor: "zod",
+          validate: (value: unknown) => ({ value }),
+        },
+      };
+
+      const fallback = () => ({
+        type: "object",
+        properties: { test: { type: "string" } },
+      });
+
+      const result = schemaToJsonSchema(mockZodSchema, {
+        zodToJsonSchema: fallback,
+      });
+
+      expect(result).toEqual({
+        type: "object",
+        properties: { test: { type: "string" } },
+      });
+    });
+  });
+});