@gpt-platform/client 0.10.5 → 0.11.0

package/dist/namespaces/threads.d.ts

@@ -0,0 +1,596 @@
+import type { ChatThread as Thread, ChatMessage as Message, ChatMessageFeedback } from "../_internal/types.gen";
+/** Re-export the generated feedback type under the short alias. */
+export type MessageFeedback = ChatMessageFeedback;
+/** Attributes accepted when creating a new thread. */
+export type CreateThreadAttributes = {
+    title?: string;
+    agent_id?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating an existing thread (PATCH semantics). */
+export type UpdateThreadAttributes = {
+    title?: string;
+    context_summary?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+/** Optional extra attributes when sending a message (beyond content). */
+export type SendMessageAttributes = {
+    role?: string;
+    metadata?: Record<string, unknown>;
+    attachments?: unknown[];
+    [key: string]: unknown;
+};
+/** Attributes for inserting a pre-generated message directly (no inference). */
+export type InsertMessageAttributes = {
+    /** Message role. Use 'assistant' for injecting agent responses. */
+    role: "user" | "assistant" | "system" | "tool";
+    /** Optional metadata to attach to the message. */
+    metadata?: Record<string, unknown>;
+};
+/** Attributes for rating a message (thumbs up/down). */
+export type RateMessageAttributes = {
+    /** Thumbs up or down. */
+    rating: "up" | "down";
+    /** Optional comment explaining the rating. */
+    comment?: string;
+};
+/** Attributes for updating a message (PATCH semantics). */
+export type UpdateMessageAttributes = {
+    role?: string;
+    content?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+import type { StreamMessageChunk, StreamOptions } from "../streaming";
+/**
+ * Creates the `threads` namespace, providing methods for managing conversation
+ * threads and their messages.
+ *
+ * A thread is a persistent, ordered sequence of messages between a user and an
+ * AI agent. Threads support forking (branching a conversation into a new copy),
+ * archiving (soft-deletion with restore), AI-generated summaries, and export in
+ * multiple formats. Messages within a thread can be sent synchronously or
+ * streamed in real time via Server-Sent Events (SSE).
+ *
+ * ## Real-time Updates (WebSocket)
+ *
+ * Connect to `chat_thread:{threadId}` via `client.channels` to receive:
+ * - `new_message` — When a new message is added to the thread
+ * - `thread_updated` — When thread metadata changes (archived, summarized)
+ *
+ * @param rb - The `RequestBuilder` instance bound to the authenticated client.
+ * @returns An object containing all thread-related methods and the `messages`
+ *   sub-namespace.
+ *
+ * @example
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ * const thread = await client.threads.create({ title: 'Support conversation' });
+ * console.log(`Thread created: ${thread.id}`);
+ */
+export declare function createThreadsNamespace(rb: RequestBuilder): {
+    /**
+     * Permanently deletes a thread and all of its messages.
+     *
+     * This action is irreversible. All messages, attachments, and metadata
+     * associated with the thread are removed. If you only need to hide the
+     * thread from default listings without losing the history, use
+     * {@link archive} instead.
+     *
+     * @param id - The UUID of the thread to delete.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to `true` on successful deletion.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * await client.threads.delete('thr_01HXYZ...');
+     */
+    delete: (id: string, options?: RequestOptions) => Promise<true>;
+    /**
+     * Lists threads in the workspace with optional pagination controls.
+     *
+     * By default only non-archived threads are returned. Use {@link listAll}
+     * to fetch every thread across all pages automatically.
+     *
+     * @param options - Optional pagination and request options.
+     * @param options.page - The page number to fetch (1-based). Defaults to 1.
+     * @param options.pageSize - Number of threads per page. Defaults to the server default.
+     * @returns A promise that resolves to an array of `Thread` objects on the requested page.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     *
+     * // Second page, 20 threads
+     * const page2 = await client.threads.list({ page: 2, pageSize: 20 });
+     */
+    list: (options?: {
+        page?: number;
+        pageSize?: number;
+    } & RequestOptions) => Promise<Thread[]>;
+    /**
+     * Lists only the calling user's threads within their current workspace.
+     *
+     * Unlike {@link list} which returns all threads in the workspace (for admin
+     * visibility), `listMine` scopes results to threads owned by the
+     * authenticated user. This is the recommended method for end-user UIs.
+     *
+     * @param options - Optional pagination and request options.
+     * @returns A promise that resolves to an array of the user's `Thread` objects.
+     *
+     * @example
+     * ```typescript
+     * const myThreads = await client.threads.listMine();
+     * myThreads.forEach(t => console.log(t.attributes.title));
+     * ```
+     */
+    listMine: (options?: {
+        page?: number;
+        pageSize?: number;
+    } & RequestOptions) => Promise<Thread[]>;
+    /**
+     * Fetches all threads in the workspace by transparently paginating through
+     * every page until exhausted.
+     *
+     * This is a convenience wrapper that handles page management automatically.
+     * For workspaces with very many threads, prefer {@link list} with explicit
+     * pagination to control memory usage.
+     *
+     * @param options - Optional request options.
+     * @returns A promise that resolves to a flat array of every `Thread` in the workspace.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const allThreads = await client.threads.listAll();
+     * console.log(`Total threads: ${allThreads.length}`);
+     */
+    listAll: (options?: RequestOptions) => Promise<Thread[]>;
+    /**
+     * Creates a new conversation thread.
+     *
+     * Threads are the container for messages between a user and an AI agent.
+     * You can optionally associate the thread with an agent, a user identity,
+     * or a workspace context by passing relevant fields in `attributes`.
+     *
+     * @param attributes - Thread attributes such as `title`, `agent_id`,
+     *   `metadata`, or any custom fields accepted by the server.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the newly created `Thread` object.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     *
+     * const thread = await client.threads.create({
+     *   title: 'Invoice review session',
+     *   agent_id: 'agt_01HXYZ...',
+     * });
+     * console.log(`Thread ID: ${thread.id}`);
+     */
+    create: (attributes: CreateThreadAttributes, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Updates one or more attributes of an existing thread.
+     *
+     * Only the fields present in `attributes` are changed (PATCH semantics).
+     * Commonly used to rename a thread or update its metadata after creation.
+     *
+     * @param id - The UUID of the thread to update.
+     * @param attributes - A partial map of thread attributes to update
+     *   (e.g. `{ title: 'Renamed thread', metadata: { priority: 'high' } }`).
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the updated `Thread` object.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     *
+     * const updated = await client.threads.update('thr_01HXYZ...', {
+     *   title: 'Q2 Invoice Review',
+     * });
+     */
+    update: (id: string, attributes: UpdateThreadAttributes, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Merge metadata into the thread's existing metadata (shallow merge).
+     *
+     * Keys present in the input overwrite existing keys; keys not present are
+     * preserved. Use `update({ metadata })` instead for full replacement.
+     *
+     * @param id - The UUID of the thread to update.
+     * @param metadata - Key-value pairs to merge into existing metadata.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the updated `Thread`.
+     *
+     * @example
+     * ```typescript
+     * await client.threads.updateMetadata(threadId, {
+     *   pinned_context: { client_id: 'uuid', client_name: 'Sarah Johnson' },
+     * });
+     * ```
+     */
+    updateMetadata: (id: string, metadata: Record<string, unknown>, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Generates an AI-produced summary of the thread's conversation history.
+     *
+     * Triggers an LLM call that reads all messages in the thread and produces a
+     * concise natural-language summary. The summary is stored on the thread and
+     * returned as part of the response. Useful for giving users a quick recap of
+     * long conversations or for providing context before forking.
+     *
+     * @param id - The UUID of the thread to summarize.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the `Thread` object with the generated
+     *   summary populated in `attributes.context_summary`.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const thread = await client.threads.summarize('thr_01HXYZ...');
+     * console.log(thread.attributes.context_summary);
+     */
+    summarize: (id: string, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Forks a thread by creating a new thread that is a full copy of the original,
+     * including all of its messages.
+     *
+     * The forked thread is independent — changes to either thread after forking
+     * do not affect the other. Forking is useful for branching a conversation to
+     * explore a different line of questioning without losing the original, or for
+     * creating a template thread that can be re-used across multiple users.
+     *
+     * @param id - The UUID of the thread to fork.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the newly created fork as a `Thread` object.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const fork = await client.threads.fork('thr_01HXYZ...');
+     * console.log(`Forked into new thread: ${fork.id}`);
+     */
+    fork: (id: string, title?: string, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Exports a thread and all of its messages in a portable format.
+     *
+     * The export includes the thread metadata and the full ordered message
+     * history. Supported output formats include JSON (structured), Markdown
+     * (human-readable), and plain text. The desired format can be specified
+     * via request options or query parameters.
+     *
+     * @param id - The UUID of the thread to export.
+     * @param format - Export format: `'json'`, `'markdown'`, or `'text'`. Defaults to `'json'`.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the export payload.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const exported = await client.threads.export('thr_01HXYZ...', 'markdown');
+     * console.log(exported.content);
+     */
+    export: (id: string, format?: "json" | "markdown" | "text", options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Fetches a single thread by its ID.
+     *
+     * @param id - The UUID of the thread to retrieve.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the full `Thread` object.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const thread = await client.threads.get('thr_01HXYZ...');
+     * console.log(thread.attributes.title);
+     */
+    get: (id: string, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Archives a thread, soft-deleting it by hiding it from default listings.
+     *
+     * Archived threads are not permanently deleted — their messages, metadata,
+     * and history are preserved. They will no longer appear in the default
+     * `list` results but can be restored at any time using {@link unarchive}.
+     * Archiving is the recommended way to "clean up" a thread without losing
+     * its history.
+     *
+     * @param id - The UUID of the thread to archive.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the `Thread` object with
+     *   `attributes.archived_at` populated.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const archived = await client.threads.archive('thr_01HXYZ...');
+     * console.log(`Archived at: ${archived.attributes.archived_at}`);
+     */
+    archive: (id: string, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Restores a previously archived thread back to active status.
+     *
+     * After unarchiving, the thread will appear again in default `list` results
+     * and all of its messages will be accessible as normal.
+     *
+     * @param id - The UUID of the archived thread to restore.
+     * @param options - Optional request options.
+     * @returns A promise that resolves to the restored `Thread` object with
+     *   `attributes.archived_at` cleared.
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const restored = await client.threads.unarchive('thr_01HXYZ...');
+     * console.log(`Archived at: ${restored.attributes.archived_at}`); // null
+     */
+    unarchive: (id: string, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Sub-namespace for reading and sending messages within a thread.
+     *
+     * Messages are the ordered entries within a thread. The platform supports
+     * both synchronous (request/response) message sending via {@link send} and
+     * real-time token streaming via {@link stream} using Server-Sent Events (SSE).
+     *
+     * @example
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     *
+     * // Non-streaming
+     * const reply = await client.threads.messages.send('thr_01HXYZ...', 'Hello!');
+     *
+     * // Streaming
+     * const stream = await client.threads.messages.stream('thr_01HXYZ...', { content: 'Hello!' });
+     * for await (const chunk of stream) {
+     *   if (chunk.type === 'token') process.stdout.write(chunk.content ?? '');
+     * }
+     */
+    messages: {
+        /**
+         * Lists all messages in a thread.
+         *
+         * Messages are returned in ascending chronological order (oldest first).
+         * Each message includes the role (`user` or `assistant`), content, timestamp,
+         * and any associated metadata.
+         *
+         * @param threadId - The UUID of the thread whose messages to list.
+         * @param options - Optional request options.
+         * @returns A promise that resolves to an array of message objects ordered
+         *   oldest-first.
+         *
+         * @example
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const messages = await client.threads.messages.list('thr_01HXYZ...');
+         * messages.forEach(m => console.log(`${m.attributes.role}: ${m.attributes.content}`));
+         */
+        list: (threadId: string, options?: RequestOptions) => Promise<Message[]>;
+        /**
+         * Sends a message to a thread and waits for the full AI response before
+         * returning (non-streaming).
+         *
+         * The platform routes the message to the agent associated with the thread,
+         * runs inference, and returns the complete assistant reply once generation
+         * finishes. For long responses or low-latency UIs, prefer {@link stream}
+         * which delivers tokens incrementally as they are generated.
+         *
+         * @param threadId - The UUID of the thread to send the message to.
+         * @param content - The text content of the user message.
+         * @param attributes - Optional additional message attributes such as
+         *   `attachments`, `metadata`, or `role` override.
+         * @param options - Optional request options.
+         * @returns A promise that resolves to the created message object, including
+         *   the full assistant reply in `attributes.content`.
+         *
+         * @example
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const reply = await client.threads.messages.send(
+         *   'thr_01HXYZ...',
+         *   'What is the total amount due on the invoice?',
+         * );
+         * console.log(`Assistant: ${reply.attributes.content}`);
+         */
+        send: (threadId: string, content: string, attributes?: SendMessageAttributes, options?: RequestOptions) => Promise<Message>;
+        /**
+         * Inserts a pre-generated message into a thread WITHOUT triggering AI inference.
+         *
+         * Use this to persist results from specialized agent executions (via
+         * `sdk.agents.executions.start()`) back into a thread. The message is stored
+         * with PII compliance scan and async vectorization, but no LLM call is made.
+         *
+         * @param threadId - The UUID of the thread to insert the message into.
+         * @param content - The message content text.
+         * @param attributes - Message attributes including `role` (typically `'assistant'`).
+         * @param options - Optional request options.
+         * @returns A promise resolving to the created `Message`.
+         *
+         * @example
+         * ```typescript
+         * const message = await client.threads.messages.insert(threadId, result.content, {
+         *   role: 'assistant',
+         *   metadata: { execution_id: execution.id, agent_id: agentId },
+         * });
+         * ```
+         */
+        insert: (threadId: string, content: string, attributes: InsertMessageAttributes, options?: RequestOptions) => Promise<Message>;
+        /**
+         * Submit thumbs up/down feedback on a message. Uses upsert — calling again
+         * on the same message replaces the previous rating.
+         *
+         * @param messageId - The UUID of the message to rate.
+         * @param rating - `'up'` or `'down'`.
+         * @param comment - Optional comment explaining the rating.
+         * @param options - Optional request options.
+         * @returns A promise resolving to the created/updated `MessageFeedback`.
+         *
+         * @example
+         * ```typescript
+         * await client.threads.messages.rate(messageId, 'up');
+         * await client.threads.messages.rate(messageId, 'down', 'Response was inaccurate');
+         * ```
+         */
+        rate: (messageId: string, rating: "up" | "down", comment?: string, options?: RequestOptions) => Promise<MessageFeedback>;
+        /**
+         * Update an existing message's content, role, or metadata (PATCH semantics).
+         *
+         * Only the fields present in `attributes` are changed. Useful for attaching
+         * metadata (e.g., execution_id, tool_call details) to a message after creation.
+         *
+         * @param messageId - The UUID of the message to update.
+         * @param attributes - Fields to update.
+         * @param options - Optional request options.
+         * @returns A promise resolving to the updated `Message`.
+         *
+         * @example
+         * ```typescript
+         * await client.threads.messages.update(messageId, {
+         *   metadata: { execution_id: 'exec_123', reviewed: true },
+         * });
+         * ```
+         */
+        update: (messageId: string, attributes: UpdateMessageAttributes, options?: RequestOptions) => Promise<Message>;
+        /**
+         * Sends a message to a thread and streams the AI response via Server-Sent Events (SSE).
+         *
+         * For agent-backed threads, the stream includes the full execution lifecycle:
+         * - `token` — incremental LLM output tokens
+         * - `tool_call` — agent is calling a tool (name + arguments)
+         * - `tool_result` — tool execution completed (name + summary)
+         * - `iteration_complete` — LLM loop iteration finished
+         * - `approval_required` — human approval needed for a sensitive tool
+         * - `done` — stream complete, includes metadata with execution_id
+         * - `error` — stream error
+         *
+         * For RAG threads (no agent), only `token`, `done`, and `error` are emitted.
+         *
+         * SSE security limits: 5-minute idle timeout, 10,000 chunk maximum,
+         * 10 MB buffer size limit.
+         *
+         * @param threadId - The UUID of the thread to stream a message to.
+         * @param body - The message payload, including at minimum `content` (string).
+         * @param options - Optional request options (e.g. custom headers, abort signal).
+         * @param streamOptions - Optional streaming configuration (e.g. chunk timeout).
+         * @returns A promise that resolves to an `AsyncIterableIterator<StreamMessageChunk>`.
+         *
+         * @example
+         * ```typescript
+         * const stream = await client.threads.messages.stream(threadId, { content: 'Summarize the contract.' });
+         * for await (const event of stream) {
+         *   switch (event.type) {
+         *     case 'token':
+         *       process.stdout.write(event.content ?? '');
+         *       break;
+         *     case 'tool_call':
+         *       console.log(`Tool: ${event.data.name}`, event.data.arguments);
+         *       break;
+         *     case 'tool_result':
+         *       console.log(`Result: ${event.data.summary}`);
+         *       break;
+         *     case 'done':
+         *       console.log('Complete', event.metadata);
+         *       break;
+         *   }
+         * }
+         * ```
+         */
+        stream: (threadId: string, body: Record<string, unknown>, options?: RequestOptions, streamOptions?: StreamOptions) => Promise<AsyncIterableIterator<StreamMessageChunk>>;
+        /**
+         * Full-text substring search across message content.
+         * Optionally filter to a specific thread.
+         *
+         * @param query - Substring to match against message content.
+         * @param threadId - Optional thread UUID to scope the search.
+         * @param options - Optional request options.
+         * @returns A promise resolving to an array of matching `Message` objects.
+         *
+         * @example
+         * ```typescript
+         * // Search all messages
+         * const all = await client.threads.messages.search('deadline');
+         * // Search within a specific thread
+         * const scoped = await client.threads.messages.search('deadline', threadId);
+         * ```
+         */
+        search: (query: string, threadId?: string, options?: RequestOptions) => Promise<Message[]>;
+        /**
+         * Vector similarity search across messages using a generated embedding.
+         * Optionally filter to a specific thread.
+         *
+         * @param query - Natural-language query string to embed and search.
+         * @param limit - Maximum number of results (default: 10).
+         * @param threadId - Optional thread UUID to scope the search.
+         * @param options - Optional request options.
+         * @returns A promise resolving to an array of semantically similar `Message` objects.
+         *
+         * @example
+         * ```typescript
+         * const results = await client.threads.messages.semanticSearch('unpaid invoices', 5, threadId);
+         * ```
+         */
+        semanticSearch: (query: string, limit?: number, threadId?: string, options?: RequestOptions) => Promise<Message[]>;
+    };
+    /**
+     * Trigger AI inference on a thread without sending a new user message.
+     *
+     * Runs the full RAG pipeline (VectorSearch + GraphLookup + SynthesizeResponse)
+     * using the thread's last user message as query context. Saves the AI response
+     * as an assistant message and returns the updated Thread.
+     *
+     * Use this to let the AI proactively continue a conversation — for example,
+     * after a voice session finalizes, to generate a follow-up or summary without
+     * requiring the user to explicitly ask.
+     *
+     * @param threadId - The UUID of the thread to run AI completion on.
+     * @param options - Optional request options.
+     * @returns A promise resolving to the updated `Thread` after the assistant
+     *   message has been saved.
+     *
+     * @example
+     * ```typescript
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     *
+     * // After a voice session finalizes, trigger AI continuation:
+     * const thread = await client.threads.complete('thr_01HXYZ...');
+     * console.log(`Thread updated at: ${thread.attributes?.updated_at}`);
+     * ```
+     */
+    complete: (threadId: string, options?: RequestOptions) => Promise<Thread>;
+    /**
+     * Trigger AI inference on a thread and receive the response via Server-Sent Events.
+     *
+     * For agent-backed threads (when execution bridge is enabled), this streams
+     * the full execution lifecycle including `token`, `tool_call`, `tool_result`,
+     * `iteration_complete`, `approval_required`, `done`, and `error` events.
+     *
+     * For RAG threads or when the bridge is disabled, delivers the full response
+     * as a single `done` event.
+     *
+     * @param threadId - The UUID of the thread to run AI completion on.
+     * @param options - Optional request options (e.g. abort signal).
+     * @param streamOptions - Optional streaming configuration.
+     * @returns A promise resolving to an `AsyncIterableIterator<StreamMessageChunk>`.
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.threads.completeStream('thr_01HXYZ...');
+     * for await (const event of stream) {
+     *   switch (event.type) {
+     *     case 'token':
+     *       process.stdout.write(event.content ?? '');
+     *       break;
+     *     case 'tool_call':
+     *       console.log(`Tool: ${event.data.name}`);
+     *       break;
+     *     case 'done':
+     *       console.log('Complete', event.metadata);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    completeStream: (threadId: string, options?: RequestOptions, streamOptions?: StreamOptions) => Promise<AsyncIterableIterator<StreamMessageChunk>>;
+    /**
+     * Full-text search threads by title or context summary.
+     *
+     * @param query - The search query string.
+     * @param options - Optional request options.
+     * @returns A promise resolving to an array of matching `Thread` objects.
+     *
+     * @example
+     * ```typescript
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const results = await client.threads.search('invoice review');
+     * ```
+     */
+    search: (query: string, options?: RequestOptions) => Promise<Thread[]>;
+};
+//# sourceMappingURL=threads.d.ts.map

package/dist/namespaces/threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.d.ts","sourceRoot":"","sources":["../../src/namespaces/threads.ts"],"names":[],"mappings":"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"}