@s2-dev/streamstore 0.15.1 → 0.15.3

package/src/lib/config.ts

@@ -58,8 +58,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.15.1",
-  genVersion: "2.624.0",
+  sdkVersion: "0.15.3",
+  genVersion: "2.651.2",
   userAgent:
-    "speakeasy-sdk/typescript 0.15.1 2.624.0 1.0.0 @s2-dev/streamstore",
+    "speakeasy-sdk/typescript 0.15.3 2.651.2 1.0.0 @s2-dev/streamstore",
 } as const;

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/files.ts

@@ -38,3 +38,45 @@ export async function readableStreamToArrayBuffer(
 
   return concatenatedChunks.buffer as ArrayBuffer;
 }
+
+/**
+ * Determines the MIME content type based on a file's extension.
+ * Returns null if the extension is not recognized.
+ */
+export function getContentTypeFromFileName(fileName: string): string | null {
+  if (!fileName) return null;
+
+  const ext = fileName.toLowerCase().split(".").pop();
+  if (!ext) return null;
+
+  const mimeTypes: Record<string, string> = {
+    json: "application/json",
+    xml: "application/xml",
+    html: "text/html",
+    htm: "text/html",
+    txt: "text/plain",
+    csv: "text/csv",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    js: "application/javascript",
+    css: "text/css",
+    zip: "application/zip",
+    tar: "application/x-tar",
+    gz: "application/gzip",
+    mp4: "video/mp4",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+  };
+
+  return mimeTypes[ext] || null;
+}

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/lib/security.ts

@@ -7,8 +7,8 @@ import { env } from "./env.js";
 
 type OAuth2PasswordFlow = {
   username: string;
-  password?: string | undefined;
-  clientID: string;
+  password: string;
+  clientID?: string | undefined;
   clientSecret?: string | undefined;
   tokenURL: string;
 };

package/src/mcp-server/cli/start/command.ts

@@ -37,18 +37,13 @@ export const startCommand = buildCommand({
           return z.string().parse(value);
         },
       },
-      ...(mcpScopes.length
-        ? {
-          scope: {
-            kind: "enum",
-            brief:
-              "Mount tools/resources that match given scope (repeatable flag)",
-            values: mcpScopes,
-            variadic: true,
-            optional: true,
-          },
-        }
-        : {}),
+      scope: {
+        kind: "enum",
+        brief: "Mount tools/resources that match given scope (repeatable flag)",
+        values: mcpScopes,
+        variadic: true,
+        optional: true,
+      },
       "access-token": {
         kind: "parsed",
         brief: "Sets the accessToken auth field for the API",

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

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

package/src/mcp-server/server.ts

@@ -45,7 +45,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "S2",
-    version: "0.15.1",
+    version: "0.15.3",
   });
 
   const client = new S2Core({

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

@@ -12,7 +12,7 @@ const args = {
 
 export const tool$basinsGetBasinConfig: ToolDefinition<typeof args> = {
   name: "basins-get-basin-config",
-  description: `Get basin config.`,
+  description: `Get basin configuration.`,
   scopes: ["read", "read", "read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -12,7 +12,7 @@ const args = {
 
 export const tool$metricsAccountMetrics: ToolDefinition<typeof args> = {
   name: "metrics-account-metrics",
-  description: `Get account level metrics.`,
+  description: `Account-level metrics.`,
   scopes: ["read", "read", "read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -12,7 +12,7 @@ const args = {
 
 export const tool$metricsBasinMetrics: ToolDefinition<typeof args> = {
   name: "metrics-basin-metrics",
-  description: `Get metrics for a basin.`,
+  description: `Basin-level metrics.`,
   scopes: ["read", "read", "read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -12,7 +12,7 @@ const args = {
 
 export const tool$metricsStreamMetrics: ToolDefinition<typeof args> = {
   name: "metrics-stream-metrics",
-  description: `Get metrics for a stream.`,
+  description: `Stream-level metrics.`,
   scopes: ["read", "read", "read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -12,9 +12,7 @@ const args = {
 
 export const tool$recordsAppend: ToolDefinition<typeof args> = {
   name: "records-append",
-  description: `Append records.
-
-Append a batch of records to a stream.`,
+  description: `Append records.`,
   scopes: ["write", "write", "write"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -12,9 +12,7 @@ const args = {
 
 export const tool$recordsCheckTail: ToolDefinition<typeof args> = {
   name: "records-check-tail",
-  description: `Check the tail.
-
-Check the tail of a stream.`,
+  description: `Check the tail.`,
   scopes: ["read", "read", "read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -12,9 +12,7 @@ const args = {
 
 export const tool$recordsRead: ToolDefinition<typeof args> = {
   name: "records-read",
-  description: `Retrieve records.
-
-Retrieve a batch of records, or set \`Accept: text/event-stream\` to stream using server-sent events.`,
+  description: `Read records.`,
   scopes: ["read", "read", "read"],
   args,
   tool: async (client, args, ctx) => {

package/src/models/components/accesstokeninfo.ts

@@ -19,8 +19,7 @@ export type AccessTokenInfo = {
    * Namespace streams based on the configured stream-level scope, which must be a prefix.
    *
    * @remarks
-   * Stream name arguments will be automatically prefixed, and the prefix will be stripped
-   * when listing streams.
+   * Stream name arguments will be automatically prefixed, and the prefix will be stripped when listing streams.
    */
   autoPrefixStreams?: boolean | undefined;
   /**

package/src/models/components/accountmetricset.ts

@@ -6,8 +6,8 @@ import * as z from "zod";
 import { ClosedEnum } from "../../types/enums.js";
 
 export const AccountMetricSet = {
-  ActiveBasins: "active_basins",
-  AccountOps: "account_ops",
+  ActiveBasins: "active-basins",
+  AccountOps: "account-ops",
 } as const;
 export type AccountMetricSet = ClosedEnum<typeof AccountMetricSet>;
 

package/src/models/components/accumulation.ts

@@ -31,12 +31,8 @@ export type Accumulation = {
    * Timeseries values.
    *
    * @remarks
-   *
-   * Each element is a tuple containing the seconds since Unix epoch, followed by the data
-   * point.
-   *
-   * The data point represented the accumulated value for a bucket of time, starting
-   * at the provided epoch, lasting for the duration of the `bucket_length` parameter above.
+   * Each element is a tuple of a timestamp in Unix epoch seconds and a data point.
+   * The data point represents the accumulated value for a bucket of time starting at the provided timestamp, lasting for the duration of the `bucket_length` parameter.
    */
   values: Array<Array<number | number>>;
 };

package/src/models/components/appendack.ts

@@ -14,7 +14,7 @@ import {
 } from "./streamposition.js";
 
 /**
- * Success response message to an Append request.
+ * Success response to an `append` request.
  */
 export type AppendAck = {
   /**

package/src/models/components/appendinput.ts

@@ -15,19 +15,19 @@ import {
 } from "./appendrecord.js";
 
 /**
- * Payload of an Append request message.
+ * Payload of an `append` request.
  */
 export type AppendInput = {
   /**
-   * Enforce a fencing token which must have been previously set by a `fence` command record.
+   * Enforce a fencing token, which starts out as an empty string that can be overridden by a `fence` command record.
    */
   fencingToken?: string | null | undefined;
   matchSeqNum?: number | null | undefined;
   /**
-   * Batch of records to append atomically, which must contain at least one record, and no more
+   * Batch of records to append atomically, which must contain at least one record, and no more than 1000.
    *
    * @remarks
-   * than 1000. The total size of a batch of records may not exceed 1MiB of metered bytes.
+   * The total size of a batch of records may not exceed 1 MiB of metered bytes.
    */
   records: Array<AppendRecord>;
 };