@tambo-ai/typescript-sdk 0.80.0 → 0.83.0

package/src/resources/threads/threads.ts

@@ -0,0 +1,536 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as ThreadsAPI from './threads';
+import * as Shared from '../shared';
+import * as MessagesAPI from './messages';
+import {
+  MessageGetParams,
+  MessageGetResponse,
+  MessageListParams,
+  MessageListResponse,
+  Messages,
+} from './messages';
+import * as RunsAPI from './runs';
+import {
+  InputMessage,
+  RunCreateParams,
+  RunDeleteParams,
+  RunDeleteResponse,
+  RunRunParams,
+  Runs,
+} from './runs';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Threads extends APIResource {
+  messages: MessagesAPI.Messages = new MessagesAPI.Messages(this._client);
+  runs: RunsAPI.Runs = new RunsAPI.Runs(this._client);
+
+  /**
+   * Create a new empty thread. Note: initialMessages is not supported yet; create
+   * the thread first, then add messages via runs/message endpoints.
+   *
+   * @example
+   * ```ts
+   * const thread = await client.threads.create();
+   * ```
+   */
+  create(body: ThreadCreateParams, options?: RequestOptions): APIPromise<ThreadCreateResponse> {
+    return this._client.post('/v1/threads', { body, ...options });
+  }
+
+  /**
+   * Get a thread by ID with all its messages. The thread must belong to the
+   * authenticated project.
+   *
+   * @example
+   * ```ts
+   * const thread = await client.threads.retrieve(
+   *   'thr_abc123xyz',
+   * );
+   * ```
+   */
+  retrieve(threadID: string, options?: RequestOptions): APIPromise<ThreadRetrieveResponse> {
+    return this._client.get(path`/v1/threads/${threadID}`, options);
+  }
+
+  /**
+   * List all threads for the authenticated project. Supports cursor-based pagination
+   * and filtering by context key.
+   *
+   * @example
+   * ```ts
+   * const threads = await client.threads.list();
+   * ```
+   */
+  list(
+    query: ThreadListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ThreadListResponse> {
+    return this._client.get('/v1/threads', { query, ...options });
+  }
+
+  /**
+   * Delete a thread and all its messages. This action cannot be undone.
+   *
+   * @example
+   * ```ts
+   * await client.threads.delete('thr_abc123xyz');
+   * ```
+   */
+  delete(threadID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v1/threads/${threadID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface ComponentContent {
+  /**
+   * Unique identifier for this component instance
+   */
+  id: string;
+
+  /**
+   * Name of the component to render
+   */
+  name: string;
+
+  /**
+   * Props to pass to the component
+   */
+  props: unknown;
+
+  /**
+   * Content block type identifier
+   */
+  type: 'component';
+
+  /**
+   * Current state of the component
+   */
+  state?: unknown;
+}
+
+export interface ResourceContent {
+  /**
+   * Resource data containing URI, text, or blob
+   */
+  resource: Shared.Resource;
+
+  /**
+   * Content block type identifier
+   */
+  type: 'resource';
+}
+
+export interface RunError {
+  /**
+   * Error message
+   */
+  message: string;
+
+  /**
+   * Error code
+   */
+  code?: string;
+}
+
+export interface TextContent {
+  /**
+   * The text content
+   */
+  text: string;
+
+  /**
+   * Content block type identifier
+   */
+  type: 'text';
+}
+
+export interface ToolResultContent {
+  /**
+   * Result content (text or resource blocks)
+   */
+  content: Array<TextContent | ResourceContent>;
+
+  /**
+   * ID of the tool call this result responds to
+   */
+  toolUseId: string;
+
+  /**
+   * Content block type identifier
+   */
+  type: 'tool_result';
+
+  /**
+   * Whether the tool call resulted in an error
+   */
+  isError?: boolean;
+}
+
+export interface ToolUseContent {
+  /**
+   * Unique identifier for this tool call
+   */
+  id: string;
+
+  /**
+   * Input arguments for the tool
+   */
+  input: unknown;
+
+  /**
+   * Name of the tool being called
+   */
+  name: string;
+
+  /**
+   * Content block type identifier
+   */
+  type: 'tool_use';
+}
+
+export interface ThreadCreateResponse {
+  /**
+   * Unique identifier for this thread
+   */
+  id: string;
+
+  /**
+   * When the thread was created (ISO 8601)
+   */
+  createdAt: string;
+
+  /**
+   * Project this thread belongs to
+   */
+  projectId: string;
+
+  /**
+   * Current run status: idle (no run), waiting (run started, awaiting content),
+   * streaming (receiving content)
+   */
+  runStatus: 'idle' | 'waiting' | 'streaming';
+
+  /**
+   * When the thread was last updated (ISO 8601)
+   */
+  updatedAt: string;
+
+  /**
+   * Optional context key for thread organization
+   */
+  contextKey?: string;
+
+  /**
+   * ID of the currently active run (when not idle)
+   */
+  currentRunId?: string;
+
+  /**
+   * ID of the last completed run. Required as previousRunId when continuing after
+   * tool calls.
+   */
+  lastCompletedRunId?: string;
+
+  /**
+   * Whether the last run was cancelled
+   */
+  lastRunCancelled?: boolean;
+
+  /**
+   * Error information from the last run
+   */
+  lastRunError?: RunError;
+
+  /**
+   * Additional metadata
+   */
+  metadata?: unknown;
+
+  /**
+   * Tool call IDs awaiting client-side results. If non-empty, next run must provide
+   * tool_result content with previousRunId set.
+   */
+  pendingToolCallIds?: Array<string>;
+
+  /**
+   * Human-readable status message (e.g., 'Fetching weather data...')
+   */
+  statusMessage?: string;
+}
+
+export interface ThreadRetrieveResponse {
+  /**
+   * Unique identifier for this thread
+   */
+  id: string;
+
+  /**
+   * When the thread was created (ISO 8601)
+   */
+  createdAt: string;
+
+  /**
+   * Messages in this thread
+   */
+  messages: Array<ThreadRetrieveResponse.Message>;
+
+  /**
+   * Project this thread belongs to
+   */
+  projectId: string;
+
+  /**
+   * Current run status: idle (no run), waiting (run started, awaiting content),
+   * streaming (receiving content)
+   */
+  runStatus: 'idle' | 'waiting' | 'streaming';
+
+  /**
+   * When the thread was last updated (ISO 8601)
+   */
+  updatedAt: string;
+
+  /**
+   * Optional context key for thread organization
+   */
+  contextKey?: string;
+
+  /**
+   * ID of the currently active run (when not idle)
+   */
+  currentRunId?: string;
+
+  /**
+   * ID of the last completed run. Required as previousRunId when continuing after
+   * tool calls.
+   */
+  lastCompletedRunId?: string;
+
+  /**
+   * Whether the last run was cancelled
+   */
+  lastRunCancelled?: boolean;
+
+  /**
+   * Error information from the last run
+   */
+  lastRunError?: RunError;
+
+  /**
+   * Additional metadata
+   */
+  metadata?: unknown;
+
+  /**
+   * Tool call IDs awaiting client-side results. If non-empty, next run must provide
+   * tool_result content with previousRunId set.
+   */
+  pendingToolCallIds?: Array<string>;
+
+  /**
+   * Human-readable status message (e.g., 'Fetching weather data...')
+   */
+  statusMessage?: string;
+}
+
+export namespace ThreadRetrieveResponse {
+  export interface Message {
+    /**
+     * Unique identifier for this message
+     */
+    id: string;
+
+    /**
+     * Content blocks in this message
+     */
+    content: Array<
+      | ThreadsAPI.TextContent
+      | ThreadsAPI.ResourceContent
+      | ThreadsAPI.ToolUseContent
+      | ThreadsAPI.ToolResultContent
+      | ThreadsAPI.ComponentContent
+    >;
+
+    /**
+     * Message role
+     */
+    role: 'user' | 'assistant' | 'system';
+
+    /**
+     * When the message was created (ISO 8601)
+     */
+    createdAt?: string;
+
+    /**
+     * Additional metadata
+     */
+    metadata?: unknown;
+  }
+}
+
+export interface ThreadListResponse {
+  /**
+   * Whether there are more results
+   */
+  hasMore: boolean;
+
+  /**
+   * List of threads
+   */
+  threads: Array<ThreadListResponse.Thread>;
+
+  /**
+   * Cursor for the next page of results
+   */
+  nextCursor?: string;
+}
+
+export namespace ThreadListResponse {
+  export interface Thread {
+    /**
+     * Unique identifier for this thread
+     */
+    id: string;
+
+    /**
+     * When the thread was created (ISO 8601)
+     */
+    createdAt: string;
+
+    /**
+     * Project this thread belongs to
+     */
+    projectId: string;
+
+    /**
+     * Current run status: idle (no run), waiting (run started, awaiting content),
+     * streaming (receiving content)
+     */
+    runStatus: 'idle' | 'waiting' | 'streaming';
+
+    /**
+     * When the thread was last updated (ISO 8601)
+     */
+    updatedAt: string;
+
+    /**
+     * Optional context key for thread organization
+     */
+    contextKey?: string;
+
+    /**
+     * ID of the currently active run (when not idle)
+     */
+    currentRunId?: string;
+
+    /**
+     * ID of the last completed run. Required as previousRunId when continuing after
+     * tool calls.
+     */
+    lastCompletedRunId?: string;
+
+    /**
+     * Whether the last run was cancelled
+     */
+    lastRunCancelled?: boolean;
+
+    /**
+     * Error information from the last run
+     */
+    lastRunError?: ThreadsAPI.RunError;
+
+    /**
+     * Additional metadata
+     */
+    metadata?: unknown;
+
+    /**
+     * Tool call IDs awaiting client-side results. If non-empty, next run must provide
+     * tool_result content with previousRunId set.
+     */
+    pendingToolCallIds?: Array<string>;
+
+    /**
+     * Human-readable status message (e.g., 'Fetching weather data...')
+     */
+    statusMessage?: string;
+  }
+}
+
+export interface ThreadCreateParams {
+  /**
+   * Optional context key for thread organization
+   */
+  contextKey?: string;
+
+  /**
+   * Initial messages to seed the thread with
+   */
+  initialMessages?: Array<RunsAPI.InputMessage>;
+
+  /**
+   * Additional metadata to attach to the thread
+   */
+  metadata?: unknown;
+}
+
+export interface ThreadListParams {
+  /**
+   * Filter by context key
+   */
+  contextKey?: string;
+
+  /**
+   * Cursor for pagination
+   */
+  cursor?: string;
+
+  /**
+   * Maximum number of threads to return
+   */
+  limit?: string;
+}
+
+Threads.Messages = Messages;
+Threads.Runs = Runs;
+
+export declare namespace Threads {
+  export {
+    type ComponentContent as ComponentContent,
+    type ResourceContent as ResourceContent,
+    type RunError as RunError,
+    type TextContent as TextContent,
+    type ToolResultContent as ToolResultContent,
+    type ToolUseContent as ToolUseContent,
+    type ThreadCreateResponse as ThreadCreateResponse,
+    type ThreadRetrieveResponse as ThreadRetrieveResponse,
+    type ThreadListResponse as ThreadListResponse,
+    type ThreadCreateParams as ThreadCreateParams,
+    type ThreadListParams as ThreadListParams,
+  };
+
+  export {
+    Messages as Messages,
+    type MessageListResponse as MessageListResponse,
+    type MessageGetResponse as MessageGetResponse,
+    type MessageListParams as MessageListParams,
+    type MessageGetParams as MessageGetParams,
+  };
+
+  export {
+    Runs as Runs,
+    type InputMessage as InputMessage,
+    type RunDeleteResponse as RunDeleteResponse,
+    type RunCreateParams as RunCreateParams,
+    type RunDeleteParams as RunDeleteParams,
+    type RunRunParams as RunRunParams,
+  };
+}

package/src/resources/threads.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './threads/index';

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.80.0'; // x-release-please-version
+export const VERSION = '0.83.0'; // x-release-please-version

package/version.d.mts

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

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.80.0";
+export declare const VERSION = "0.83.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.80.0'; // x-release-please-version
+exports.VERSION = '0.83.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

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