@orq-ai/node 3.9.4 → 3.9.5

package/packages/orq-rc/src/funcs/deploymentsStream.ts

@@ -162,16 +162,15 @@ async function $do(
     M.sse(
       200,
       z.instanceof(ReadableStream<Uint8Array>).transform(stream => {
-        return new EventStream({
-          stream,
-          decoder(rawEvent) {
-            const schema =
-              operations.DeploymentStreamResponseBody$inboundSchema;
-            return schema.parse(rawEvent);
-          },
+        return new EventStream(stream, rawEvent => {
+          if (rawEvent.data === "[DONE]") return { done: true };
+          return {
+            value: operations.DeploymentStreamResponseBody$inboundSchema.parse(
+              rawEvent,
+            ),
+          };
         });
       }),
-      { sseSentinel: "[DONE]" },
     ),
     M.fail("4XX"),
     M.fail("5XX"),

package/packages/orq-rc/src/lib/config.ts

@@ -68,7 +68,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "2.0",
-  sdkVersion: "3.10.0-rc.0",
-  genVersion: "2.648.7",
-  userAgent: "speakeasy-sdk/typescript 3.10.0-rc.0 2.648.7 2.0 @orq-ai/node",
+  sdkVersion: "3.10.0-rc.2",
+  genVersion: "2.652.0",
+  userAgent: "speakeasy-sdk/typescript 3.10.0-rc.2 2.652.0 2.0 @orq-ai/node",
 } as const;

package/packages/orq-rc/src/lib/event-streams.ts

@@ -5,260 +5,143 @@
 export type ServerEvent<T> = {
   data?: T | undefined;
   event?: string | undefined;
-  retry?: number | undefined;
   id?: string | undefined;
+  retry?: number | undefined;
 };
-const LF = 0x0a;
-const CR = 0x0d;
-const NEWLINE_CHARS = new Set([LF, CR]);
-const MESSAGE_BOUNDARIES = [
-  new Uint8Array([CR, LF, CR, LF]),
-  new Uint8Array([CR, CR]),
-  new Uint8Array([LF, LF]),
-];
-
-export class EventStream<Event extends ServerEvent<unknown>> {
-  private readonly stream: ReadableStream<Uint8Array>;
-  private readonly decoder: (rawEvent: ServerEvent<string>) => Event;
-
-  constructor(init: {
-    stream: ReadableStream<Uint8Array>;
-    decoder: (rawEvent: ServerEvent<string>) => Event;
-  }) {
-    this.stream = init.stream;
-    this.decoder = init.decoder;
-  }
-
-  async *[Symbol.asyncIterator](): AsyncGenerator<Event, void, unknown> {
-    const reader = this.stream.getReader();
-    let buffer = new Uint8Array([]);
-    let position = 0;
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-
-        const newBuffer = new Uint8Array(buffer.length + value.length);
-        newBuffer.set(buffer);
-        newBuffer.set(value, buffer.length);
-        buffer = newBuffer;
-
-        for (let i = position; i < buffer.length; i++) {
-          const boundary = findBoundary(buffer, i);
-          if (boundary == null) {
-            continue;
-          }
 
-          const chunk = buffer.slice(position, i);
-          position = i + boundary.length;
-          const event = parseEvent(chunk, this.decoder);
-          if (event != null) {
-            yield event;
+export class EventStream<T extends ServerEvent<unknown>>
+  extends ReadableStream<T>
+{
+  constructor(
+    stream: ReadableStream<Uint8Array>,
+    parse: (x: ServerEvent<string>) => IteratorResult<T, undefined>,
+  ) {
+    const reader = stream.getReader();
+    let buffer: Uint8Array = new Uint8Array();
+    super({
+      async pull(controller) {
+        try {
+          const r = await reader.read();
+          if (r.done) return controller.close();
+          buffer = concatBuffer(buffer, r.value);
+          for (const { chunk, remainder } of chunks(buffer)) {
+            buffer = remainder;
+            const item = parseChunk(chunk, parse);
+            if (item?.value) controller.enqueue(item.value);
+            if (item?.done) {
+              await reader.cancel("done");
+              return controller.close();
+            }
           }
+        } catch (e) {
+          await reader.cancel(e);
+          controller.error(e);
         }
+      },
+      cancel: reason => reader.cancel(reason),
+    });
+  }
 
-        if (position > 0) {
-          buffer = buffer.slice(position);
-          position = 0;
-        }
-      }
-
-      if (buffer.length > 0) {
-        const event = parseEvent(buffer, this.decoder);
-        if (event != null) {
-          yield event;
+  // Polyfill for older browsers
+  [Symbol.asyncIterator](): AsyncIterableIterator<T, void, unknown> {
+    const fn = (ReadableStream.prototype as any)[Symbol.asyncIterator];
+    if (typeof fn === "function") return fn.call(this);
+    const reader = this.getReader();
+    return {
+      next: async () => {
+        const r = await reader.read();
+        if (r.done) {
+          reader.releaseLock();
+          return { done: true, value: undefined };
         }
-      }
-    } catch (e: unknown) {
-      if (e instanceof Error && e.name === "AbortError") {
-        return;
-      }
-
-      throw e;
-    } finally {
-      reader.releaseLock();
-    }
+        return { done: false, value: r.value };
+      },
+      throw: async (e) => {
+        await reader.cancel(e);
+        reader.releaseLock();
+        return { done: true, value: undefined };
+      },
+      return: async () => {
+        await reader.cancel("done");
+        reader.releaseLock();
+        return { done: true, value: undefined };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    };
   }
 }
 
-function findBoundary(buffer: Uint8Array, start: number): Uint8Array | null {
-  const char1 = buffer[start];
-  const char2 = buffer[start + 1];
-
-  // Don't bother checking if the first two characters are not new line
-  // characters.
-  if (
-    char1 == null
-    || char2 == null
-    || !NEWLINE_CHARS.has(char1)
-    || !NEWLINE_CHARS.has(char2)
-  ) {
-    return null;
-  }
+function concatBuffer(a: Uint8Array, b: Uint8Array): Uint8Array {
+  const c = new Uint8Array(a.length + b.length);
+  c.set(a, 0);
+  c.set(b, a.length);
+  return c;
+}
 
-  for (const s of MESSAGE_BOUNDARIES) {
-    const seq = peekSequence(start, buffer, s);
-    if (seq != null) {
-      return seq;
+/** Finds the first (CR,LF,CR,LF) or (CR,CR) or (LF,LF) */
+function findBoundary(
+  buf: Uint8Array,
+): { index: number; length: number } | null {
+  const len = buf.length;
+  for (let i = 0; i < len; i++) {
+    if (
+      i <= len - 4
+      && buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13
+      && buf[i + 3] === 10
+    ) {
+      return { index: i, length: 4 };
+    }
+    if (i <= len - 2 && buf[i] === 13 && buf[i + 1] === 13) {
+      return { index: i, length: 2 };
+    }
+    if (i <= len - 2 && buf[i] === 10 && buf[i + 1] === 10) {
+      return { index: i, length: 2 };
     }
   }
-
   return null;
 }
 
-function peekSequence(
-  position: number,
-  buffer: Uint8Array,
-  sequence: Uint8Array,
-): Uint8Array | null {
-  if (sequence.length > buffer.length - position) {
-    return null;
-  }
-
-  for (let i = 0; i < sequence.length; i++) {
-    if (buffer[position + i] !== sequence[i]) {
-      return null;
+function* chunks(
+  remainder: Uint8Array,
+): Generator<{ chunk: Uint8Array; remainder: Uint8Array }> {
+  while (true) {
+    const match = findBoundary(remainder);
+    if (!match) {
+      yield { chunk: new Uint8Array(), remainder };
+      return;
     }
+    const chunk = remainder.slice(0, match.index);
+    remainder = remainder.slice(match.index + match.length);
+    yield { chunk, remainder };
   }
-
-  return sequence;
 }
 
-function parseEvent<Event extends ServerEvent<unknown>>(
+function parseChunk<T extends ServerEvent<unknown>>(
   chunk: Uint8Array,
-  decoder: (rawEvent: ServerEvent<string>) => Event,
+  parse: (x: ServerEvent<string>) => IteratorResult<T, undefined>,
 ) {
-  if (!chunk.length) {
-    return null;
-  }
-
-  const td = new TextDecoder();
-  const raw = td.decode(chunk);
-  const lines = raw.split(/\r?\n|\r/g);
-  let publish = false;
-  const rawEvent: ServerEvent<string> = {};
-
+  const text = new TextDecoder().decode(chunk);
+  const lines = text.split(/\r\n|\r|\n/);
+  const dataLines: string[] = [];
+  const ret: ServerEvent<string> = {};
+  let ignore = true;
   for (const line of lines) {
-    if (!line) {
-      continue;
-    }
-
-    const delim = line.indexOf(":");
-    // Lines starting with a colon are ignored.
-    if (delim === 0) {
-      continue;
-    }
-
-    const field = delim > 0 ? line.substring(0, delim) : "";
-    let value = delim > 0 ? line.substring(delim + 1) : "";
-    if (value.charAt(0) === " ") {
-      value = value.substring(1);
+    if (!line || line.startsWith(":")) continue;
+    ignore = false;
+    const i = line.indexOf(":");
+    const field = line.slice(0, i);
+    const value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+    if (field === "data") dataLines.push(value);
+    else if (field === "event") ret.event = value;
+    else if (field === "id") ret.id = value;
+    else if (field === "retry") {
+      const n = Number(value);
+      if (!isNaN(n)) ret.retry = n;
     }
-
-    switch (field) {
-      case "event": {
-        publish = true;
-        rawEvent.event = value;
-        break;
-      }
-      case "data": {
-        publish = true;
-        rawEvent.data ??= "";
-        rawEvent.data += value + "\n";
-        break;
-      }
-      case "id": {
-        publish = true;
-        rawEvent.id = value;
-        break;
-      }
-      case "retry": {
-        const r = parseInt(value, 10);
-        if (!Number.isNaN(r)) {
-          publish = true;
-          rawEvent.retry = r;
-        }
-        break;
-      }
-    }
-  }
-
-  if (!publish) {
-    return null;
-  }
-
-  if (rawEvent.data != null) {
-    rawEvent.data = rawEvent.data.slice(0, -1);
   }
-
-  return decoder(rawEvent);
-}
-
-export function discardSentinel(
-  stream: ReadableStream<Uint8Array>,
-  sentinel: string,
-): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    async start(controller) {
-      let buffer = new Uint8Array([]);
-      let position = 0;
-      let done = false;
-      let discard = false;
-      const rdr = stream.getReader();
-      try {
-        while (!done) {
-          const result = await rdr.read();
-          const value = result.value;
-          done = done || result.done;
-          // We keep consuming from the source to its completion so it can
-          // flush all its contents and release resources.
-          if (discard) {
-            continue;
-          }
-          if (typeof value === "undefined") {
-            continue;
-          }
-
-          const newBuffer = new Uint8Array(buffer.length + value.length);
-          newBuffer.set(buffer);
-          newBuffer.set(value, buffer.length);
-          buffer = newBuffer;
-
-          for (let i = position; i < buffer.length; i++) {
-            const boundary = findBoundary(buffer, i);
-            if (boundary == null) {
-              continue;
-            }
-
-            const start = position;
-            const chunk = buffer.slice(start, i);
-            position = i + boundary.length;
-            const event = parseEvent(chunk, id);
-            if (event?.data === sentinel) {
-              controller.enqueue(buffer.slice(0, start));
-              discard = true;
-            } else {
-              controller.enqueue(buffer.slice(0, position));
-              buffer = buffer.slice(position);
-              position = 0;
-            }
-          }
-        }
-      } catch (e) {
-        controller.error(e);
-      } finally {
-        // If the source stream terminates, flush its contents and terminate.
-        // If the sentinel event was found, flush everything up to its start.
-        controller.close();
-        rdr.releaseLock();
-      }
-    },
-  });
-}
-
-function id<T>(v: T): T {
-  return v;
+  if (ignore) return;
+  if (dataLines.length) ret.data = dataLines.join("\n");
+  return parse(ret);
 }

package/packages/orq-rc/src/lib/matchers.ts

@@ -5,7 +5,6 @@
 import { APIError } from "../models/errors/apierror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { ERR, OK, Result } from "../types/fp.js";
-import { discardSentinel } from "./event-streams.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
 
@@ -238,9 +237,7 @@ export function match<T, E>(
         raw = body;
         break;
       case "sse":
-        raw = response.body && matcher.sseSentinel
-          ? discardSentinel(response.body, matcher.sseSentinel)
-          : response.body;
+        raw = response.body;
         break;
       case "nil":
         body = await response.text();

package/packages/orq-rc/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "3.10.0-rc.0",
+    currentVersion: "3.10.0-rc.2",
   },
 });
 

package/packages/orq-rc/src/mcp-server/server.ts

@@ -119,7 +119,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Orq",
-    version: "3.10.0-rc.0",
+    version: "3.10.0-rc.2",
   });
 
   const client = new OrqCore({

package/packages/orq-rc/src/models/operations/createcontact.ts

@@ -182,7 +182,7 @@ export const CreateContactResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2025-07-04T12:58:16.632Z",
+    "2025-07-08T10:06:05.308Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -223,7 +223,7 @@ export const CreateContactResponseBody$outboundSchema: z.ZodType<
   tags: z.array(z.string()).optional(),
   metadata: z.record(z.any()).optional(),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2025-07-04T12:58:16.632Z"))
+  updated: z.date().default(() => new Date("2025-07-08T10:06:05.308Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/createdataset.ts

@@ -211,7 +211,7 @@ export const CreateDatasetResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2025-07-04T12:58:16.632Z",
+    "2025-07-08T10:06:05.308Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -251,7 +251,7 @@ export const CreateDatasetResponseBody$outboundSchema: z.ZodType<
   updatedById: z.string().optional(),
   metadata: z.lazy(() => CreateDatasetMetadata$outboundSchema),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2025-07-04T12:58:16.632Z"))
+  updated: z.date().default(() => new Date("2025-07-08T10:06:05.308Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/createdatasetitem.ts

@@ -5111,7 +5111,7 @@ export const CreateDatasetItemResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2025-07-04T12:58:16.632Z",
+    "2025-07-08T10:06:05.308Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -5175,7 +5175,7 @@ export const CreateDatasetItemResponseBody$outboundSchema: z.ZodType<
   createdById: z.string().optional(),
   updatedById: z.string().optional(),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2025-07-04T12:58:16.632Z"))
+  updated: z.date().default(() => new Date("2025-07-08T10:06:05.308Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/createdatasource.ts

@@ -751,7 +751,7 @@ export const CreateDatasourceResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("01JZAR8H5A0HGMG4C7K1Z58QEC"),
+  _id: z.string().default("01JZMR03EGA03VCJ8PX3ZNZVQJ"),
   display_name: z.string(),
   description: z.string().optional(),
   status: CreateDatasourceStatus$inboundSchema,
@@ -795,7 +795,7 @@ export const CreateDatasourceResponseBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateDatasourceResponseBody
 > = z.object({
-  id: z.string().default("01JZAR8H5A0HGMG4C7K1Z58QEC"),
+  id: z.string().default("01JZMR03EGA03VCJ8PX3ZNZVQJ"),
   displayName: z.string(),
   description: z.string().optional(),
   status: CreateDatasourceStatus$outboundSchema,

package/packages/orq-rc/src/models/operations/createeval.ts

@@ -2399,8 +2399,8 @@ export const ResponseBodyPython$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrail_config: z.union([
     z.lazy(() =>
       CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema
@@ -2442,8 +2442,8 @@ export const ResponseBodyPython$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrailConfig: z.union([
     z.lazy(() =>
       CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$outboundSchema
@@ -2856,8 +2856,8 @@ export const ResponseBodyHTTP$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrail_config: z.union([
     z.lazy(() =>
       CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema
@@ -2905,8 +2905,8 @@ export const ResponseBodyHTTP$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrailConfig: z.union([
     z.lazy(() =>
       CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$outboundSchema
@@ -3283,8 +3283,8 @@ export const ResponseBodyJSON$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrail_config: z.union([
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponse200Number$inboundSchema),
     z.lazy(() =>
@@ -3324,8 +3324,8 @@ export const ResponseBodyJSON$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrailConfig: z.union([
     z.lazy(() =>
       CreateEvalGuardrailConfigEvalsResponse200Number$outboundSchema
@@ -3680,8 +3680,8 @@ export const ResponseBodyLLM$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrail_config: z.union([
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponseNumber$inboundSchema),
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema),
@@ -3721,8 +3721,8 @@ export const ResponseBodyLLM$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   description: z.string(),
-  created: z.string().default("2025-07-04T12:58:18.731Z"),
-  updated: z.string().default("2025-07-04T12:58:18.731Z"),
+  created: z.string().default("2025-07-08T10:06:07.416Z"),
+  updated: z.string().default("2025-07-08T10:06:07.416Z"),
   guardrailConfig: z.union([
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponseNumber$outboundSchema),
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponseBoolean$outboundSchema),

package/packages/orq-rc/src/models/operations/fileget.ts

@@ -146,7 +146,7 @@ export const FileGetResponseBody$inboundSchema: z.ZodType<
   file_name: z.string(),
   workspace_id: z.string(),
   created: z.string().datetime({ offset: true }).default(
-    "2025-07-04T12:58:19.613Z",
+    "2025-07-08T10:06:08.258Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -180,7 +180,7 @@ export const FileGetResponseBody$outboundSchema: z.ZodType<
   bytes: z.number(),
   fileName: z.string(),
   workspaceId: z.string(),
-  created: z.date().default(() => new Date("2025-07-04T12:58:19.613Z"))
+  created: z.date().default(() => new Date("2025-07-08T10:06:08.258Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/filelist.ts

@@ -196,7 +196,7 @@ export const FileListData$inboundSchema: z.ZodType<
   file_name: z.string(),
   workspace_id: z.string(),
   created: z.string().datetime({ offset: true }).default(
-    "2025-07-04T12:58:19.613Z",
+    "2025-07-08T10:06:08.258Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -230,7 +230,7 @@ export const FileListData$outboundSchema: z.ZodType<
   bytes: z.number(),
   fileName: z.string(),
   workspaceId: z.string(),
-  created: z.date().default(() => new Date("2025-07-04T12:58:19.613Z"))
+  created: z.date().default(() => new Date("2025-07-08T10:06:08.258Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/fileupload.ts

@@ -250,7 +250,7 @@ export const FileUploadResponseBody$inboundSchema: z.ZodType<
   file_name: z.string(),
   workspace_id: z.string(),
   created: z.string().datetime({ offset: true }).default(
-    "2025-07-04T12:58:19.613Z",
+    "2025-07-08T10:06:08.258Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -284,7 +284,7 @@ export const FileUploadResponseBody$outboundSchema: z.ZodType<
   bytes: z.number(),
   fileName: z.string(),
   workspaceId: z.string(),
-  created: z.date().default(() => new Date("2025-07-04T12:58:19.613Z"))
+  created: z.date().default(() => new Date("2025-07-08T10:06:08.258Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {