@orq-ai/node 3.9.3 → 3.9.5

package/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/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/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "3.9.3",
+    currentVersion: "3.9.5",
   },
 });
 

package/src/mcp-server/server.ts

@@ -81,7 +81,7 @@ import { tool$filesCreate } from "./tools/filesCreate.js";
 import { tool$filesDelete } from "./tools/filesDelete.js";
 import { tool$filesGet } from "./tools/filesGet.js";
 import { tool$filesList } from "./tools/filesList.js";
-import { tool$knowledgeBasesChunkText } from "./tools/knowledgeBasesChunkText.js";
+import { tool$knowledgeCreate } from "./tools/knowledgeCreate.js";
 import { tool$knowledgeCreateChunks } from "./tools/knowledgeCreateChunks.js";
 import { tool$knowledgeCreateDatasource } from "./tools/knowledgeCreateDatasource.js";
 import { tool$knowledgeDelete } from "./tools/knowledgeDelete.js";
@@ -119,7 +119,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Orq",
-    version: "3.9.3",
+    version: "3.9.5",
   });
 
   const client = new OrqCore({
@@ -186,6 +186,7 @@ export function createMCPServer(deps: {
   tool(tool$datasetsDeleteDatapoint);
   tool(tool$datasetsClear);
   tool(tool$knowledgeList);
+  tool(tool$knowledgeCreate);
   tool(tool$knowledgeRetrieve);
   tool(tool$knowledgeUpdate);
   tool(tool$knowledgeDelete);
@@ -200,7 +201,6 @@ export function createMCPServer(deps: {
   tool(tool$knowledgeUpdateChunk);
   tool(tool$knowledgeDeleteChunk);
   tool(tool$knowledgeRetrieveChunk);
-  tool(tool$knowledgeBasesChunkText);
   tool(tool$evalsAll);
   tool(tool$evalsCreate);
   tool(tool$evalsUpdate);

package/src/mcp-server/tools/knowledgeCreate.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { knowledgeCreate } from "../../funcs/knowledgeCreate.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.CreateKnowledgeRequestBody$inboundSchema,
+};
+
+export const tool$knowledgeCreate: ToolDefinition<typeof args> = {
+  name: "knowledge-create",
+  description: `Create a knowledge`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await knowledgeCreate(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/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-03T19:32:36.817Z",
+    "2025-07-09T18:59:26.904Z",
   ).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-03T19:32:36.817Z"))
+  updated: z.date().default(() => new Date("2025-07-09T18:59:26.904Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/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-03T19:32:36.817Z",
+    "2025-07-09T18:59:26.904Z",
   ).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-03T19:32:36.817Z"))
+  updated: z.date().default(() => new Date("2025-07-09T18:59:26.904Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/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-03T19:32:36.817Z",
+    "2025-07-09T18:59:26.904Z",
   ).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-03T19:32:36.817Z"))
+  updated: z.date().default(() => new Date("2025-07-09T18:59:26.904Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/createdatasource.ts

@@ -751,7 +751,7 @@ export const CreateDatasourceResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("01JZ8WDVTT3G9XM8PHB91TZPBC"),
+  _id: z.string().default("01JZR8XF2W2CY6V5YRYHDWWMEG"),
   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("01JZ8WDVTT3G9XM8PHB91TZPBC"),
+  id: z.string().default("01JZR8XF2W2CY6V5YRYHDWWMEG"),
   displayName: z.string(),
   description: z.string().optional(),
   status: CreateDatasourceStatus$outboundSchema,

package/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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   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-03T19:32:39.016Z"),
-  updated: z.string().default("2025-07-03T19:32:39.016Z"),
+  created: z.string().default("2025-07-09T18:59:29.212Z"),
+  updated: z.string().default("2025-07-09T18:59:29.212Z"),
   guardrailConfig: z.union([
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponseNumber$outboundSchema),
     z.lazy(() => CreateEvalGuardrailConfigEvalsResponseBoolean$outboundSchema),