@s2-dev/streamstore 0.11.2 → 0.12.0

package/src/funcs/streamsCreateStream.ts

@@ -0,0 +1,185 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { S2Core } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
+import { APIError } from "../models/errors/apierror.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { CreateStreamServerList } from "../models/operations/createstream.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Create a stream.
+ */
+export function streamsCreateStream(
+  client: S2Core,
+  request: components.CreateStreamRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    components.StreamInfo,
+    | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
+    | APIError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: S2Core,
+  request: components.CreateStreamRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      components.StreamInfo,
+      | errors.ErrorResponse
+      | errors.RetryableError
+      | errors.RetryableError
+      | APIError
+      | SDKValidationError
+      | UnexpectedClientError
+      | InvalidRequestError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | ConnectionError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => components.CreateStreamRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const baseURL = options?.serverURL
+    || pathToFunc(CreateStreamServerList[0], { charEncoding: "percent" })({
+      basin: "",
+    });
+
+  const path = pathToFunc("/streams")();
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.accessToken);
+  const securityInput = secConfig == null ? {} : { accessToken: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    baseURL: baseURL ?? "",
+    operationID: "create_stream",
+    oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.accessToken,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: baseURL,
+    path: path,
+    headers: headers,
+    body: body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "403",
+      "404",
+      "409",
+      "499",
+      "4XX",
+      "500",
+      "503",
+      "504",
+      "5XX",
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    components.StreamInfo,
+    | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
+    | APIError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >(
+    M.json(201, components.StreamInfo$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"),
+    M.fail("5XX"),
+  )(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/streamsDeleteStream.ts

@@ -37,6 +37,7 @@ export function streamsDeleteStream(
   Result<
     void,
     | errors.ErrorResponse
+    | errors.NotFoundError
     | errors.RetryableError
     | errors.RetryableError
     | APIError
@@ -64,6 +65,7 @@ async function $do(
     Result<
       void,
       | errors.ErrorResponse
+      | errors.NotFoundError
       | errors.RetryableError
       | errors.RetryableError
       | APIError
@@ -140,7 +142,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,
   });
@@ -156,6 +158,7 @@ async function $do(
   const [result] = await M.match<
     void,
     | errors.ErrorResponse
+    | errors.NotFoundError
     | errors.RetryableError
     | errors.RetryableError
     | APIError
@@ -167,7 +170,8 @@ async function $do(
     | ConnectionError
   >(
     M.nil(202, z.void()),
-    M.jsonErr([400, 401], errors.ErrorResponse$inboundSchema),
+    M.jsonErr([400, 403], errors.ErrorResponse$inboundSchema),
+    M.jsonErr(404, errors.NotFoundError$inboundSchema),
     M.jsonErr(499, errors.RetryableError$inboundSchema),
     M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),

package/src/funcs/streamsGetStreamConfig.ts

@@ -140,7 +140,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,
   });
@@ -167,7 +178,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/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.2",
-  genVersion: "2.597.9",
+  sdkVersion: "0.12.0",
+  genVersion: "2.604.2",
   userAgent:
-    "speakeasy-sdk/typescript 0.11.2 2.597.9 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/mcp-server/mcp-server.ts

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

package/src/mcp-server/server.ts

@@ -16,13 +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";
@@ -38,7 +42,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "S2",
-    version: "0.11.2",
+    version: "0.12.0",
   });
 
   const client = new S2Core({
@@ -72,15 +76,19 @@ 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);
+  },
+};