@reminix/sdk 0.10.0 → 0.11.0

package/src/resources/conversations.ts

@@ -0,0 +1,146 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { Cursor, type CursorParams, PagePromise } from '../core/pagination';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Conversations extends APIResource {
+  /**
+   * Get details of a specific conversation including all messages.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<ConversationRetrieveResponse> {
+    return this._client.get(path`/conversations/${id}`, options);
+  }
+
+  /**
+   * List conversations for the project with optional filtering.
+   *
+   * Conversations store chat history between users and agents. Use filters to narrow
+   * down results by agent name or identity fields.
+   *
+   * **Filters:**
+   *
+   * - `agent_name`: Filter by agent name
+   * - `identity.*`: Filter by identity fields (e.g., identity.user_id=user_123)
+   */
+  list(
+    query: ConversationListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<ConversationsCursor, Conversation> {
+    return this._client.getAPIList('/conversations', Cursor<Conversation>, { query, ...options });
+  }
+
+  /**
+   * Delete a conversation and all its messages. This action cannot be undone.
+   */
+  delete(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/conversations/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export type ConversationsCursor = Cursor<Conversation>;
+
+export interface Conversation {
+  /**
+   * Unique conversation ID
+   */
+  id: string;
+
+  /**
+   * Agent name
+   */
+  agentName: string;
+
+  /**
+   * When the conversation was created
+   */
+  createdAt: string;
+
+  /**
+   * Identity fields for conversation scoping
+   */
+  identity: { [key: string]: unknown };
+
+  /**
+   * Project ID
+   */
+  projectId: string;
+
+  /**
+   * When the conversation was last updated
+   */
+  updatedAt: string;
+}
+
+export interface ConversationRetrieveResponse extends Conversation {
+  /**
+   * Conversation messages
+   */
+  messages: Array<ConversationRetrieveResponse.Message>;
+}
+
+export namespace ConversationRetrieveResponse {
+  export interface Message {
+    /**
+     * Unique message ID
+     */
+    id: string;
+
+    /**
+     * Message content
+     */
+    content: string | null;
+
+    /**
+     * Conversation ID
+     */
+    conversationId: string;
+
+    /**
+     * When the message was created
+     */
+    createdAt: string;
+
+    /**
+     * Tool name (for tool messages)
+     */
+    name: string | null;
+
+    /**
+     * Message role
+     */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+
+    /**
+     * Tool call ID (for tool messages)
+     */
+    toolCallId: string | null;
+
+    /**
+     * Tool calls (for assistant messages)
+     */
+    toolCalls?: unknown;
+  }
+}
+
+export interface ConversationListParams extends CursorParams {
+  /**
+   * Filter by agent name
+   */
+  agent_name?: string;
+}
+
+export declare namespace Conversations {
+  export {
+    type Conversation as Conversation,
+    type ConversationRetrieveResponse as ConversationRetrieveResponse,
+    type ConversationsCursor as ConversationsCursor,
+    type ConversationListParams as ConversationListParams,
+  };
+}

package/src/resources/execution-logs.ts

@@ -0,0 +1,125 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { Cursor, type CursorParams, PagePromise } from '../core/pagination';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class ExecutionLogs extends APIResource {
+  /**
+   * Get details of a specific execution log by ID.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<ExecutionLog> {
+    return this._client.get(path`/execution-logs/${id}`, options);
+  }
+
+  /**
+   * List execution logs for the project with optional filtering.
+   *
+   * Execution logs track all agent invocations, chats, and tool executions. Use
+   * filters to narrow down results by type, source, name, or status.
+   *
+   * **Filters:**
+   *
+   * - `type`: Filter by execution type (agent_execute, tool_execute)
+   * - `source`: Filter by request source (api, cli, dashboard, widget, sdk)
+   * - `name`: Filter by agent or tool name
+   * - `status`: Filter by result status (success, error, timeout)
+   */
+  list(
+    query: ExecutionLogListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<ExecutionLogsCursor, ExecutionLog> {
+    return this._client.getAPIList('/execution-logs', Cursor<ExecutionLog>, { query, ...options });
+  }
+}
+
+export type ExecutionLogsCursor = Cursor<ExecutionLog>;
+
+export interface ExecutionLog {
+  /**
+   * Unique execution log ID
+   */
+  id: string;
+
+  /**
+   * When the execution occurred
+   */
+  createdAt: string;
+
+  /**
+   * Execution duration in milliseconds
+   */
+  durationMs: number | null;
+
+  /**
+   * Error message (null for success)
+   */
+  error: string | null;
+
+  /**
+   * Agent or tool name
+   */
+  name: string;
+
+  /**
+   * Project ID
+   */
+  projectId: string;
+
+  /**
+   * Where the request originated
+   */
+  source: 'api' | 'cli' | 'dashboard' | 'widget' | 'sdk';
+
+  /**
+   * Execution result status
+   */
+  status: 'success' | 'error' | 'timeout';
+
+  /**
+   * Type of execution
+   */
+  type: 'agent_execute' | 'agent_chat' | 'tool_execute';
+
+  /**
+   * Input parameters
+   */
+  input?: unknown;
+
+  /**
+   * Output from execution (null for errors)
+   */
+  output?: unknown;
+}
+
+export interface ExecutionLogListParams extends CursorParams {
+  /**
+   * Filter by agent or tool name
+   */
+  name?: string;
+
+  /**
+   * Filter by request source
+   */
+  source?: 'api' | 'cli' | 'dashboard' | 'widget' | 'sdk';
+
+  /**
+   * Filter by execution status
+   */
+  status?: 'success' | 'error' | 'timeout';
+
+  /**
+   * Filter by execution type
+   */
+  type?: 'agent_execute' | 'agent_chat' | 'tool_execute';
+}
+
+export declare namespace ExecutionLogs {
+  export {
+    type ExecutionLog as ExecutionLog,
+    type ExecutionLogsCursor as ExecutionLogsCursor,
+    type ExecutionLogListParams as ExecutionLogListParams,
+  };
+}

package/src/resources/index.ts

@@ -2,17 +2,41 @@
 
 export {
   Agents,
+  type Agent,
+  type AgentConfig,
   type ChatMessage,
-  type Context,
   type StreamChunk,
   type AgentChatResponse,
-  type AgentInvokeResponse,
+  type AgentExecuteResponse,
+  type AgentListParams,
   type AgentChatParams,
   type AgentChatParamsNonStreaming,
   type AgentChatParamsStreaming,
-  type AgentInvokeParams,
-  type AgentInvokeParamsNonStreaming,
-  type AgentInvokeParamsStreaming,
+  type AgentExecuteParams,
+  type AgentExecuteParamsNonStreaming,
+  type AgentExecuteParamsStreaming,
+  type AgentsCursor,
 } from './agents';
 export { ClientTokens, type ClientTokenCreateResponse, type ClientTokenCreateParams } from './client-tokens';
-export { Projects, type PaginationCursor, type Project } from './projects';
+export {
+  Conversations,
+  type Conversation,
+  type ConversationRetrieveResponse,
+  type ConversationListParams,
+  type ConversationsCursor,
+} from './conversations';
+export {
+  ExecutionLogs,
+  type ExecutionLog,
+  type ExecutionLogListParams,
+  type ExecutionLogsCursor,
+} from './execution-logs';
+export { Projects, type Project } from './projects';
+export {
+  Tools,
+  type Tool,
+  type ToolExecuteResponse,
+  type ToolListParams,
+  type ToolExecuteParams,
+  type ToolsCursor,
+} from './tools';

package/src/resources/projects.ts

@@ -24,18 +24,6 @@ export class Projects extends APIResource {
   }
 }
 
-export interface PaginationCursor {
-  /**
-   * Whether there are more results available
-   */
-  hasMore: boolean;
-
-  /**
-   * Cursor for the next page of results. Null if there are no more results.
-   */
-  nextCursor: string | null;
-}
-
 export interface Project {
   /**
    * Unique identifier for the project
@@ -96,5 +84,5 @@ export namespace Project {
 }
 
 export declare namespace Projects {
-  export { type PaginationCursor as PaginationCursor, type Project as Project };
+  export { type Project as Project };
 }

package/src/resources/tools.ts

@@ -0,0 +1,192 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { Cursor, type CursorParams, PagePromise } from '../core/pagination';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Tools extends APIResource {
+  /**
+   * Get details of a specific tool by name.
+   *
+   * @example
+   * ```ts
+   * const tool = await client.tools.retrieve('x');
+   * ```
+   */
+  retrieve(name: string, options?: RequestOptions): APIPromise<Tool> {
+    return this._client.get(path`/tools/${name}`, options);
+  }
+
+  /**
+   * List all tools in the project with optional filtering by type and status. Tools
+   * are automatically discovered from deployments.
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const tool of client.tools.list()) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    query: ToolListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<ToolsCursor, Tool> {
+    return this._client.getAPIList('/tools', Cursor<Tool>, { query, ...options });
+  }
+
+  /**
+   * Execute a tool with the provided input parameters.
+   *
+   * **Timeout:** Tool executions have a 60-second timeout. If the tool takes longer
+   * to respond, you will receive a 504 Gateway Timeout error.
+   *
+   * **Use cases:**
+   *
+   * - Calling custom tools from your deployment
+   * - Executing utility functions
+   * - Integrating with external services via tools
+   *
+   * @example
+   * ```ts
+   * const response = await client.tools.execute('x', {
+   *   input: { name: 'World', greeting: 'Hello' },
+   * });
+   * ```
+   */
+  execute(name: string, body: ToolExecuteParams, options?: RequestOptions): APIPromise<ToolExecuteResponse> {
+    return this._client.post(path`/tools/${name}/execute`, { body, ...options });
+  }
+}
+
+export type ToolsCursor = Cursor<Tool>;
+
+export interface Tool {
+  /**
+   * Unique tool ID
+   */
+  id: string;
+
+  /**
+   * Creation timestamp
+   */
+  createdAt: string;
+
+  /**
+   * User who created the tool (for managed tools)
+   */
+  createdBy: string | null;
+
+  /**
+   * Tool description
+   */
+  description: string | null;
+
+  /**
+   * When the tool was discovered
+   */
+  discoveredAt: string | null;
+
+  /**
+   * Tool name
+   */
+  name: string;
+
+  /**
+   * JSON Schema for agent input parameters
+   */
+  output: Tool.Output | null;
+
+  /**
+   * JSON Schema for agent input parameters
+   */
+  parameters: Tool.Parameters | null;
+
+  /**
+   * Project ID
+   */
+  projectId: string;
+
+  /**
+   * Tool status
+   */
+  status: 'active' | 'inactive';
+
+  /**
+   * Tool type: "managed" for platform-provided, or "{language}" for custom tools
+   * (e.g., "python", "typescript")
+   */
+  type: string;
+
+  /**
+   * Last update timestamp
+   */
+  updatedAt: string;
+}
+
+export namespace Tool {
+  /**
+   * JSON Schema for agent input parameters
+   */
+  export interface Output {
+    type: string;
+
+    properties?: { [key: string]: unknown };
+
+    required?: Array<string>;
+
+    [k: string]: unknown;
+  }
+
+  /**
+   * JSON Schema for agent input parameters
+   */
+  export interface Parameters {
+    type: string;
+
+    properties?: { [key: string]: unknown };
+
+    required?: Array<string>;
+
+    [k: string]: unknown;
+  }
+}
+
+export interface ToolExecuteResponse {
+  /**
+   * Output from the tool execution.
+   */
+  output?: unknown;
+}
+
+export interface ToolListParams extends CursorParams {
+  /**
+   * Filter by tool status
+   */
+  status?: 'active' | 'inactive';
+
+  /**
+   * Filter by tool type (python, typescript)
+   */
+  type?: string;
+}
+
+export interface ToolExecuteParams {
+  /**
+   * Input parameters for the tool. Structure depends on tool definition.
+   */
+  input: { [key: string]: unknown };
+}
+
+export declare namespace Tools {
+  export {
+    type Tool as Tool,
+    type ToolExecuteResponse as ToolExecuteResponse,
+    type ToolsCursor as ToolsCursor,
+    type ToolListParams as ToolListParams,
+    type ToolExecuteParams as ToolExecuteParams,
+  };
+}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.10.0'; // x-release-please-version
+export const VERSION = '0.11.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.10.0";
+export declare const VERSION = "0.11.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.10.0";
+export declare const VERSION = "0.11.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.10.0'; // x-release-please-version
+exports.VERSION = '0.11.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.10.0'; // x-release-please-version
+export const VERSION = '0.11.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map