@reminix/sdk 0.9.0 → 0.11.0

package/src/client.ts

@@ -13,26 +13,51 @@ import * as Shims from './internal/shims';
 import * as Opts from './internal/request-options';
 import { VERSION } from './version';
 import * as Errors from './core/error';
+import * as Pagination from './core/pagination';
+import { AbstractPage, type CursorParams, CursorResponse } from './core/pagination';
 import * as Uploads from './core/uploads';
 import * as API from './resources/index';
 import { APIPromise } from './core/api-promise';
 import {
+  Agent,
   AgentChatParams,
   AgentChatParamsNonStreaming,
   AgentChatParamsStreaming,
   AgentChatResponse,
-  AgentInvokeParams,
-  AgentInvokeParamsNonStreaming,
-  AgentInvokeParamsStreaming,
-  AgentInvokeResponse,
+  AgentConfig,
+  AgentExecuteParams,
+  AgentExecuteParamsNonStreaming,
+  AgentExecuteParamsStreaming,
+  AgentExecuteResponse,
+  AgentListParams,
   Agents,
-  Context,
+  AgentsCursor,
+  ChatMessage,
   StreamChunk,
 } from './resources/agents';
 import { ClientTokenCreateParams, ClientTokenCreateResponse, ClientTokens } from './resources/client-tokens';
-import { Deployments } from './resources/deployments';
-import { ProjectRetrieveCurrentResponse, Projects } from './resources/projects';
-import { Secrets } from './resources/secrets';
+import {
+  Conversation,
+  ConversationListParams,
+  ConversationRetrieveResponse,
+  Conversations,
+  ConversationsCursor,
+} from './resources/conversations';
+import {
+  ExecutionLog,
+  ExecutionLogListParams,
+  ExecutionLogs,
+  ExecutionLogsCursor,
+} from './resources/execution-logs';
+import { Project, Projects } from './resources/projects';
+import {
+  Tool,
+  ToolExecuteParams,
+  ToolExecuteResponse,
+  ToolListParams,
+  Tools,
+  ToolsCursor,
+} from './resources/tools';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
@@ -48,7 +73,7 @@ import { isEmptyObj } from './internal/utils/values';
 
 export interface ClientOptions {
   /**
-   * Project API key or Personal Access Token (PAT). When using PAT, include X-Project header.
+   * API Key or Personal Access Token (PAT). When using PAT, include X-Project header.
    */
   apiKey?: string | undefined;
 
@@ -498,6 +523,25 @@ export class Reminix {
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
 
+  getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(
+    path: string,
+    Page: new (...args: any[]) => PageClass,
+    opts?: RequestOptions,
+  ): Pagination.PagePromise<PageClass, Item> {
+    return this.requestAPIList(Page, { method: 'get', path, ...opts });
+  }
+
+  requestAPIList<
+    Item = unknown,
+    PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>,
+  >(
+    Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass,
+    options: FinalRequestOptions,
+  ): Pagination.PagePromise<PageClass, Item> {
+    const request = this.makeRequest(options, null, undefined);
+    return new Pagination.PagePromise<PageClass, Item>(this as any as Reminix, request, Page);
+  }
+
   async fetchWithTimeout(
     url: RequestInfo,
     init: RequestInit | undefined,
@@ -662,6 +706,7 @@ export class Reminix {
         'X-Stainless-Retry-Count': String(retryCount),
         ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
         ...getPlatformHeaders(),
+        'X-Reminix-Source': 'sdk',
       },
       await this.authHeaders(options),
       this._options.defaultHeaders,
@@ -732,43 +777,72 @@ export class Reminix {
 
   projects: API.Projects = new API.Projects(this);
   agents: API.Agents = new API.Agents(this);
-  secrets: API.Secrets = new API.Secrets(this);
-  deployments: API.Deployments = new API.Deployments(this);
+  tools: API.Tools = new API.Tools(this);
   clientTokens: API.ClientTokens = new API.ClientTokens(this);
+  executionLogs: API.ExecutionLogs = new API.ExecutionLogs(this);
+  conversations: API.Conversations = new API.Conversations(this);
 }
 
 Reminix.Projects = Projects;
 Reminix.Agents = Agents;
-Reminix.Secrets = Secrets;
-Reminix.Deployments = Deployments;
+Reminix.Tools = Tools;
 Reminix.ClientTokens = ClientTokens;
+Reminix.ExecutionLogs = ExecutionLogs;
+Reminix.Conversations = Conversations;
 
 export declare namespace Reminix {
   export type RequestOptions = Opts.RequestOptions;
 
-  export { Projects as Projects, type ProjectRetrieveCurrentResponse as ProjectRetrieveCurrentResponse };
+  export import Cursor = Pagination.Cursor;
+  export { type CursorParams as CursorParams, type CursorResponse as CursorResponse };
+
+  export { Projects as Projects, type Project as Project };
 
   export {
     Agents as Agents,
-    type Context as Context,
+    type Agent as Agent,
+    type AgentConfig as AgentConfig,
+    type ChatMessage as ChatMessage,
     type StreamChunk as StreamChunk,
     type AgentChatResponse as AgentChatResponse,
-    type AgentInvokeResponse as AgentInvokeResponse,
+    type AgentExecuteResponse as AgentExecuteResponse,
+    type AgentsCursor as AgentsCursor,
+    type AgentListParams as AgentListParams,
     type AgentChatParams as AgentChatParams,
     type AgentChatParamsNonStreaming as AgentChatParamsNonStreaming,
     type AgentChatParamsStreaming as AgentChatParamsStreaming,
-    type AgentInvokeParams as AgentInvokeParams,
-    type AgentInvokeParamsNonStreaming as AgentInvokeParamsNonStreaming,
-    type AgentInvokeParamsStreaming as AgentInvokeParamsStreaming,
+    type AgentExecuteParams as AgentExecuteParams,
+    type AgentExecuteParamsNonStreaming as AgentExecuteParamsNonStreaming,
+    type AgentExecuteParamsStreaming as AgentExecuteParamsStreaming,
   };
 
-  export { Secrets as Secrets };
-
-  export { Deployments as Deployments };
+  export {
+    Tools as Tools,
+    type Tool as Tool,
+    type ToolExecuteResponse as ToolExecuteResponse,
+    type ToolsCursor as ToolsCursor,
+    type ToolListParams as ToolListParams,
+    type ToolExecuteParams as ToolExecuteParams,
+  };
 
   export {
     ClientTokens as ClientTokens,
     type ClientTokenCreateResponse as ClientTokenCreateResponse,
     type ClientTokenCreateParams as ClientTokenCreateParams,
   };
+
+  export {
+    ExecutionLogs as ExecutionLogs,
+    type ExecutionLog as ExecutionLog,
+    type ExecutionLogsCursor as ExecutionLogsCursor,
+    type ExecutionLogListParams as ExecutionLogListParams,
+  };
+
+  export {
+    Conversations as Conversations,
+    type Conversation as Conversation,
+    type ConversationRetrieveResponse as ConversationRetrieveResponse,
+    type ConversationsCursor as ConversationsCursor,
+    type ConversationListParams as ConversationListParams,
+  };
 }

package/src/core/pagination.ts

@@ -0,0 +1,165 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { ReminixError } from './error';
+import { FinalRequestOptions } from '../internal/request-options';
+import { defaultParseResponse } from '../internal/parse';
+import { type Reminix } from '../client';
+import { APIPromise } from './api-promise';
+import { type APIResponseProps } from '../internal/parse';
+import { maybeObj } from '../internal/utils/values';
+
+export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;
+
+export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #client: Reminix;
+  protected options: FinalRequestOptions;
+
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: Reminix, response: Response, body: unknown, options: FinalRequestOptions) {
+    this.#client = client;
+    this.options = options;
+    this.response = response;
+    this.body = body;
+  }
+
+  abstract nextPageRequestOptions(): PageRequestOptions | null;
+
+  abstract getPaginatedItems(): Item[];
+
+  hasNextPage(): boolean {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageRequestOptions() != null;
+  }
+
+  async getNextPage(): Promise<this> {
+    const nextOptions = this.nextPageRequestOptions();
+    if (!nextOptions) {
+      throw new ReminixError(
+        'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+      );
+    }
+
+    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
+  }
+
+  async *iterPages(): AsyncGenerator<this> {
+    let page: this = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+}
+
+/**
+ * This subclass of Promise will resolve to an instantiated Page once the request completes.
+ *
+ * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
+ *
+ *    for await (const item of client.items.list()) {
+ *      console.log(item)
+ *    }
+ */
+export class PagePromise<
+    PageClass extends AbstractPage<Item>,
+    Item = ReturnType<PageClass['getPaginatedItems']>[number],
+  >
+  extends APIPromise<PageClass>
+  implements AsyncIterable<Item>
+{
+  constructor(
+    client: Reminix,
+    request: Promise<APIResponseProps>,
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+  ) {
+    super(
+      client,
+      request,
+      async (client, props) =>
+        new Page(client, props.response, await defaultParseResponse(client, props), props.options),
+    );
+  }
+
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+}
+
+export interface CursorResponse<Item> {
+  data: Array<Item>;
+
+  nextCursor: string | null;
+
+  hasMore: boolean;
+}
+
+export interface CursorParams {
+  cursor?: string;
+
+  limit?: number;
+}
+
+export class Cursor<Item> extends AbstractPage<Item> implements CursorResponse<Item> {
+  data: Array<Item>;
+
+  nextCursor: string | null;
+
+  hasMore: boolean;
+
+  constructor(client: Reminix, response: Response, body: CursorResponse<Item>, options: FinalRequestOptions) {
+    super(client, response, body, options);
+
+    this.data = body.data || [];
+    this.nextCursor = body.nextCursor || null;
+    this.hasMore = body.hasMore || false;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.data ?? [];
+  }
+
+  override hasNextPage(): boolean {
+    if (this.hasMore === false) {
+      return false;
+    }
+
+    return super.hasNextPage();
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextCursor;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        cursor,
+      },
+    };
+  }
+}

package/src/index.ts

@@ -5,6 +5,7 @@ export { Reminix as default } from './client';
 export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
 export { Reminix, type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
 export {
   ReminixError,
   APIError,

package/src/pagination.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';