@s2-dev/streamstore 0.11.2 → 0.12.0

package/bin/mcp-server.js

@@ -34173,9 +34173,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.11.2",
-    genVersion: "2.597.9",
-    userAgent: "speakeasy-sdk/typescript 0.11.2 2.597.9 1.0.0 @s2-dev/streamstore"
+    sdkVersion: "0.12.0",
+    genVersion: "2.604.2",
+    userAgent: "speakeasy-sdk/typescript 0.12.0 2.604.2 1.0.0 @s2-dev/streamstore"
   };
 });
 
@@ -35178,6 +35178,208 @@ ${body}` : "";
   };
 });
 
+// src/lib/event-streams.ts
+function findBoundary(buffer, start) {
+  const char1 = buffer[start];
+  const char2 = buffer[start + 1];
+  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, buffer, sequence) {
+  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(chunk, decoder) {
+  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 = {};
+  for (const line of lines) {
+    if (!line) {
+      continue;
+    }
+    const delim = line.indexOf(":");
+    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 + `
+`;
+        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);
+}
+function discardSentinel(stream, sentinel) {
+  return new ReadableStream({
+    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;
+          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 {
+        controller.close();
+        rdr.releaseLock();
+      }
+    }
+  });
+}
+function id(v2) {
+  return v2;
+}
+var LF = 10, CR = 13, NEWLINE_CHARS, MESSAGE_BOUNDARIES, EventStream;
+var init_event_streams = __esm(() => {
+  NEWLINE_CHARS = new Set([LF, CR]);
+  MESSAGE_BOUNDARIES = [
+    new Uint8Array([CR, LF, CR, LF]),
+    new Uint8Array([CR, CR]),
+    new Uint8Array([LF, LF])
+  ];
+  EventStream = class EventStream {
+    stream;
+    decoder;
+    constructor(init) {
+      this.stream = init.stream;
+      this.decoder = init.decoder;
+    }
+    async* [Symbol.asyncIterator]() {
+      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) {
+        if (e instanceof Error && e.name === "AbortError") {
+          return;
+        }
+        throw e;
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  };
+});
+
 // src/models/errors/sdkvalidationerror.ts
 function formatZodError(err, level = 0) {
   let pre = "  ".repeat(level);
@@ -35273,6 +35475,9 @@ function jsonErr(codes, schema, options) {
 function json(codes, schema, options) {
   return { ...options, enc: "json", codes, schema };
 }
+function sse(codes, schema, options) {
+  return { ...options, enc: "sse", codes, schema };
+}
 function nil(codes, schema, options) {
   return { ...options, enc: "nil", codes, schema };
 }
@@ -35319,7 +35524,7 @@ function match(...matchers) {
         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);
@@ -35395,6 +35600,7 @@ async function discardResponseBody(res) {
 var DEFAULT_CONTENT_TYPES, headerValRE;
 var init_matchers = __esm(() => {
   init_apierror();
+  init_event_streams();
   init_http();
   init_schemas();
   DEFAULT_CONTENT_TYPES = {
@@ -35745,6 +35951,125 @@ var init_accesstokeninfo = __esm(() => {
   })(AccessTokenInfo$ ||= {});
 });
 
+// src/models/components/streamposition.ts
+var StreamPosition$inboundSchema, StreamPosition$outboundSchema, StreamPosition$;
+var init_streamposition = __esm(() => {
+  init_lib();
+  init_primitives();
+  StreamPosition$inboundSchema = objectType({
+    seq_num: numberType().int(),
+    timestamp: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      seq_num: "seqNum"
+    });
+  });
+  StreamPosition$outboundSchema = objectType({
+    seqNum: numberType().int(),
+    timestamp: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      seqNum: "seq_num"
+    });
+  });
+  ((StreamPosition$) => {
+    StreamPosition$.inboundSchema = StreamPosition$inboundSchema;
+    StreamPosition$.outboundSchema = StreamPosition$outboundSchema;
+  })(StreamPosition$ ||= {});
+});
+
+// src/models/components/appendack.ts
+var AppendAck$inboundSchema, AppendAck$outboundSchema, AppendAck$;
+var init_appendack = __esm(() => {
+  init_lib();
+  init_streamposition();
+  AppendAck$inboundSchema = objectType({
+    end: StreamPosition$inboundSchema,
+    start: StreamPosition$inboundSchema,
+    tail: StreamPosition$inboundSchema
+  });
+  AppendAck$outboundSchema = objectType({
+    end: StreamPosition$outboundSchema,
+    start: StreamPosition$outboundSchema,
+    tail: StreamPosition$outboundSchema
+  });
+  ((AppendAck$) => {
+    AppendAck$.inboundSchema = AppendAck$inboundSchema;
+    AppendAck$.outboundSchema = AppendAck$outboundSchema;
+  })(AppendAck$ ||= {});
+});
+
+// src/models/components/header.ts
+var Header$inboundSchema, Header$outboundSchema, Header$;
+var init_header = __esm(() => {
+  init_lib();
+  Header$inboundSchema = objectType({
+    name: stringType(),
+    value: stringType()
+  });
+  Header$outboundSchema = objectType({
+    name: stringType(),
+    value: stringType()
+  });
+  ((Header$) => {
+    Header$.inboundSchema = Header$inboundSchema;
+    Header$.outboundSchema = Header$outboundSchema;
+  })(Header$ ||= {});
+});
+
+// src/models/components/appendrecord.ts
+var AppendRecord$inboundSchema, AppendRecord$outboundSchema, AppendRecord$;
+var init_appendrecord = __esm(() => {
+  init_lib();
+  init_header();
+  AppendRecord$inboundSchema = objectType({
+    body: stringType().optional(),
+    headers: arrayType(Header$inboundSchema).optional(),
+    timestamp: nullableType(numberType().int()).optional()
+  });
+  AppendRecord$outboundSchema = objectType({
+    body: stringType().optional(),
+    headers: arrayType(Header$outboundSchema).optional(),
+    timestamp: nullableType(numberType().int()).optional()
+  });
+  ((AppendRecord$) => {
+    AppendRecord$.inboundSchema = AppendRecord$inboundSchema;
+    AppendRecord$.outboundSchema = AppendRecord$outboundSchema;
+  })(AppendRecord$ ||= {});
+});
+
+// src/models/components/appendinput.ts
+var AppendInput$inboundSchema, AppendInput$outboundSchema, AppendInput$;
+var init_appendinput = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_appendrecord();
+  AppendInput$inboundSchema = objectType({
+    fencing_token: nullableType(stringType()).optional(),
+    match_seq_num: nullableType(numberType().int()).optional(),
+    records: arrayType(AppendRecord$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      fencing_token: "fencingToken",
+      match_seq_num: "matchSeqNum"
+    });
+  });
+  AppendInput$outboundSchema = objectType({
+    fencingToken: nullableType(stringType()).optional(),
+    matchSeqNum: nullableType(numberType().int()).optional(),
+    records: arrayType(AppendRecord$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      fencingToken: "fencing_token",
+      matchSeqNum: "match_seq_num"
+    });
+  });
+  ((AppendInput$) => {
+    AppendInput$.inboundSchema = AppendInput$inboundSchema;
+    AppendInput$.outboundSchema = AppendInput$outboundSchema;
+  })(AppendInput$ ||= {});
+});
+
 // src/models/components/retentionpolicy.ts
 var One$inboundSchema, One$outboundSchema, One$, RetentionPolicy$inboundSchema, RetentionPolicy$outboundSchema, RetentionPolicy$;
 var init_retentionpolicy = __esm(() => {
@@ -35830,7 +36155,7 @@ var init_streamconfig = __esm(() => {
   StreamConfig$inboundSchema = objectType({
     retention_policy: nullableType(RetentionPolicy$inboundSchema).optional(),
     storage_class: nullableType(StorageClass$inboundSchema).optional(),
-    timestamping: TimestampingConfig$inboundSchema
+    timestamping: nullableType(TimestampingConfig$inboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       retention_policy: "retentionPolicy",
@@ -35840,7 +36165,7 @@ var init_streamconfig = __esm(() => {
   StreamConfig$outboundSchema = objectType({
     retentionPolicy: nullableType(RetentionPolicy$outboundSchema).optional(),
     storageClass: nullableType(StorageClass$outboundSchema).optional(),
-    timestamping: TimestampingConfig$outboundSchema
+    timestamping: nullableType(TimestampingConfig$outboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       retentionPolicy: "retention_policy",
@@ -35860,8 +36185,8 @@ var init_basinconfig = __esm(() => {
   init_primitives();
   init_streamconfig();
   BasinConfig$inboundSchema = objectType({
-    create_stream_on_append: nullableType(booleanType()).optional(),
-    create_stream_on_read: nullableType(booleanType()).optional(),
+    create_stream_on_append: booleanType().optional(),
+    create_stream_on_read: booleanType().optional(),
     default_stream_config: nullableType(StreamConfig$inboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
@@ -35871,8 +36196,8 @@ var init_basinconfig = __esm(() => {
     });
   });
   BasinConfig$outboundSchema = objectType({
-    createStreamOnAppend: nullableType(booleanType()).optional(),
-    createStreamOnRead: nullableType(booleanType()).optional(),
+    createStreamOnAppend: booleanType().optional(),
+    createStreamOnRead: booleanType().optional(),
     defaultStreamConfig: nullableType(StreamConfig$outboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
@@ -35971,7 +36296,7 @@ var init_streamreconfiguration = __esm(() => {
   StreamReconfiguration$inboundSchema = objectType({
     retention_policy: nullableType(RetentionPolicy$inboundSchema).optional(),
     storage_class: nullableType(StorageClass$inboundSchema).optional(),
-    timestamping: TimestampingReconfiguration$inboundSchema
+    timestamping: nullableType(TimestampingReconfiguration$inboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       retention_policy: "retentionPolicy",
@@ -35981,7 +36306,7 @@ var init_streamreconfiguration = __esm(() => {
   StreamReconfiguration$outboundSchema = objectType({
     retentionPolicy: nullableType(RetentionPolicy$outboundSchema).optional(),
     storageClass: nullableType(StorageClass$outboundSchema).optional(),
-    timestamping: TimestampingReconfiguration$outboundSchema
+    timestamping: nullableType(TimestampingReconfiguration$outboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       retentionPolicy: "retention_policy",
@@ -36028,50 +36353,6 @@ var init_basinreconfiguration = __esm(() => {
   })(BasinReconfiguration$ ||= {});
 });
 
-// src/models/components/streamposition.ts
-var StreamPosition$inboundSchema, StreamPosition$outboundSchema, StreamPosition$;
-var init_streamposition = __esm(() => {
-  init_lib();
-  init_primitives();
-  StreamPosition$inboundSchema = objectType({
-    seq_num: numberType().int(),
-    timestamp: numberType().int()
-  }).transform((v2) => {
-    return remap(v2, {
-      seq_num: "seqNum"
-    });
-  });
-  StreamPosition$outboundSchema = objectType({
-    seqNum: numberType().int(),
-    timestamp: numberType().int()
-  }).transform((v2) => {
-    return remap(v2, {
-      seqNum: "seq_num"
-    });
-  });
-  ((StreamPosition$) => {
-    StreamPosition$.inboundSchema = StreamPosition$inboundSchema;
-    StreamPosition$.outboundSchema = StreamPosition$outboundSchema;
-  })(StreamPosition$ ||= {});
-});
-
-// src/models/components/checktailresponse.ts
-var CheckTailResponse$inboundSchema, CheckTailResponse$outboundSchema, CheckTailResponse$;
-var init_checktailresponse = __esm(() => {
-  init_lib();
-  init_streamposition();
-  CheckTailResponse$inboundSchema = objectType({
-    tail: StreamPosition$inboundSchema
-  });
-  CheckTailResponse$outboundSchema = objectType({
-    tail: StreamPosition$outboundSchema
-  });
-  ((CheckTailResponse$) => {
-    CheckTailResponse$.inboundSchema = CheckTailResponse$inboundSchema;
-    CheckTailResponse$.outboundSchema = CheckTailResponse$outboundSchema;
-  })(CheckTailResponse$ ||= {});
-});
-
 // src/models/components/createbasinrequest.ts
 var Scope$inboundSchema, Scope$outboundSchema, Scope$, CreateBasinRequest$inboundSchema, CreateBasinRequest$outboundSchema, CreateBasinRequest$;
 var init_createbasinrequest = __esm(() => {
@@ -36085,10 +36366,12 @@ var init_createbasinrequest = __esm(() => {
     Scope$.outboundSchema = Scope$outboundSchema;
   })(Scope$ ||= {});
   CreateBasinRequest$inboundSchema = objectType({
+    basin: stringType(),
     config: nullableType(BasinConfig$inboundSchema).optional(),
     scope: BasinScope$inboundSchema.optional()
   });
   CreateBasinRequest$outboundSchema = objectType({
+    basin: stringType(),
     config: nullableType(BasinConfig$outboundSchema).optional(),
     scope: BasinScope$outboundSchema.optional()
   });
@@ -36098,6 +36381,51 @@ var init_createbasinrequest = __esm(() => {
   })(CreateBasinRequest$ ||= {});
 });
 
+// src/models/components/createorreconfigurebasinrequest.ts
+var CreateOrReconfigureBasinRequestScope$inboundSchema, CreateOrReconfigureBasinRequestScope$outboundSchema, CreateOrReconfigureBasinRequestScope$, CreateOrReconfigureBasinRequest$inboundSchema, CreateOrReconfigureBasinRequest$outboundSchema, CreateOrReconfigureBasinRequest$;
+var init_createorreconfigurebasinrequest = __esm(() => {
+  init_lib();
+  init_basinconfig();
+  init_basinscope();
+  CreateOrReconfigureBasinRequestScope$inboundSchema = BasinScope$inboundSchema;
+  CreateOrReconfigureBasinRequestScope$outboundSchema = BasinScope$outboundSchema;
+  ((CreateOrReconfigureBasinRequestScope$) => {
+    CreateOrReconfigureBasinRequestScope$.inboundSchema = CreateOrReconfigureBasinRequestScope$inboundSchema;
+    CreateOrReconfigureBasinRequestScope$.outboundSchema = CreateOrReconfigureBasinRequestScope$outboundSchema;
+  })(CreateOrReconfigureBasinRequestScope$ ||= {});
+  CreateOrReconfigureBasinRequest$inboundSchema = objectType({
+    config: nullableType(BasinConfig$inboundSchema).optional(),
+    scope: BasinScope$inboundSchema.optional()
+  });
+  CreateOrReconfigureBasinRequest$outboundSchema = objectType({
+    config: nullableType(BasinConfig$outboundSchema).optional(),
+    scope: BasinScope$outboundSchema.optional()
+  });
+  ((CreateOrReconfigureBasinRequest$) => {
+    CreateOrReconfigureBasinRequest$.inboundSchema = CreateOrReconfigureBasinRequest$inboundSchema;
+    CreateOrReconfigureBasinRequest$.outboundSchema = CreateOrReconfigureBasinRequest$outboundSchema;
+  })(CreateOrReconfigureBasinRequest$ ||= {});
+});
+
+// src/models/components/createstreamrequest.ts
+var CreateStreamRequest$inboundSchema, CreateStreamRequest$outboundSchema, CreateStreamRequest$;
+var init_createstreamrequest = __esm(() => {
+  init_lib();
+  init_streamconfig();
+  CreateStreamRequest$inboundSchema = objectType({
+    config: nullableType(StreamConfig$inboundSchema).optional(),
+    stream: stringType()
+  });
+  CreateStreamRequest$outboundSchema = objectType({
+    config: nullableType(StreamConfig$outboundSchema).optional(),
+    stream: stringType()
+  });
+  ((CreateStreamRequest$) => {
+    CreateStreamRequest$.inboundSchema = CreateStreamRequest$inboundSchema;
+    CreateStreamRequest$.outboundSchema = CreateStreamRequest$outboundSchema;
+  })(CreateStreamRequest$ ||= {});
+});
+
 // src/models/components/issueaccesstokenresponse.ts
 var IssueAccessTokenResponse$inboundSchema, IssueAccessTokenResponse$outboundSchema, IssueAccessTokenResponse$;
 var init_issueaccesstokenresponse = __esm(() => {
@@ -36240,6 +36568,138 @@ var init_liststreamsresponse = __esm(() => {
   })(ListStreamsResponse$ ||= {});
 });
 
+// src/models/components/sequencedrecord.ts
+var SequencedRecord$inboundSchema, SequencedRecord$outboundSchema, SequencedRecord$;
+var init_sequencedrecord = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_header();
+  SequencedRecord$inboundSchema = objectType({
+    body: stringType().optional(),
+    headers: arrayType(Header$inboundSchema).optional(),
+    seq_num: numberType().int(),
+    timestamp: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      seq_num: "seqNum"
+    });
+  });
+  SequencedRecord$outboundSchema = objectType({
+    body: stringType().optional(),
+    headers: arrayType(Header$outboundSchema).optional(),
+    seqNum: numberType().int(),
+    timestamp: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      seqNum: "seq_num"
+    });
+  });
+  ((SequencedRecord$) => {
+    SequencedRecord$.inboundSchema = SequencedRecord$inboundSchema;
+    SequencedRecord$.outboundSchema = SequencedRecord$outboundSchema;
+  })(SequencedRecord$ ||= {});
+});
+
+// src/models/components/readbatch.ts
+var ReadBatch$inboundSchema, ReadBatch$outboundSchema, ReadBatch$;
+var init_readbatch = __esm(() => {
+  init_lib();
+  init_sequencedrecord();
+  ReadBatch$inboundSchema = objectType({
+    records: arrayType(SequencedRecord$inboundSchema)
+  });
+  ReadBatch$outboundSchema = objectType({
+    records: arrayType(SequencedRecord$outboundSchema)
+  });
+  ((ReadBatch$) => {
+    ReadBatch$.inboundSchema = ReadBatch$inboundSchema;
+    ReadBatch$.outboundSchema = ReadBatch$outboundSchema;
+  })(ReadBatch$ ||= {});
+});
+
+// src/models/components/readevent.ts
+var Ping$inboundSchema, Ping$outboundSchema, Ping$, ErrorT$inboundSchema, ErrorT$outboundSchema, ErrorT$, Batch$inboundSchema, Batch$outboundSchema, Batch$, ReadEvent$inboundSchema, ReadEvent$outboundSchema, ReadEvent$;
+var init_readevent = __esm(() => {
+  init_lib();
+  init_readbatch();
+  Ping$inboundSchema = objectType({
+    data: stringType(),
+    event: stringType()
+  });
+  Ping$outboundSchema = objectType({
+    data: stringType(),
+    event: stringType()
+  });
+  ((Ping$) => {
+    Ping$.inboundSchema = Ping$inboundSchema;
+    Ping$.outboundSchema = Ping$outboundSchema;
+  })(Ping$ ||= {});
+  ErrorT$inboundSchema = objectType({
+    data: stringType(),
+    event: stringType()
+  });
+  ErrorT$outboundSchema = objectType({
+    data: stringType(),
+    event: stringType()
+  });
+  ((ErrorT$) => {
+    ErrorT$.inboundSchema = ErrorT$inboundSchema;
+    ErrorT$.outboundSchema = ErrorT$outboundSchema;
+  })(ErrorT$ ||= {});
+  Batch$inboundSchema = objectType({
+    data: stringType().transform((v2, ctx) => {
+      try {
+        return JSON.parse(v2);
+      } catch (err) {
+        ctx.addIssue({
+          code: ZodIssueCode.custom,
+          message: `malformed json: ${err}`
+        });
+        return NEVER;
+      }
+    }).pipe(ReadBatch$inboundSchema),
+    event: stringType()
+  });
+  Batch$outboundSchema = objectType({
+    data: ReadBatch$outboundSchema,
+    event: stringType()
+  });
+  ((Batch$) => {
+    Batch$.inboundSchema = Batch$inboundSchema;
+    Batch$.outboundSchema = Batch$outboundSchema;
+  })(Batch$ ||= {});
+  ReadEvent$inboundSchema = unionType([
+    lazyType(() => Batch$inboundSchema),
+    lazyType(() => ErrorT$inboundSchema),
+    lazyType(() => Ping$inboundSchema)
+  ]);
+  ReadEvent$outboundSchema = unionType([
+    lazyType(() => Batch$outboundSchema),
+    lazyType(() => ErrorT$outboundSchema),
+    lazyType(() => Ping$outboundSchema)
+  ]);
+  ((ReadEvent$) => {
+    ReadEvent$.inboundSchema = ReadEvent$inboundSchema;
+    ReadEvent$.outboundSchema = ReadEvent$outboundSchema;
+  })(ReadEvent$ ||= {});
+});
+
+// src/models/components/s2format.ts
+var S2Format, S2Format$inboundSchema, S2Format$outboundSchema, S2Format$;
+var init_s2format = __esm(() => {
+  init_lib();
+  S2Format = {
+    Json: "json",
+    JsonBinsafe: "json-binsafe"
+  };
+  S2Format$inboundSchema = nativeEnumType(S2Format);
+  S2Format$outboundSchema = S2Format$inboundSchema;
+  ((S2Format$) => {
+    S2Format$.inboundSchema = S2Format$inboundSchema;
+    S2Format$.outboundSchema = S2Format$outboundSchema;
+  })(S2Format$ ||= {});
+});
+
 // src/models/components/security.ts
 var Security$inboundSchema, Security$outboundSchema, Security$;
 var init_security2 = __esm(() => {
@@ -36265,44 +36725,147 @@ var init_security2 = __esm(() => {
   })(Security$ ||= {});
 });
 
+// src/models/components/tailresponse.ts
+var TailResponse$inboundSchema, TailResponse$outboundSchema, TailResponse$;
+var init_tailresponse = __esm(() => {
+  init_lib();
+  init_streamposition();
+  TailResponse$inboundSchema = objectType({
+    tail: StreamPosition$inboundSchema
+  });
+  TailResponse$outboundSchema = objectType({
+    tail: StreamPosition$outboundSchema
+  });
+  ((TailResponse$) => {
+    TailResponse$.inboundSchema = TailResponse$inboundSchema;
+    TailResponse$.outboundSchema = TailResponse$outboundSchema;
+  })(TailResponse$ ||= {});
+});
+
 // src/models/components/index.ts
 var init_components = __esm(() => {
   init_accesstokeninfo();
   init_accesstokenscope();
+  init_appendack();
+  init_appendinput();
+  init_appendrecord();
   init_basinconfig();
   init_basininfo();
   init_basinreconfiguration();
   init_basinscope();
   init_basinstate();
-  init_checktailresponse();
   init_createbasinrequest();
+  init_createorreconfigurebasinrequest();
+  init_createstreamrequest();
+  init_header();
   init_issueaccesstokenresponse();
   init_listaccesstokensresponse();
   init_listbasinsresponse();
   init_liststreamsresponse();
   init_operation();
   init_permittedoperationgroups();
+  init_readbatch();
+  init_readevent();
   init_readwritepermissions();
   init_resourceset();
   init_retentionpolicy();
+  init_s2format();
   init_security2();
+  init_sequencedrecord();
   init_storageclass();
   init_streamconfig();
   init_streaminfo();
   init_streamposition();
   init_streamreconfiguration();
+  init_tailresponse();
   init_timestampingconfig();
   init_timestampingmode();
   init_timestampingreconfiguration();
 });
 
-// src/models/errors/errorresponse.ts
-var ErrorResponse, ErrorResponse$inboundSchema, ErrorResponse$outboundSchema, ErrorResponse$;
-var init_errorresponse = __esm(() => {
+// src/models/errors/appendconditionfailed.ts
+var Two, One, Two$inboundSchema, Two$outboundSchema, Two$, One$inboundSchema2, One$outboundSchema2, One$2, AppendConditionFailed$inboundSchema, AppendConditionFailed$outboundSchema, AppendConditionFailed$;
+var init_appendconditionfailed = __esm(() => {
   init_lib();
-  ErrorResponse = class ErrorResponse extends Error {
-    code;
-    error;
+  init_primitives();
+  Two = class Two extends Error {
+    seqNumMismatch;
+    data$;
+    constructor(err) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message);
+      this.data$ = err;
+      this.seqNumMismatch = err.seqNumMismatch;
+      this.name = "Two";
+    }
+  };
+  One = class One extends Error {
+    fencingTokenMismatch;
+    data$;
+    constructor(err) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message);
+      this.data$ = err;
+      this.fencingTokenMismatch = err.fencingTokenMismatch;
+      this.name = "One";
+    }
+  };
+  Two$inboundSchema = objectType({
+    SeqNumMismatch: numberType().int()
+  }).transform((v2) => {
+    const remapped = remap(v2, {
+      SeqNumMismatch: "seqNumMismatch"
+    });
+    return new Two(remapped);
+  });
+  Two$outboundSchema = instanceOfType(Two).transform((v2) => v2.data$).pipe(objectType({
+    seqNumMismatch: numberType().int()
+  }).transform((v2) => {
+    return remap(v2, {
+      seqNumMismatch: "SeqNumMismatch"
+    });
+  }));
+  ((Two$) => {
+    Two$.inboundSchema = Two$inboundSchema;
+    Two$.outboundSchema = Two$outboundSchema;
+  })(Two$ ||= {});
+  One$inboundSchema2 = objectType({
+    FencingTokenMismatch: stringType()
+  }).transform((v2) => {
+    const remapped = remap(v2, {
+      FencingTokenMismatch: "fencingTokenMismatch"
+    });
+    return new One(remapped);
+  });
+  One$outboundSchema2 = instanceOfType(One).transform((v2) => v2.data$).pipe(objectType({
+    fencingTokenMismatch: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      fencingTokenMismatch: "FencingTokenMismatch"
+    });
+  }));
+  ((One$) => {
+    One$.inboundSchema = One$inboundSchema2;
+    One$.outboundSchema = One$outboundSchema2;
+  })(One$2 ||= {});
+  AppendConditionFailed$inboundSchema = unionType([lazyType(() => One$inboundSchema2), lazyType(() => Two$inboundSchema)]);
+  AppendConditionFailed$outboundSchema = unionType([
+    lazyType(() => One$outboundSchema2),
+    lazyType(() => Two$outboundSchema)
+  ]);
+  ((AppendConditionFailed$) => {
+    AppendConditionFailed$.inboundSchema = AppendConditionFailed$inboundSchema;
+    AppendConditionFailed$.outboundSchema = AppendConditionFailed$outboundSchema;
+  })(AppendConditionFailed$ ||= {});
+});
+
+// src/models/errors/errorresponse.ts
+var ErrorResponse, ErrorResponse$inboundSchema, ErrorResponse$outboundSchema, ErrorResponse$;
+var init_errorresponse = __esm(() => {
+  init_lib();
+  ErrorResponse = class ErrorResponse extends Error {
+    code;
+    error;
     data$;
     constructor(err) {
       const message = err.error || "API error occurred";
@@ -36332,6 +36895,35 @@ var init_errorresponse = __esm(() => {
   })(ErrorResponse$ ||= {});
 });
 
+// src/models/errors/notfounderror.ts
+var NotFoundError, NotFoundError$inboundSchema, NotFoundError$outboundSchema, NotFoundError$;
+var init_notfounderror = __esm(() => {
+  init_lib();
+  NotFoundError = class NotFoundError extends Error {
+    error;
+    data$;
+    constructor(err) {
+      const message = err.error || "API error occurred";
+      super(message);
+      this.data$ = err;
+      this.error = err.error;
+      this.name = "NotFoundError";
+    }
+  };
+  NotFoundError$inboundSchema = objectType({
+    error: stringType()
+  }).transform((v2) => {
+    return new NotFoundError(v2);
+  });
+  NotFoundError$outboundSchema = instanceOfType(NotFoundError).transform((v2) => v2.data$).pipe(objectType({
+    error: stringType()
+  }));
+  ((NotFoundError$) => {
+    NotFoundError$.inboundSchema = NotFoundError$inboundSchema;
+    NotFoundError$.outboundSchema = NotFoundError$outboundSchema;
+  })(NotFoundError$ ||= {});
+});
+
 // src/models/errors/retryableerror.ts
 var RetryableError, RetryableError$inboundSchema, RetryableError$outboundSchema, RetryableError$;
 var init_retryableerror = __esm(() => {
@@ -36361,13 +36953,46 @@ var init_retryableerror = __esm(() => {
   })(RetryableError$ ||= {});
 });
 
+// src/models/errors/tailresponse.ts
+var TailResponse, TailResponse$inboundSchema2, TailResponse$outboundSchema2, TailResponse$2;
+var init_tailresponse2 = __esm(() => {
+  init_lib();
+  init_components();
+  TailResponse = class TailResponse extends Error {
+    tail;
+    data$;
+    constructor(err) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message);
+      this.data$ = err;
+      this.tail = err.tail;
+      this.name = "TailResponse";
+    }
+  };
+  TailResponse$inboundSchema2 = objectType({
+    tail: StreamPosition$inboundSchema
+  }).transform((v2) => {
+    return new TailResponse(v2);
+  });
+  TailResponse$outboundSchema2 = instanceOfType(TailResponse).transform((v2) => v2.data$).pipe(objectType({
+    tail: StreamPosition$outboundSchema
+  }));
+  ((TailResponse$) => {
+    TailResponse$.inboundSchema = TailResponse$inboundSchema2;
+    TailResponse$.outboundSchema = TailResponse$outboundSchema2;
+  })(TailResponse$2 ||= {});
+});
+
 // src/models/errors/index.ts
 var init_errors = __esm(() => {
   init_apierror();
+  init_appendconditionfailed();
   init_errorresponse();
   init_httpclienterrors();
+  init_notfounderror();
   init_retryableerror();
   init_sdkvalidationerror();
+  init_tailresponse2();
 });
 
 // src/types/async.ts
@@ -36439,7 +37064,7 @@ async function $do(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: ["400", "403", "409", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -36450,7 +37075,7 @@ async function $do(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, IssueAccessTokenResponse$inboundSchema), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, IssueAccessTokenResponse$inboundSchema), jsonErr([400, 403, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -36496,6 +37121,41 @@ var init_accessTokensIssueAccessToken2 = __esm(() => {
   };
 });
 
+// src/models/operations/append.ts
+var AppendServerList, AppendRequest$inboundSchema, AppendRequest$outboundSchema, AppendRequest$;
+var init_append = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  AppendServerList = [
+    "https://{basin}.b.aws.s2.dev/v1"
+  ];
+  AppendRequest$inboundSchema = objectType({
+    stream: stringType(),
+    "s2-format": S2Format$inboundSchema.optional(),
+    AppendInput: AppendInput$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      "s2-format": "s2Format",
+      AppendInput: "appendInput"
+    });
+  });
+  AppendRequest$outboundSchema = objectType({
+    stream: stringType(),
+    s2Format: S2Format$outboundSchema.optional(),
+    appendInput: AppendInput$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      s2Format: "s2-format",
+      appendInput: "AppendInput"
+    });
+  });
+  ((AppendRequest$) => {
+    AppendRequest$.inboundSchema = AppendRequest$inboundSchema;
+    AppendRequest$.outboundSchema = AppendRequest$outboundSchema;
+  })(AppendRequest$ ||= {});
+});
+
 // src/models/operations/checktail.ts
 var CheckTailServerList, CheckTailRequest$inboundSchema, CheckTailRequest$outboundSchema, CheckTailRequest$;
 var init_checktail = __esm(() => {
@@ -36516,35 +37176,35 @@ var init_checktail = __esm(() => {
 });
 
 // src/models/operations/createorreconfigurebasin.ts
-var CreateOrReconfigureBasinRequest$inboundSchema, CreateOrReconfigureBasinRequest$outboundSchema, CreateOrReconfigureBasinRequest$;
+var CreateOrReconfigureBasinRequest$inboundSchema2, CreateOrReconfigureBasinRequest$outboundSchema2, CreateOrReconfigureBasinRequest$2;
 var init_createorreconfigurebasin = __esm(() => {
   init_lib();
   init_primitives();
   init_components();
-  CreateOrReconfigureBasinRequest$inboundSchema = objectType({
-    basin: stringType(),
+  CreateOrReconfigureBasinRequest$inboundSchema2 = objectType({
     "s2-request-token": stringType().optional(),
-    CreateBasinRequest: CreateBasinRequest$inboundSchema
+    basin: stringType(),
+    CreateOrReconfigureBasinRequest: nullableType(CreateOrReconfigureBasinRequest$inboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       "s2-request-token": "s2RequestToken",
-      CreateBasinRequest: "createBasinRequest"
+      CreateOrReconfigureBasinRequest: "createOrReconfigureBasinRequest"
     });
   });
-  CreateOrReconfigureBasinRequest$outboundSchema = objectType({
-    basin: stringType(),
+  CreateOrReconfigureBasinRequest$outboundSchema2 = objectType({
     s2RequestToken: stringType().optional(),
-    createBasinRequest: CreateBasinRequest$outboundSchema
+    basin: stringType(),
+    createOrReconfigureBasinRequest: nullableType(CreateOrReconfigureBasinRequest$outboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       s2RequestToken: "s2-request-token",
-      createBasinRequest: "CreateBasinRequest"
+      createOrReconfigureBasinRequest: "CreateOrReconfigureBasinRequest"
     });
   });
   ((CreateOrReconfigureBasinRequest$) => {
-    CreateOrReconfigureBasinRequest$.inboundSchema = CreateOrReconfigureBasinRequest$inboundSchema;
-    CreateOrReconfigureBasinRequest$.outboundSchema = CreateOrReconfigureBasinRequest$outboundSchema;
-  })(CreateOrReconfigureBasinRequest$ ||= {});
+    CreateOrReconfigureBasinRequest$.inboundSchema = CreateOrReconfigureBasinRequest$inboundSchema2;
+    CreateOrReconfigureBasinRequest$.outboundSchema = CreateOrReconfigureBasinRequest$outboundSchema2;
+  })(CreateOrReconfigureBasinRequest$2 ||= {});
 });
 
 // src/models/operations/createorreconfigurestream.ts
@@ -36559,7 +37219,7 @@ var init_createorreconfigurestream = __esm(() => {
   CreateOrReconfigureStreamRequest$inboundSchema = objectType({
     stream: stringType(),
     "s2-request-token": stringType().optional(),
-    StreamConfig: StreamConfig$inboundSchema
+    StreamConfig: nullableType(StreamConfig$inboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       "s2-request-token": "s2RequestToken",
@@ -36569,7 +37229,7 @@ var init_createorreconfigurestream = __esm(() => {
   CreateOrReconfigureStreamRequest$outboundSchema = objectType({
     stream: stringType(),
     s2RequestToken: stringType().optional(),
-    streamConfig: StreamConfig$outboundSchema
+    streamConfig: nullableType(StreamConfig$outboundSchema).optional()
   }).transform((v2) => {
     return remap(v2, {
       s2RequestToken: "s2-request-token",
@@ -36582,6 +37242,14 @@ var init_createorreconfigurestream = __esm(() => {
   })(CreateOrReconfigureStreamRequest$ ||= {});
 });
 
+// src/models/operations/createstream.ts
+var CreateStreamServerList;
+var init_createstream = __esm(() => {
+  CreateStreamServerList = [
+    "https://{basin}.b.aws.s2.dev/v1"
+  ];
+});
+
 // src/models/operations/deletebasin.ts
 var DeleteBasinRequest$inboundSchema, DeleteBasinRequest$outboundSchema, DeleteBasinRequest$;
 var init_deletebasin = __esm(() => {
@@ -36780,6 +37448,69 @@ var init_liststreams = __esm(() => {
   })(ListStreamsResponse$2 ||= {});
 });
 
+// src/models/operations/read.ts
+var ReadServerList, ReadRequest$inboundSchema, ReadRequest$outboundSchema, ReadRequest$, ReadResponse$inboundSchema, ReadResponse$outboundSchema, ReadResponse$;
+var init_read = __esm(() => {
+  init_lib();
+  init_event_streams();
+  init_primitives();
+  init_components();
+  ReadServerList = [
+    "https://{basin}.b.aws.s2.dev/v1"
+  ];
+  ReadRequest$inboundSchema = objectType({
+    stream: stringType(),
+    "s2-format": S2Format$inboundSchema.optional(),
+    seq_num: numberType().int().optional(),
+    timestamp: numberType().int().optional(),
+    tail_offset: numberType().int().optional(),
+    count: numberType().int().optional(),
+    bytes: numberType().int().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "s2-format": "s2Format",
+      seq_num: "seqNum",
+      tail_offset: "tailOffset"
+    });
+  });
+  ReadRequest$outboundSchema = objectType({
+    stream: stringType(),
+    s2Format: S2Format$outboundSchema.optional(),
+    seqNum: numberType().int().optional(),
+    timestamp: numberType().int().optional(),
+    tailOffset: numberType().int().optional(),
+    count: numberType().int().optional(),
+    bytes: numberType().int().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      s2Format: "s2-format",
+      seqNum: "seq_num",
+      tailOffset: "tail_offset"
+    });
+  });
+  ((ReadRequest$) => {
+    ReadRequest$.inboundSchema = ReadRequest$inboundSchema;
+    ReadRequest$.outboundSchema = ReadRequest$outboundSchema;
+  })(ReadRequest$ ||= {});
+  ReadResponse$inboundSchema = unionType([
+    ReadBatch$inboundSchema,
+    instanceOfType(ReadableStream).transform((stream) => {
+      return new EventStream({
+        stream,
+        decoder(rawEvent) {
+          const schema = ReadEvent$inboundSchema;
+          return schema.parse(rawEvent);
+        }
+      });
+    })
+  ]);
+  ReadResponse$outboundSchema = unionType([ReadBatch$outboundSchema, neverType()]);
+  ((ReadResponse$) => {
+    ReadResponse$.inboundSchema = ReadResponse$inboundSchema;
+    ReadResponse$.outboundSchema = ReadResponse$outboundSchema;
+  })(ReadResponse$ ||= {});
+});
+
 // src/models/operations/reconfigurebasin.ts
 var ReconfigureBasinRequest$inboundSchema, ReconfigureBasinRequest$outboundSchema, ReconfigureBasinRequest$;
 var init_reconfigurebasin = __esm(() => {
@@ -36857,9 +37588,11 @@ var init_revokeaccesstoken = __esm(() => {
 
 // src/models/operations/index.ts
 var init_operations = __esm(() => {
+  init_append();
   init_checktail();
   init_createorreconfigurebasin();
   init_createorreconfigurestream();
+  init_createstream();
   init_deletebasin();
   init_deletestream();
   init_getbasinconfig();
@@ -36867,6 +37600,7 @@ var init_operations = __esm(() => {
   init_listaccesstokens();
   init_listbasins();
   init_liststreams();
+  init_read();
   init_reconfigurebasin();
   init_reconfigurestream();
   init_revokeaccesstoken();
@@ -36920,7 +37654,7 @@ async function $do2(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: ["400", "403", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -36931,7 +37665,7 @@ async function $do2(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, ListAccessTokensResponse$inboundSchema), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, ListAccessTokensResponse$inboundSchema), jsonErr([400, 403], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -37026,7 +37760,7 @@ async function $do3(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: ["400", "403", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -37037,7 +37771,7 @@ async function $do3(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(200, voidType()), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(200, voidType()), jsonErr([400, 403], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -37083,17 +37817,128 @@ var init_accessTokensRevokeAccessToken2 = __esm(() => {
   };
 });
 
-// src/funcs/basinsCreateOrReconfigureBasin.ts
-function basinsCreateOrReconfigureBasin(client, request, options) {
+// src/funcs/basinsCreateBasin.ts
+function basinsCreateBasin(client, request, options) {
   return new APIPromise($do4(client, request, options));
 }
 async function $do4(client, request, options) {
-  const parsed = safeParse(request, (value) => CreateOrReconfigureBasinRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => CreateBasinRequest$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 path = pathToFunc("/basins")();
+  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: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_basin",
+    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: options?.serverURL,
+    path,
+    headers,
+    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",
+      "401",
+      "403",
+      "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 match(json(201, BasinInfo$inboundSchema), jsonErr([400, 401, 403, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_basinsCreateBasin = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_async();
+});
+
+// src/mcp-server/tools/basinsCreateBasin.ts
+var args4, tool$basinsCreateBasin;
+var init_basinsCreateBasin2 = __esm(() => {
+  init_basinsCreateBasin();
+  init_components();
+  init_tools();
+  args4 = {
+    request: CreateBasinRequest$inboundSchema
+  };
+  tool$basinsCreateBasin = {
+    name: "basins-create-basin",
+    description: `Create a basin.`,
+    scopes: ["write"],
+    args: args4,
+    tool: async (client, args5, ctx) => {
+      const [result, apiCall] = await basinsCreateBasin(client, args5.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);
+    }
+  };
+});
+
+// src/funcs/basinsCreateOrReconfigureBasin.ts
+function basinsCreateOrReconfigureBasin(client, request, options) {
+  return new APIPromise($do5(client, request, options));
+}
+async function $do5(client, request, options) {
+  const parsed = safeParse(request, (value) => CreateOrReconfigureBasinRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CreateBasinRequest, {
+  const body = encodeJSON("body", payload.CreateOrReconfigureBasinRequest, {
     explode: true
   });
   const pathParams = {
@@ -37135,7 +37980,7 @@ async function $do4(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: ["400", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -37146,7 +37991,7 @@ async function $do4(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, BasinInfo$inboundSchema.optional()), nil(204, BasinInfo$inboundSchema.optional()), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, BasinInfo$inboundSchema.optional()), nil(204, BasinInfo$inboundSchema.optional()), jsonErr(400, ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -37166,21 +38011,21 @@ var init_basinsCreateOrReconfigureBasin = __esm(() => {
 });
 
 // src/mcp-server/tools/basinsCreateOrReconfigureBasin.ts
-var args4, tool$basinsCreateOrReconfigureBasin;
+var args5, tool$basinsCreateOrReconfigureBasin;
 var init_basinsCreateOrReconfigureBasin2 = __esm(() => {
   init_basinsCreateOrReconfigureBasin();
   init_operations();
   init_tools();
-  args4 = {
-    request: CreateOrReconfigureBasinRequest$inboundSchema
+  args5 = {
+    request: CreateOrReconfigureBasinRequest$inboundSchema2
   };
   tool$basinsCreateOrReconfigureBasin = {
     name: "basins-create-or-reconfigure-basin",
     description: `Create or reconfigure a basin.`,
     scopes: ["write"],
-    args: args4,
-    tool: async (client, args5, ctx) => {
-      const [result, apiCall] = await basinsCreateOrReconfigureBasin(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args5,
+    tool: async (client, args6, ctx) => {
+      const [result, apiCall] = await basinsCreateOrReconfigureBasin(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -37195,9 +38040,9 @@ var init_basinsCreateOrReconfigureBasin2 = __esm(() => {
 
 // src/funcs/basinsDeleteBasin.ts
 function basinsDeleteBasin(client, request, options) {
-  return new APIPromise($do5(client, request, options));
+  return new APIPromise($do6(client, request, options));
 }
-async function $do5(client, request, options) {
+async function $do6(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteBasinRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -37241,7 +38086,18 @@ async function $do5(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "499",
+      "4XX",
+      "500",
+      "503",
+      "504",
+      "5XX"
+    ],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -37252,7 +38108,7 @@ async function $do5(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(202, voidType()), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(202, voidType()), jsonErr([400, 401, 403], ErrorResponse$inboundSchema), jsonErr(404, NotFoundError$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -37272,21 +38128,21 @@ var init_basinsDeleteBasin = __esm(() => {
 });
 
 // src/mcp-server/tools/basinsDeleteBasin.ts
-var args5, tool$basinsDeleteBasin;
+var args6, tool$basinsDeleteBasin;
 var init_basinsDeleteBasin2 = __esm(() => {
   init_basinsDeleteBasin();
   init_operations();
   init_tools();
-  args5 = {
+  args6 = {
     request: DeleteBasinRequest$inboundSchema
   };
   tool$basinsDeleteBasin = {
     name: "basins-delete-basin",
     description: `Delete a basin.`,
     scopes: ["write"],
-    args: args5,
-    tool: async (client, args6, ctx) => {
-      const [result, apiCall] = await basinsDeleteBasin(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args6,
+    tool: async (client, args7, ctx) => {
+      const [result, apiCall] = await basinsDeleteBasin(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -37300,9 +38156,9 @@ var init_basinsDeleteBasin2 = __esm(() => {
 
 // src/funcs/basinsGetBasinConfig.ts
 function basinsGetBasinConfig(client, request, options) {
-  return new APIPromise($do6(client, request, options));
+  return new APIPromise($do7(client, request, options));
 }
-async function $do6(client, request, options) {
+async function $do7(client, request, options) {
   const parsed = safeParse(request, (value) => GetBasinConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -37346,7 +38202,7 @@ async function $do6(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -37357,7 +38213,7 @@ async function $do6(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, BasinConfig$inboundSchema), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, BasinConfig$inboundSchema), jsonErr([400, 403, 404], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -37377,21 +38233,21 @@ var init_basinsGetBasinConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/basinsGetBasinConfig.ts
-var args6, tool$basinsGetBasinConfig;
+var args7, tool$basinsGetBasinConfig;
 var init_basinsGetBasinConfig2 = __esm(() => {
   init_basinsGetBasinConfig();
   init_operations();
   init_tools();
-  args6 = {
+  args7 = {
     request: GetBasinConfigRequest$inboundSchema
   };
   tool$basinsGetBasinConfig = {
     name: "basins-get-basin-config",
     description: `Get basin config.`,
     scopes: ["read"],
-    args: args6,
-    tool: async (client, args7, ctx) => {
-      const [result, apiCall] = await basinsGetBasinConfig(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args7,
+    tool: async (client, args8, ctx) => {
+      const [result, apiCall] = await basinsGetBasinConfig(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -37730,11 +38586,11 @@ function peg$parse(input, options) {
   var peg$f36 = function(name, f, r) {
     return [f, ...r];
   };
-  var peg$f37 = function(name, args7) {
+  var peg$f37 = function(name, args8) {
     return {
       type: "FunctionExpr",
       name,
-      arguments: args7
+      arguments: args8
     };
   };
   var peg$f38 = function(value) {
@@ -40845,7 +41701,7 @@ function evalFunctionExpr(ctx, item, node) {
   if (fn.definition.parameters.length !== node.arguments.length) {
     return false;
   }
-  const args7 = [];
+  const args8 = [];
   for (let i = 0;i < node.arguments.length; i++) {
     const value2 = evalFunctionArgument(ctx, item, node.arguments[i]);
     const param = fn.definition.parameters[i];
@@ -40854,19 +41710,19 @@ function evalFunctionExpr(ctx, item, node) {
         if (!isNodeList(value2) && !isJsonValue(value2)) {
           return false;
         }
-        args7.push(coerceValueType(value2));
+        args8.push(coerceValueType(value2));
         break;
       case "NodesType":
         if (!isNodeList(value2)) {
           return false;
         }
-        args7.push(value2);
+        args8.push(value2);
         break;
       case "LogicalType":
         if (typeof value2 === "boolean") {
-          args7.push(value2);
+          args8.push(value2);
         } else if (isNodeList(value2)) {
-          args7.push(value2.length > 0);
+          args8.push(value2.length > 0);
         } else {
           return false;
         }
@@ -40875,7 +41731,7 @@ function evalFunctionExpr(ctx, item, node) {
         assertNever(param, "Unknown function argument type");
     }
   }
-  return fn.declaration(ctx, ...args7);
+  return fn.declaration(ctx, ...args8);
 }
 function isKnownFunction(functions, name) {
   return Object.hasOwn(functions, name);
@@ -41225,9 +42081,9 @@ var init_operations2 = __esm(() => {
 
 // src/funcs/basinsListBasins.ts
 function basinsListBasins(client, request, options) {
-  return new APIPromise($do7(client, request, options));
+  return new APIPromise($do8(client, request, options));
 }
-async function $do7(client, request, options) {
+async function $do8(client, request, options) {
   const parsed = safeParse(request, (value2) => ListBasinsRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -41271,7 +42127,7 @@ async function $do7(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: ["400", "403", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -41282,7 +42138,7 @@ async function $do7(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result, raw] = await match(json(200, ListBasinsResponse$inboundSchema2, { key: "Result" }), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result, raw] = await match(json(200, ListBasinsResponse$inboundSchema2, { key: "Result" }), jsonErr([400, 403], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [haltIterator(result), {
       status: "complete",
@@ -41323,21 +42179,21 @@ var init_basinsListBasins = __esm(() => {
 });
 
 // src/mcp-server/tools/basinsListBasins.ts
-var args7, tool$basinsListBasins;
+var args8, tool$basinsListBasins;
 var init_basinsListBasins2 = __esm(() => {
   init_basinsListBasins();
   init_operations();
   init_tools();
-  args7 = {
+  args8 = {
     request: ListBasinsRequest$inboundSchema
   };
   tool$basinsListBasins = {
     name: "basins-list-basins",
     description: `List basins.`,
     scopes: ["read"],
-    args: args7,
-    tool: async (client, args8, ctx) => {
-      const [result, apiCall] = await basinsListBasins(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args8,
+    tool: async (client, args9, ctx) => {
+      const [result, apiCall] = await basinsListBasins(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41352,9 +42208,9 @@ var init_basinsListBasins2 = __esm(() => {
 
 // src/funcs/basinsReconfigureBasin.ts
 function basinsReconfigureBasin(client, request, options) {
-  return new APIPromise($do8(client, request, options));
+  return new APIPromise($do9(client, request, options));
 }
-async function $do8(client, request, options) {
+async function $do9(client, request, options) {
   const parsed = safeParse(request, (value2) => ReconfigureBasinRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41401,7 +42257,7 @@ async function $do8(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -41412,7 +42268,7 @@ async function $do8(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, BasinConfig$inboundSchema), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, BasinConfig$inboundSchema), jsonErr([400, 403, 404], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -41432,21 +42288,21 @@ var init_basinsReconfigureBasin = __esm(() => {
 });
 
 // src/mcp-server/tools/basinsReconfigureBasin.ts
-var args8, tool$basinsReconfigureBasin;
+var args9, tool$basinsReconfigureBasin;
 var init_basinsReconfigureBasin2 = __esm(() => {
   init_basinsReconfigureBasin();
   init_operations();
   init_tools();
-  args8 = {
+  args9 = {
     request: ReconfigureBasinRequest$inboundSchema
   };
   tool$basinsReconfigureBasin = {
     name: "basins-reconfigure-basin",
     description: `Reconfigure a basin.`,
     scopes: ["write"],
-    args: args8,
-    tool: async (client, args9, ctx) => {
-      const [result, apiCall] = await basinsReconfigureBasin(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args9,
+    tool: async (client, args10, ctx) => {
+      const [result, apiCall] = await basinsReconfigureBasin(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41459,11 +42315,140 @@ var init_basinsReconfigureBasin2 = __esm(() => {
   };
 });
 
-// src/funcs/recordsCheckTail.ts
+// src/funcs/recordsAppend.ts
+function recordsAppend(client, request, options) {
+  return new APIPromise($do10(client, request, options));
+}
+async function $do10(client, request, options) {
+  const parsed = safeParse(request, (value2) => AppendRequest$outboundSchema.parse(value2), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.AppendInput, { explode: true });
+  const baseURL = options?.serverURL || pathToFunc(AppendServerList[0], { charEncoding: "percent" })({
+    basin: ""
+  });
+  const pathParams = {
+    stream: encodeSimple("stream", payload.stream, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/streams/{stream}/records")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "s2-format": encodeSimple("s2-format", payload["s2-format"], {
+      explode: false,
+      charEncoding: "none"
+    })
+  }));
+  const secConfig = await extractSecurity(client._options.accessToken);
+  const securityInput = secConfig == null ? {} : { accessToken: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: baseURL ?? "",
+    operationID: "append",
+    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,
+    path,
+    headers,
+    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",
+      "401",
+      "404",
+      "409",
+      "412",
+      "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 match(json(200, AppendAck$inboundSchema), jsonErr([400, 401, 404, 409], ErrorResponse$inboundSchema), jsonErr(412, AppendConditionFailed$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_recordsAppend = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_append();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/recordsAppend.ts
+var args10, tool$recordsAppend;
+var init_recordsAppend2 = __esm(() => {
+  init_recordsAppend();
+  init_operations();
+  init_tools();
+  args10 = {
+    request: AppendRequest$inboundSchema
+  };
+  tool$recordsAppend = {
+    name: "records-append",
+    description: `Append records.
+
+Append a batch of records to a stream.`,
+    scopes: ["write"],
+    args: args10,
+    tool: async (client, args11, ctx) => {
+      const [result, apiCall] = await recordsAppend(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value2 = result.value;
+      return formatResult(value2, apiCall);
+    }
+  };
+});
+
+// src/funcs/recordsCheckTail.ts
 function recordsCheckTail(client, request, options) {
-  return new APIPromise($do9(client, request, options));
+  return new APIPromise($do11(client, request, options));
 }
-async function $do9(client, request, options) {
+async function $do11(client, request, options) {
   const parsed = safeParse(request, (value2) => CheckTailRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41510,7 +42495,18 @@ async function $do9(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "404", "499", "4XX", "500", "503", "504", "5XX"],
+    errorCodes: [
+      "400",
+      "401",
+      "404",
+      "409",
+      "499",
+      "4XX",
+      "500",
+      "503",
+      "504",
+      "5XX"
+    ],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -41521,7 +42517,7 @@ async function $do9(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, CheckTailResponse$inboundSchema), jsonErr([400, 401, 404], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, TailResponse$inboundSchema), jsonErr([400, 401, 404, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -41542,12 +42538,12 @@ var init_recordsCheckTail = __esm(() => {
 });
 
 // src/mcp-server/tools/recordsCheckTail.ts
-var args9, tool$recordsCheckTail;
+var args11, tool$recordsCheckTail;
 var init_recordsCheckTail2 = __esm(() => {
   init_recordsCheckTail();
   init_operations();
   init_tools();
-  args9 = {
+  args11 = {
     request: CheckTailRequest$inboundSchema
   };
   tool$recordsCheckTail = {
@@ -41556,9 +42552,144 @@ var init_recordsCheckTail2 = __esm(() => {
 
 Check the tail of a stream.`,
     scopes: ["read"],
-    args: args9,
-    tool: async (client, args10, ctx) => {
-      const [result, apiCall] = await recordsCheckTail(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args11,
+    tool: async (client, args12, ctx) => {
+      const [result, apiCall] = await recordsCheckTail(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value2 = result.value;
+      return formatResult(value2, apiCall);
+    }
+  };
+});
+
+// src/funcs/recordsRead.ts
+function recordsRead(client, request, options) {
+  return new APIPromise($do12(client, request, options));
+}
+async function $do12(client, request, options) {
+  const parsed = safeParse(request, (value2) => ReadRequest$outboundSchema.parse(value2), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const baseURL = options?.serverURL || pathToFunc(ReadServerList[0], { charEncoding: "percent" })({
+    basin: ""
+  });
+  const pathParams = {
+    stream: encodeSimple("stream", payload.stream, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/streams/{stream}/records")(pathParams);
+  const query2 = encodeFormQuery({
+    bytes: payload.bytes,
+    count: payload.count,
+    seq_num: payload.seq_num,
+    tail_offset: payload.tail_offset,
+    timestamp: payload.timestamp
+  });
+  const headers = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, text/event-stream;q=0",
+    "s2-format": encodeSimple("s2-format", payload["s2-format"], {
+      explode: false,
+      charEncoding: "none"
+    })
+  }));
+  const secConfig = await extractSecurity(client._options.accessToken);
+  const securityInput = secConfig == null ? {} : { accessToken: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: baseURL ?? "",
+    operationID: "read",
+    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: "GET",
+    baseURL,
+    path,
+    headers,
+    query: query2,
+    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",
+      "401",
+      "404",
+      "409",
+      "416",
+      "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 match(json(200, ReadResponse$inboundSchema), sse(200, ReadResponse$inboundSchema), jsonErr([400, 401, 404, 409], ErrorResponse$inboundSchema), jsonErr(416, TailResponse$inboundSchema2), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_recordsRead = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors();
+  init_operations();
+  init_read();
+  init_async();
+});
+
+// src/mcp-server/tools/recordsRead.ts
+var args12, tool$recordsRead;
+var init_recordsRead2 = __esm(() => {
+  init_recordsRead();
+  init_operations();
+  init_tools();
+  args12 = {
+    request: ReadRequest$inboundSchema
+  };
+  tool$recordsRead = {
+    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: args12,
+    tool: async (client, args13, ctx) => {
+      const [result, apiCall] = await recordsRead(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41573,9 +42704,9 @@ Check the tail of a stream.`,
 
 // src/funcs/streamsCreateOrReconfigureStream.ts
 function streamsCreateOrReconfigureStream(client, request, options) {
-  return new APIPromise($do10(client, request, options));
+  return new APIPromise($do13(client, request, options));
 }
-async function $do10(client, request, options) {
+async function $do13(client, request, options) {
   const parsed = safeParse(request, (value2) => CreateOrReconfigureStreamRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41613,7 +42744,7 @@ async function $do10(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "PUT",
     baseURL,
     path,
     headers,
@@ -41626,7 +42757,18 @@ async function $do10(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -41637,7 +42779,7 @@ async function $do10(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, StreamInfo$inboundSchema.optional()), nil(204, StreamInfo$inboundSchema.optional()), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, StreamInfo$inboundSchema.optional()), nil(204, StreamInfo$inboundSchema.optional()), jsonErr([400, 403, 404, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -41658,21 +42800,136 @@ var init_streamsCreateOrReconfigureStream = __esm(() => {
 });
 
 // src/mcp-server/tools/streamsCreateOrReconfigureStream.ts
-var args10, tool$streamsCreateOrReconfigureStream;
+var args13, tool$streamsCreateOrReconfigureStream;
 var init_streamsCreateOrReconfigureStream2 = __esm(() => {
   init_streamsCreateOrReconfigureStream();
   init_operations();
   init_tools();
-  args10 = {
+  args13 = {
     request: CreateOrReconfigureStreamRequest$inboundSchema
   };
   tool$streamsCreateOrReconfigureStream = {
     name: "streams-create-or-reconfigure-stream",
     description: `Create or reconfigure a stream.`,
     scopes: ["write"],
-    args: args10,
-    tool: async (client, args11, ctx) => {
-      const [result, apiCall] = await streamsCreateOrReconfigureStream(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args13,
+    tool: async (client, args14, ctx) => {
+      const [result, apiCall] = await streamsCreateOrReconfigureStream(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value2 = result.value;
+      return formatResult(value2, apiCall);
+    }
+  };
+});
+
+// src/funcs/streamsCreateStream.ts
+function streamsCreateStream(client, request, options) {
+  return new APIPromise($do14(client, request, options));
+}
+async function $do14(client, request, options) {
+  const parsed = safeParse(request, (value2) => CreateStreamRequest$outboundSchema.parse(value2), "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,
+    path,
+    headers,
+    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 match(json(201, StreamInfo$inboundSchema), jsonErr([400, 403, 404, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_streamsCreateStream = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_createstream();
+  init_async();
+});
+
+// src/mcp-server/tools/streamsCreateStream.ts
+var args14, tool$streamsCreateStream;
+var init_streamsCreateStream2 = __esm(() => {
+  init_streamsCreateStream();
+  init_components();
+  init_tools();
+  args14 = {
+    request: CreateStreamRequest$inboundSchema
+  };
+  tool$streamsCreateStream = {
+    name: "streams-create-stream",
+    description: `Create a stream.`,
+    scopes: ["write"],
+    args: args14,
+    tool: async (client, args15, ctx) => {
+      const [result, apiCall] = await streamsCreateStream(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41687,9 +42944,9 @@ var init_streamsCreateOrReconfigureStream2 = __esm(() => {
 
 // src/funcs/streamsDeleteStream.ts
 function streamsDeleteStream(client, request, options) {
-  return new APIPromise($do11(client, request, options));
+  return new APIPromise($do15(client, request, options));
 }
-async function $do11(client, request, options) {
+async function $do15(client, request, options) {
   const parsed = safeParse(request, (value2) => DeleteStreamRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41736,7 +42993,7 @@ async function $do11(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -41747,7 +43004,7 @@ async function $do11(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(202, voidType()), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(202, voidType()), jsonErr([400, 403], ErrorResponse$inboundSchema), jsonErr(404, NotFoundError$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -41768,21 +43025,21 @@ var init_streamsDeleteStream = __esm(() => {
 });
 
 // src/mcp-server/tools/streamsDeleteStream.ts
-var args11, tool$streamsDeleteStream;
+var args15, tool$streamsDeleteStream;
 var init_streamsDeleteStream2 = __esm(() => {
   init_streamsDeleteStream();
   init_operations();
   init_tools();
-  args11 = {
+  args15 = {
     request: DeleteStreamRequest$inboundSchema
   };
   tool$streamsDeleteStream = {
     name: "streams-delete-stream",
     description: `Delete a stream.`,
     scopes: ["write"],
-    args: args11,
-    tool: async (client, args12, ctx) => {
-      const [result, apiCall] = await streamsDeleteStream(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args15,
+    tool: async (client, args16, ctx) => {
+      const [result, apiCall] = await streamsDeleteStream(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41796,9 +43053,9 @@ var init_streamsDeleteStream2 = __esm(() => {
 
 // src/funcs/streamsGetStreamConfig.ts
 function streamsGetStreamConfig(client, request, options) {
-  return new APIPromise($do12(client, request, options));
+  return new APIPromise($do16(client, request, options));
 }
-async function $do12(client, request, options) {
+async function $do16(client, request, options) {
   const parsed = safeParse(request, (value2) => GetStreamConfigRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41845,7 +43102,18 @@ async function $do12(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -41856,7 +43124,7 @@ async function $do12(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, StreamConfig$inboundSchema), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, StreamConfig$inboundSchema), jsonErr([400, 403, 404, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -41877,21 +43145,21 @@ var init_streamsGetStreamConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/streamsGetStreamConfig.ts
-var args12, tool$streamsGetStreamConfig;
+var args16, tool$streamsGetStreamConfig;
 var init_streamsGetStreamConfig2 = __esm(() => {
   init_streamsGetStreamConfig();
   init_operations();
   init_tools();
-  args12 = {
+  args16 = {
     request: GetStreamConfigRequest$inboundSchema
   };
   tool$streamsGetStreamConfig = {
     name: "streams-get-stream-config",
     description: `Get stream configuration.`,
     scopes: ["read"],
-    args: args12,
-    tool: async (client, args13, ctx) => {
-      const [result, apiCall] = await streamsGetStreamConfig(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await streamsGetStreamConfig(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41906,9 +43174,9 @@ var init_streamsGetStreamConfig2 = __esm(() => {
 
 // src/funcs/streamsListStreams.ts
 function streamsListStreams(client, request, options) {
-  return new APIPromise($do13(client, request, options));
+  return new APIPromise($do17(client, request, options));
 }
-async function $do13(client, request, options) {
+async function $do17(client, request, options) {
   const parsed = safeParse(request, (value2) => ListStreamsRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -41955,7 +43223,7 @@ async function $do13(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -41968,7 +43236,7 @@ async function $do13(client, request, options) {
   };
   const [result, raw] = await match(json(200, ListStreamsResponse$inboundSchema2, {
     key: "Result"
-  }), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  }), jsonErr([400, 403, 404], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [haltIterator(result), {
       status: "complete",
@@ -42010,21 +43278,21 @@ var init_streamsListStreams = __esm(() => {
 });
 
 // src/mcp-server/tools/streamsListStreams.ts
-var args13, tool$streamsListStreams;
+var args17, tool$streamsListStreams;
 var init_streamsListStreams2 = __esm(() => {
   init_streamsListStreams();
   init_operations();
   init_tools();
-  args13 = {
+  args17 = {
     request: ListStreamsRequest$inboundSchema
   };
   tool$streamsListStreams = {
     name: "streams-list-streams",
     description: `List streams.`,
     scopes: ["read"],
-    args: args13,
-    tool: async (client, args14, ctx) => {
-      const [result, apiCall] = await streamsListStreams(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args17,
+    tool: async (client, args18, ctx) => {
+      const [result, apiCall] = await streamsListStreams(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42039,9 +43307,9 @@ var init_streamsListStreams2 = __esm(() => {
 
 // src/funcs/streamsReconfigureStream.ts
 function streamsReconfigureStream(client, request, options) {
-  return new APIPromise($do14(client, request, options));
+  return new APIPromise($do18(client, request, options));
 }
-async function $do14(client, request, options) {
+async function $do18(client, request, options) {
   const parsed = safeParse(request, (value2) => ReconfigureStreamRequest$outboundSchema.parse(value2), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42091,7 +43359,18 @@ async function $do14(client, request, options) {
   const req = requestRes.value;
   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
   });
@@ -42102,7 +43381,7 @@ async function $do14(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, StreamConfig$inboundSchema), jsonErr([400, 401], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, StreamConfig$inboundSchema), jsonErr([400, 403, 404, 409], ErrorResponse$inboundSchema), jsonErr(499, RetryableError$inboundSchema), jsonErr([500, 503, 504], RetryableError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -42123,21 +43402,21 @@ var init_streamsReconfigureStream = __esm(() => {
 });
 
 // src/mcp-server/tools/streamsReconfigureStream.ts
-var args14, tool$streamsReconfigureStream;
+var args18, tool$streamsReconfigureStream;
 var init_streamsReconfigureStream2 = __esm(() => {
   init_streamsReconfigureStream();
   init_operations();
   init_tools();
-  args14 = {
+  args18 = {
     request: ReconfigureStreamRequest$inboundSchema
   };
   tool$streamsReconfigureStream = {
     name: "streams-reconfigure-stream",
     description: `Reconfigure a stream.`,
     scopes: ["write"],
-    args: args14,
-    tool: async (client, args15, ctx) => {
-      const [result, apiCall] = await streamsReconfigureStream(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args18,
+    tool: async (client, args19, ctx) => {
+      const [result, apiCall] = await streamsReconfigureStream(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42154,7 +43433,7 @@ var init_streamsReconfigureStream2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "S2",
-    version: "0.11.2"
+    version: "0.12.0"
   });
   const client = new S2Core({
     accessToken: deps.accessToken,
@@ -42172,15 +43451,19 @@ 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;
 }
@@ -42192,13 +43475,17 @@ var init_server2 = __esm(() => {
   init_accessTokensIssueAccessToken2();
   init_accessTokensListAccessTokens2();
   init_accessTokensRevokeAccessToken2();
+  init_basinsCreateBasin2();
   init_basinsCreateOrReconfigureBasin2();
   init_basinsDeleteBasin2();
   init_basinsGetBasinConfig2();
   init_basinsListBasins2();
   init_basinsReconfigureBasin2();
+  init_recordsAppend2();
   init_recordsCheckTail2();
+  init_recordsRead2();
   init_streamsCreateOrReconfigureStream2();
+  init_streamsCreateStream2();
   init_streamsDeleteStream2();
   init_streamsGetStreamConfig2();
   init_streamsListStreams2();
@@ -43399,7 +44686,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.11.2"
+    currentVersion: "0.12.0"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -43407,5 +44694,5 @@ export {
   app
 };
 
-//# debugId=4930F833836E7A7764756E2164756E21
+//# debugId=E625D98C99BA8A6B64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map