@copilotkit/shared 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

package/src/utils/requests.ts

@@ -0,0 +1,77 @@
+/**
+ * Safely read a Response/Request body with sensible defaults:
+ * - clones the response/request to avoid consuming the original response/request
+ * - Skips GET/HEAD
+ * - Tries JSON first regardless of content-type
+ * - Falls back to text and optionally parses when it "looks" like JSON
+ */
+export async function readBody<T extends Response | Request>(r: T): Promise<unknown> {
+  // skip GET/HEAD requests (unchanged)
+  const method = "method" in r ? r.method.toUpperCase() : undefined;
+  if (method === "GET" || method === "HEAD") {
+    return undefined;
+  }
+
+  // no body at all → undefined (unchanged)
+  if (!("body" in r) || r.body == null) {
+    return undefined;
+  }
+
+  // 1) try JSON (unchanged)
+  try {
+    return await r.clone().json();
+  } catch {
+    // 2) try text (unchanged + your whitespace/JSON-heuristic)
+    try {
+      const text = await r.clone().text();
+      const trimmed = text.trim();
+
+      if (trimmed.length === 0) return text;
+
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          return JSON.parse(trimmed);
+        } catch {
+          return text;
+        }
+      }
+      return text;
+    } catch {
+      // 3) FINAL FALLBACK: manual read that accepts string or bytes
+      try {
+        const c = r.clone();
+        const stream: ReadableStream | null = c.body ?? null;
+        if (!stream) return undefined;
+
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let out = "";
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (typeof value === "string") {
+            out += value; // accept string chunks
+          } else {
+            out += decoder.decode(value, { stream: true }); // bytes
+          }
+        }
+        out += decoder.decode(); // flush
+
+        const trimmed = out.trim();
+        if (trimmed.length === 0) return out;
+
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+          try {
+            return JSON.parse(trimmed);
+          } catch {
+            return out;
+          }
+        }
+        return out;
+      } catch {
+        return undefined; // same "give up" behavior you had
+      }
+    }
+  }
+}

package/src/utils/types.ts

@@ -0,0 +1,22 @@
+export type MaybePromise<T> = T | PromiseLike<T>;
+
+/**
+ * More specific utility for records with at least one key
+ */
+export type NonEmptyRecord<T> =
+  T extends Record<string, unknown> ? (keyof T extends never ? never : T) : never;
+
+/**
+ * Type representing an agent's basic information
+ */
+export interface AgentDescription {
+  name: string;
+  className: string;
+  description: string;
+}
+
+export interface RuntimeInfo {
+  version: string;
+  agents: Record<string, AgentDescription>;
+  audioFileTranscriptionEnabled: boolean;
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../utilities/tsconfig/base.json",
+  "include": ["."],
+  "compilerOptions": {
+    "lib": ["es2017", "dom"],
+    "resolveJsonModule": true
+  },
+  "exclude": ["dist", "build", "node_modules", "**/*.test.ts", "**/*.test.tsx", "**/__tests__/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig, Options } from "tsup";
+
+export default defineConfig((options: Options) => ({
+  entry: ["src/**/*.{ts,tsx}", "!src/**/*.test.{ts,tsx}", "!src/**/__tests__/**/*"],
+  format: ["esm", "cjs"],
+  dts: true,
+  minify: false,
+  external: [],
+  sourcemap: true,
+  ...options,
+}));

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}