@s2-dev/streamstore 0.11.1 → 0.12.0

package/src/funcs/streamsListStreams.ts

@@ -152,7 +152,7 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: ["400", "403", "404", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -181,7 +181,7 @@ async function $do(
     M.json(200, operations.ListStreamsResponse$inboundSchema, {
       key: "Result",
     }),
-    M.jsonErr([400, 401], errors.ErrorResponse$inboundSchema),
+    M.jsonErr([400, 403, 404], errors.ErrorResponse$inboundSchema),
     M.jsonErr(499, errors.RetryableError$inboundSchema),
     M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),

package/src/funcs/streamsReconfigureStream.ts

@@ -143,7 +143,18 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: [
+      "400",
+      "403",
+      "404",
+      "409",
+      "499",
+      "4XX",
+      "500",
+      "503",
+      "504",
+      "5XX",
+    ],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -170,7 +181,7 @@ async function $do(
     | ConnectionError
   >(
     M.json(200, components.StreamConfig$inboundSchema),
-    M.jsonErr([400, 401], errors.ErrorResponse$inboundSchema),
+    M.jsonErr([400, 403, 404, 409], errors.ErrorResponse$inboundSchema),
     M.jsonErr(499, errors.RetryableError$inboundSchema),
     M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),

package/src/lib/config.ts

@@ -54,8 +54,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.11.1",
-  genVersion: "2.593.4",
+  sdkVersion: "0.12.0",
+  genVersion: "2.604.2",
   userAgent:
-    "speakeasy-sdk/typescript 0.11.1 2.593.4 1.0.0 @s2-dev/streamstore",
+    "speakeasy-sdk/typescript 0.12.0 2.604.2 1.0.0 @s2-dev/streamstore",
 } as const;

package/src/lib/event-streams.ts

@@ -0,0 +1,264 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type ServerEvent<T> = {
+  data?: T | undefined;
+  event?: string | undefined;
+  retry?: number | undefined;
+  id?: string | 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;
+          }
+        }
+
+        if (position > 0) {
+          buffer = buffer.slice(position);
+          position = 0;
+        }
+      }
+
+      if (buffer.length > 0) {
+        const event = parseEvent(buffer, this.decoder);
+        if (event != null) {
+          yield event;
+        }
+      }
+    } catch (e: unknown) {
+      if (e instanceof Error && e.name === "AbortError") {
+        return;
+      }
+
+      throw e;
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+
+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;
+  }
+
+  for (const s of MESSAGE_BOUNDARIES) {
+    const seq = peekSequence(start, buffer, s);
+    if (seq != null) {
+      return seq;
+    }
+  }
+
+  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;
+    }
+  }
+
+  return sequence;
+}
+
+function parseEvent<Event extends ServerEvent<unknown>>(
+  chunk: Uint8Array,
+  decoder: (rawEvent: ServerEvent<string>) => Event,
+) {
+  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> = {};
+
+  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);
+    }
+
+    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;
+}

package/src/lib/matchers.ts

@@ -5,6 +5,7 @@
 import { APIError } from "../models/errors/apierror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import { 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";
 import { safeParse } from "./schemas.js";
@@ -234,7 +235,9 @@ export function match<T, E>(
         raw = await response.text();
         break;
       case "sse":
-        raw = response.body;
+        raw = response.body && matcher.sseSentinel
+          ? discardSentinel(response.body, matcher.sseSentinel)
+          : response.body;
         break;
       case "nil":
         raw = await discardResponseBody(response);

package/src/lib/sdks.ts

@@ -47,12 +47,14 @@ export type RequestOptions = {
    */
   serverURL?: string | URL;
   /**
+   * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
+   *
    * Sets various request options on the `fetch` call made by an SDK method.
    *
    * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
    */
   fetchOptions?: Omit<RequestInit, "method" | "body">;
-};
+} & Omit<RequestInit, "method" | "body">;
 
 type RequestConfig = {
   method: string;
@@ -172,7 +174,9 @@ export class ClientSDK {
     cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
     headers.set("cookie", cookie);
 
-    const userHeaders = new Headers(options?.fetchOptions?.headers);
+    const userHeaders = new Headers(
+      options?.headers ?? options?.fetchOptions?.headers,
+    );
     for (const [k, v] of userHeaders) {
       headers.set(k, v);
     }
@@ -183,20 +187,16 @@ export class ClientSDK {
       headers.set(conf.uaHeader ?? "user-agent", SDK_METADATA.userAgent);
     }
 
-    let fetchOptions = options?.fetchOptions;
+    const fetchOptions: Omit<RequestInit, "method" | "body"> = {
+      ...options?.fetchOptions,
+      ...options,
+    };
     if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
       const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      if (!fetchOptions) {
-        fetchOptions = { signal: timeoutSignal };
-      } else {
-        fetchOptions.signal = timeoutSignal;
-      }
+      fetchOptions.signal = timeoutSignal;
     }
 
     if (conf.body instanceof ReadableStream) {
-      if (!fetchOptions) {
-        fetchOptions = {};
-      }
       Object.assign(fetchOptions, { duplex: "half" });
     }
 

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

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

package/src/mcp-server/server.ts

@@ -16,12 +16,17 @@ import { createRegisterTool } from "./tools.js";
 import { tool$accessTokensIssueAccessToken } from "./tools/accessTokensIssueAccessToken.js";
 import { tool$accessTokensListAccessTokens } from "./tools/accessTokensListAccessTokens.js";
 import { tool$accessTokensRevokeAccessToken } from "./tools/accessTokensRevokeAccessToken.js";
+import { tool$basinsCreateBasin } from "./tools/basinsCreateBasin.js";
 import { tool$basinsCreateOrReconfigureBasin } from "./tools/basinsCreateOrReconfigureBasin.js";
 import { tool$basinsDeleteBasin } from "./tools/basinsDeleteBasin.js";
 import { tool$basinsGetBasinConfig } from "./tools/basinsGetBasinConfig.js";
 import { tool$basinsListBasins } from "./tools/basinsListBasins.js";
 import { tool$basinsReconfigureBasin } from "./tools/basinsReconfigureBasin.js";
+import { tool$recordsAppend } from "./tools/recordsAppend.js";
+import { tool$recordsCheckTail } from "./tools/recordsCheckTail.js";
+import { tool$recordsRead } from "./tools/recordsRead.js";
 import { tool$streamsCreateOrReconfigureStream } from "./tools/streamsCreateOrReconfigureStream.js";
+import { tool$streamsCreateStream } from "./tools/streamsCreateStream.js";
 import { tool$streamsDeleteStream } from "./tools/streamsDeleteStream.js";
 import { tool$streamsGetStreamConfig } from "./tools/streamsGetStreamConfig.js";
 import { tool$streamsListStreams } from "./tools/streamsListStreams.js";
@@ -37,7 +42,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "S2",
-    version: "0.11.1",
+    version: "0.12.0",
   });
 
   const client = new S2Core({
@@ -71,15 +76,20 @@ export function createMCPServer(deps: {
   tool(tool$accessTokensIssueAccessToken);
   tool(tool$accessTokensRevokeAccessToken);
   tool(tool$basinsListBasins);
+  tool(tool$basinsCreateBasin);
   tool(tool$basinsGetBasinConfig);
   tool(tool$basinsCreateOrReconfigureBasin);
   tool(tool$basinsDeleteBasin);
   tool(tool$basinsReconfigureBasin);
   tool(tool$streamsListStreams);
+  tool(tool$streamsCreateStream);
   tool(tool$streamsGetStreamConfig);
   tool(tool$streamsCreateOrReconfigureStream);
   tool(tool$streamsDeleteStream);
   tool(tool$streamsReconfigureStream);
+  tool(tool$recordsRead);
+  tool(tool$recordsAppend);
+  tool(tool$recordsCheckTail);
 
   return server;
 }

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

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { basinsCreateBasin } from "../../funcs/basinsCreateBasin.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.CreateBasinRequest$inboundSchema,
+};
+
+export const tool$basinsCreateBasin: ToolDefinition<typeof args> = {
+  name: "basins-create-basin",
+  description: `Create a basin.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await basinsCreateBasin(
+      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/mcp-server/tools/recordsAppend.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { recordsAppend } from "../../funcs/recordsAppend.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.AppendRequest$inboundSchema,
+};
+
+export const tool$recordsAppend: ToolDefinition<typeof args> = {
+  name: "records-append",
+  description: `Append records.
+
+Append a batch of records to a stream.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await recordsAppend(
+      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/mcp-server/tools/recordsCheckTail.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { recordsCheckTail } from "../../funcs/recordsCheckTail.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.CheckTailRequest$inboundSchema,
+};
+
+export const tool$recordsCheckTail: ToolDefinition<typeof args> = {
+  name: "records-check-tail",
+  description: `Check the tail.
+
+Check the tail of a stream.`,
+  scopes: ["read"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await recordsCheckTail(
+      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/mcp-server/tools/recordsRead.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { recordsRead } from "../../funcs/recordsRead.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ReadRequest$inboundSchema,
+};
+
+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.`,
+  scopes: ["read"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await recordsRead(
+      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/mcp-server/tools/streamsCreateStream.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { streamsCreateStream } from "../../funcs/streamsCreateStream.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.CreateStreamRequest$inboundSchema,
+};
+
+export const tool$streamsCreateStream: ToolDefinition<typeof args> = {
+  name: "streams-create-stream",
+  description: `Create a stream.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await streamsCreateStream(
+      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/components/accesstokeninfo.ts

@@ -24,7 +24,7 @@ export type AccessTokenInfo = {
    */
   autoPrefixStreams?: boolean | undefined;
   /**
-   * Expiration time in seconds since Unix epoch.
+   * Expiration time in ISO 8601 format.
    *
    * @remarks
    * If not set, the expiration will be set to that of the requestor's token.
@@ -34,7 +34,7 @@ export type AccessTokenInfo = {
    * Access token ID.
    *
    * @remarks
-   * It must be unique to the account and between 1 and 50 characters.
+   * It must be unique to the account and between 1 and 96 characters.
    */
   id: string;
   scope: AccessTokenScope;