@reminix/sdk 0.8.2 → 0.8.4

package/src/internal/decoders/line.ts

@@ -0,0 +1,135 @@
+import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
+
+export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+export class LineDecoder {
+  // prettier-ignore
+  static NEWLINE_CHARS = new Set(['\n', '\r']);
+  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+
+  #buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
+
+  constructor() {
+    this.#buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
+  }
+
+  decode(chunk: Bytes): string[] {
+    if (chunk == null) {
+      return [];
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
+
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
+        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
+
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+
+      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
+      lines.push(line);
+
+      this.#buffer = this.#buffer.subarray(patternIndex.index);
+      this.#carriageReturnIndex = null;
+    }
+
+    return lines;
+  }
+
+  flush(): string[] {
+    if (!this.#buffer.length) {
+      return [];
+    }
+    return this.decode('\n');
+  }
+}
+
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
+  }
+
+  return null;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
+}

package/src/internal/parse.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import type { FinalRequestOptions } from './request-options';
+import { Stream } from '../core/streaming';
 import { type Reminix } from '../client';
 import { formatRequestDetails, loggerFor } from './utils/log';
 
@@ -16,6 +17,19 @@ export type APIResponseProps = {
 export async function defaultParseResponse<T>(client: Reminix, props: APIResponseProps): Promise<T> {
   const { response, requestLogID, retryOfRequestLogID, startTime } = props;
   const body = await (async () => {
+    if (props.options.stream) {
+      loggerFor(client).debug('response', response.status, response.url, response.headers, response.body);
+
+      // Note: there is an invariant here that isn't represented in the type system
+      // that if you set `stream: true` the response type must also be `Stream<T>`
+
+      if (props.options.__streamClass) {
+        return props.options.__streamClass.fromSSEResponse(response, props.controller, client) as any;
+      }
+
+      return Stream.fromSSEResponse(response, props.controller, client) as any;
+    }
+
     // fetch refuses to read the body when the status code is 204.
     if (response.status === 204) {
       return null as T;

package/src/internal/request-options.ts

@@ -3,6 +3,7 @@
 import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
+import { Stream } from '../core/streaming';
 import type { HTTPMethod, MergedRequestInit } from './types';
 import { type HeadersLike } from './headers';
 
@@ -76,6 +77,7 @@ export type RequestOptions = {
   defaultBaseURL?: string | undefined;
 
   __binaryResponse?: boolean | undefined;
+  __streamClass?: typeof Stream;
 };
 
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };

package/src/resources/agents.ts

@@ -1,14 +1,12 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../core/resource';
+import * as AgentsAPI from './agents';
 import { APIPromise } from '../core/api-promise';
+import { Stream } from '../core/streaming';
 import { RequestOptions } from '../internal/request-options';
 import { path } from '../internal/utils/path';
 
-// stainless-custom-start
-import { Stream, StreamChunk } from '../streaming';
-// stainless-custom-end
-
 export class Agents extends APIResource {
   /**
    * Have a conversational interaction with an agent. This endpoint maintains
@@ -50,8 +48,31 @@ export class Agents extends APIResource {
    * });
    * ```
    */
-  chat(name: string, body: AgentChatParams, options?: RequestOptions): APIPromise<AgentChatResponse> {
-    return this._client.post(path`/agents/${name}/chat`, { body, ...options });
+  chat(
+    name: string,
+    body: AgentChatParamsNonStreaming,
+    options?: RequestOptions,
+  ): APIPromise<AgentChatResponse>;
+  chat(
+    name: string,
+    body: AgentChatParamsStreaming,
+    options?: RequestOptions,
+  ): APIPromise<Stream<StreamChunk>>;
+  chat(
+    name: string,
+    body: AgentChatParamsBase,
+    options?: RequestOptions,
+  ): APIPromise<Stream<StreamChunk> | AgentChatResponse>;
+  chat(
+    name: string,
+    body: AgentChatParams,
+    options?: RequestOptions,
+  ): APIPromise<AgentChatResponse> | APIPromise<Stream<StreamChunk>> {
+    return this._client.post(path`/agents/${name}/chat`, {
+      body,
+      ...options,
+      stream: body.stream ?? false,
+    }) as APIPromise<AgentChatResponse> | APIPromise<Stream<StreamChunk>>;
   }
 
   /**
@@ -88,71 +109,32 @@ export class Agents extends APIResource {
    * });
    * ```
    */
-  invoke(name: string, body: AgentInvokeParams, options?: RequestOptions): APIPromise<AgentInvokeResponse> {
-    return this._client.post(path`/agents/${name}/invoke`, { body, ...options });
-  }
-
-  // stainless-custom-start
-  /**
-   * Streaming variant of chat(). Returns an async iterable of chunks.
-   *
-   * Have a conversational interaction with an agent with real-time streaming.
-   * Each chunk contains a portion of the response as it's generated.
-   *
-   * @example
-   * ```ts
-   * const stream = await client.agents.chatStream('my-agent', {
-   *   messages: [{ role: 'user', content: 'Tell me a story' }],
-   * });
-   * for await (const chunk of stream) {
-   *   process.stdout.write(chunk.chunk);
-   * }
-   * ```
-   */
-  async chatStream(
+  invoke(
     name: string,
-    body: Omit<AgentChatParams, 'stream'>,
+    body: AgentInvokeParamsNonStreaming,
     options?: RequestOptions,
-  ): Promise<Stream<StreamChunk>> {
-    const response = await this._client.post(path`/agents/${name}/chat`, {
-      body: { ...body, stream: true },
-      ...options,
-      headers: { Accept: 'text/event-stream', ...options?.headers },
-      __binaryResponse: true,
-    });
-    return new Stream<StreamChunk>(response as unknown as Response);
-  }
-
-  /**
-   * Streaming variant of invoke(). Returns an async iterable of chunks.
-   *
-   * Execute a one-shot task with an agent with real-time streaming.
-   * Each chunk contains a portion of the response as it's generated.
-   *
-   * @example
-   * ```ts
-   * const stream = await client.agents.invokeStream('my-agent', {
-   *   input: { task: 'generate', prompt: 'Write a poem' },
-   * });
-   * for await (const chunk of stream) {
-   *   process.stdout.write(chunk.chunk);
-   * }
-   * ```
-   */
-  async invokeStream(
+  ): APIPromise<AgentInvokeResponse>;
+  invoke(
+    name: string,
+    body: AgentInvokeParamsStreaming,
+    options?: RequestOptions,
+  ): APIPromise<Stream<StreamChunk>>;
+  invoke(
+    name: string,
+    body: AgentInvokeParamsBase,
+    options?: RequestOptions,
+  ): APIPromise<Stream<StreamChunk> | AgentInvokeResponse>;
+  invoke(
     name: string,
-    body: Omit<AgentInvokeParams, 'stream'>,
+    body: AgentInvokeParams,
     options?: RequestOptions,
-  ): Promise<Stream<StreamChunk>> {
-    const response = await this._client.post(path`/agents/${name}/invoke`, {
-      body: { ...body, stream: true },
+  ): APIPromise<AgentInvokeResponse> | APIPromise<Stream<StreamChunk>> {
+    return this._client.post(path`/agents/${name}/invoke`, {
+      body,
       ...options,
-      headers: { Accept: 'text/event-stream', ...options?.headers },
-      __binaryResponse: true,
-    });
-    return new Stream<StreamChunk>(response as unknown as Response);
+      stream: body.stream ?? false,
+    }) as APIPromise<AgentInvokeResponse> | APIPromise<Stream<StreamChunk>>;
   }
-  // stainless-custom-end
 }
 
 /**
@@ -175,6 +157,13 @@ export interface Context {
   user_id?: string;
 }
 
+export interface StreamChunk {
+  /**
+   * Text chunk from the stream
+   */
+  chunk: string;
+}
+
 export interface AgentChatResponse {
   /**
    * Full conversation history including the assistant response
@@ -234,7 +223,9 @@ export interface AgentInvokeResponse {
   output?: unknown;
 }
 
-export interface AgentChatParams {
+export type AgentChatParams = AgentChatParamsNonStreaming | AgentChatParamsStreaming;
+
+export interface AgentChatParamsBase {
   /**
    * Conversation history. Must include at least one message.
    */
@@ -289,9 +280,28 @@ export namespace AgentChatParams {
       }
     }
   }
+
+  export type AgentChatParamsNonStreaming = AgentsAPI.AgentChatParamsNonStreaming;
+  export type AgentChatParamsStreaming = AgentsAPI.AgentChatParamsStreaming;
+}
+
+export interface AgentChatParamsNonStreaming extends AgentChatParamsBase {
+  /**
+   * Whether to stream the response as SSE.
+   */
+  stream?: false;
+}
+
+export interface AgentChatParamsStreaming extends AgentChatParamsBase {
+  /**
+   * Whether to stream the response as SSE.
+   */
+  stream: true;
 }
 
-export interface AgentInvokeParams {
+export type AgentInvokeParams = AgentInvokeParamsNonStreaming | AgentInvokeParamsStreaming;
+
+export interface AgentInvokeParamsBase {
   /**
    * Input data for the agent. Structure depends on agent implementation.
    */
@@ -308,12 +318,36 @@ export interface AgentInvokeParams {
   stream?: boolean;
 }
 
+export namespace AgentInvokeParams {
+  export type AgentInvokeParamsNonStreaming = AgentsAPI.AgentInvokeParamsNonStreaming;
+  export type AgentInvokeParamsStreaming = AgentsAPI.AgentInvokeParamsStreaming;
+}
+
+export interface AgentInvokeParamsNonStreaming extends AgentInvokeParamsBase {
+  /**
+   * Whether to stream the response as SSE.
+   */
+  stream?: false;
+}
+
+export interface AgentInvokeParamsStreaming extends AgentInvokeParamsBase {
+  /**
+   * Whether to stream the response as SSE.
+   */
+  stream: true;
+}
+
 export declare namespace Agents {
   export {
     type Context as Context,
+    type StreamChunk as StreamChunk,
     type AgentChatResponse as AgentChatResponse,
     type AgentInvokeResponse as AgentInvokeResponse,
     type AgentChatParams as AgentChatParams,
+    type AgentChatParamsNonStreaming as AgentChatParamsNonStreaming,
+    type AgentChatParamsStreaming as AgentChatParamsStreaming,
     type AgentInvokeParams as AgentInvokeParams,
+    type AgentInvokeParamsNonStreaming as AgentInvokeParamsNonStreaming,
+    type AgentInvokeParamsStreaming as AgentInvokeParamsStreaming,
   };
 }

package/src/resources/deployments.ts

@@ -0,0 +1,5 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+
+export class Deployments extends APIResource {}

package/src/resources/index.ts

@@ -3,9 +3,16 @@
 export {
   Agents,
   type Context,
+  type StreamChunk,
   type AgentChatResponse,
   type AgentInvokeResponse,
   type AgentChatParams,
+  type AgentChatParamsNonStreaming,
+  type AgentChatParamsStreaming,
   type AgentInvokeParams,
+  type AgentInvokeParamsNonStreaming,
+  type AgentInvokeParamsStreaming,
 } from './agents';
-export { Project, type ProjectRetrieveResponse } from './project';
+export { Deployments } from './deployments';
+export { Projects, type ProjectRetrieveCurrentResponse } from './projects';
+export { Secrets } from './secrets';

package/src/resources/{project.ts → projects.ts}

@@ -4,26 +4,27 @@ import { APIResource } from '../core/resource';
 import { APIPromise } from '../core/api-promise';
 import { RequestOptions } from '../internal/request-options';
 
-export class Project extends APIResource {
+export class Projects extends APIResource {
   /**
-   * Returns the project associated with the API key used for authentication.
+   * Returns the project associated with the API key or X-Project header.
    *
    * The project contains metadata about your organization's configuration,
    * including:
    *
    * - Project ID and organization ID
    * - Project name and slug
+   * - Organization details
    * - Creation and update timestamps
    *
    * This endpoint is useful for verifying your API key is valid and retrieving
    * project details.
    */
-  retrieve(options?: RequestOptions): APIPromise<ProjectRetrieveResponse> {
-    return this._client.get('/project', options);
+  retrieveCurrent(options?: RequestOptions): APIPromise<ProjectRetrieveCurrentResponse> {
+    return this._client.get('/projects/current', options);
   }
 }
 
-export interface ProjectRetrieveResponse {
+export interface ProjectRetrieveCurrentResponse {
   /**
    * Unique identifier for the project
    */
@@ -39,6 +40,11 @@ export interface ProjectRetrieveResponse {
    */
   name: string;
 
+  /**
+   * Organization that owns this project
+   */
+  organization: ProjectRetrieveCurrentResponse.Organization;
+
   /**
    * ID of the organization that owns this project
    */
@@ -55,6 +61,28 @@ export interface ProjectRetrieveResponse {
   updatedAt: string;
 }
 
-export declare namespace Project {
-  export { type ProjectRetrieveResponse as ProjectRetrieveResponse };
+export namespace ProjectRetrieveCurrentResponse {
+  /**
+   * Organization that owns this project
+   */
+  export interface Organization {
+    /**
+     * Unique identifier for the organization
+     */
+    id: string;
+
+    /**
+     * Human-readable name of the organization
+     */
+    name: string;
+
+    /**
+     * URL-friendly identifier for the organization
+     */
+    slug: string;
+  }
+}
+
+export declare namespace Projects {
+  export { type ProjectRetrieveCurrentResponse as ProjectRetrieveCurrentResponse };
 }

package/src/resources/secrets.ts

@@ -0,0 +1,5 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+
+export class Secrets extends APIResource {}

package/src/streaming.ts

@@ -1,87 +1,2 @@
-// stainless-custom-start
-/**
- * Streaming utilities for SSE (Server-Sent Events) responses.
- *
- * This module provides streaming support for the Reminix API.
- * When you upgrade to Stainless Pro, you can remove this file
- * and use the built-in streaming support.
- */
-
-/**
- * A chunk from a streaming response.
- */
-export interface StreamChunk {
-  /** Text chunk from the stream */
-  chunk: string;
-}
-
-/**
- * An async iterable stream that parses SSE (Server-Sent Events) responses.
- *
- * @example
- * ```ts
- * const stream = await client.agents.chatStream('agent', { messages: [...] });
- * for await (const chunk of stream) {
- *   process.stdout.write(chunk.chunk);
- * }
- * ```
- */
-export class Stream<T> implements AsyncIterable<T> {
-  constructor(private response: Response) {}
-
-  async *[Symbol.asyncIterator](): AsyncIterator<T> {
-    const reader = this.response.body?.getReader();
-    if (!reader) {
-      throw new Error('Response body is not readable');
-    }
-
-    const decoder = new TextDecoder();
-    let buffer = '';
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed.startsWith('data: ')) {
-            const data = trimmed.slice(6);
-            if (data === '[DONE]') {
-              return;
-            }
-            if (data) {
-              try {
-                yield JSON.parse(data) as T;
-              } catch {
-                // Skip malformed JSON
-              }
-            }
-          }
-        }
-      }
-
-      // Process any remaining data in buffer
-      if (buffer.trim()) {
-        const trimmed = buffer.trim();
-        if (trimmed.startsWith('data: ')) {
-          const data = trimmed.slice(6);
-          if (data && data !== '[DONE]') {
-            try {
-              yield JSON.parse(data) as T;
-            } catch {
-              // Skip malformed JSON
-            }
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-}
-// stainless-custom-end
+/** @deprecated Import from ./core/streaming instead */
+export * from './core/streaming';

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.8.2'; // x-release-please-version
+export const VERSION = '0.8.4'; // x-release-please-version

package/streaming.d.mts

@@ -1,31 +1,2 @@
-/**
- * Streaming utilities for SSE (Server-Sent Events) responses.
- *
- * This module provides streaming support for the Reminix API.
- * When you upgrade to Stainless Pro, you can remove this file
- * and use the built-in streaming support.
- */
-/**
- * A chunk from a streaming response.
- */
-export interface StreamChunk {
-    /** Text chunk from the stream */
-    chunk: string;
-}
-/**
- * An async iterable stream that parses SSE (Server-Sent Events) responses.
- *
- * @example
- * ```ts
- * const stream = await client.agents.chatStream('agent', { messages: [...] });
- * for await (const chunk of stream) {
- *   process.stdout.write(chunk.chunk);
- * }
- * ```
- */
-export declare class Stream<T> implements AsyncIterable<T> {
-    private response;
-    constructor(response: Response);
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
+export * from "./core/streaming.mjs";
 //# sourceMappingURL=streaming.d.mts.map

package/streaming.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"streaming.d.mts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,qBAAa,MAAM,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,QAAQ;IAE/B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAsDlD"}
+{"version":3,"file":"streaming.d.mts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""}

package/streaming.d.ts

@@ -1,31 +1,2 @@
-/**
- * Streaming utilities for SSE (Server-Sent Events) responses.
- *
- * This module provides streaming support for the Reminix API.
- * When you upgrade to Stainless Pro, you can remove this file
- * and use the built-in streaming support.
- */
-/**
- * A chunk from a streaming response.
- */
-export interface StreamChunk {
-    /** Text chunk from the stream */
-    chunk: string;
-}
-/**
- * An async iterable stream that parses SSE (Server-Sent Events) responses.
- *
- * @example
- * ```ts
- * const stream = await client.agents.chatStream('agent', { messages: [...] });
- * for await (const chunk of stream) {
- *   process.stdout.write(chunk.chunk);
- * }
- * ```
- */
-export declare class Stream<T> implements AsyncIterable<T> {
-    private response;
-    constructor(response: Response);
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
+export * from "./core/streaming.js";
 //# sourceMappingURL=streaming.d.ts.map

package/streaming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,qBAAa,MAAM,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,QAAQ;IAE/B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAsDlD"}
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""}