@opensecret/react 1.4.3 → 1.5.0

package/dist/index.d.ts

@@ -7,6 +7,30 @@ declare function acceptInvite(code: string): Promise<{
     message: string;
 }>;
 
+/**
+ * @deprecated Use openai.conversations.create() with items parameter instead
+ * Adds items to a conversation
+ * @param conversationId - The UUID of the conversation
+ * @param items - Array of items to add to the conversation
+ * @returns A promise resolving to the updated conversation with items
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The conversation is not found
+ * - The user doesn't have access to the conversation
+ *
+ * @example
+ * ```typescript
+ * await addConversationItems("550e8400-e29b-41d4-a716-446655440000", [
+ *   {
+ *     type: "message",
+ *     role: "user",
+ *     content: [{ type: "text", text: "Hello" }]
+ *   }
+ * ]);
+ * ```
+ */
+declare function addConversationItems(conversationId: string, items: Partial<ConversationItem>[]): Promise<Conversation>;
+
 declare namespace api {
     export {
         setApiUrl,
@@ -54,6 +78,24 @@ declare namespace api {
         checkDocumentStatus,
         uploadDocumentWithPolling,
         transcribeAudio,
+        fetchResponsesList,
+        fetchResponse,
+        cancelResponse,
+        createConversation,
+        getConversation,
+        updateConversation,
+        deleteConversation,
+        addConversationItems,
+        listConversationItems,
+        listConversations,
+        createResponse,
+        deleteResponse,
+        createInstruction,
+        listInstructions,
+        getInstruction,
+        updateInstruction,
+        deleteInstruction,
+        setDefaultInstruction,
         LoginResponse,
         UserResponse,
         KVListItem,
@@ -81,7 +123,27 @@ declare namespace api {
         DocumentStatusRequest,
         DocumentStatusResponse,
         WhisperTranscriptionRequest,
-        WhisperTranscriptionResponse
+        WhisperTranscriptionResponse,
+        ResponsesRetrieveResponse,
+        ThreadListItem,
+        ResponsesListResponse,
+        ResponsesListParams,
+        ConversationItem,
+        Conversation,
+        ConversationCreateRequest,
+        ConversationUpdateRequest,
+        ConversationItemsResponse,
+        ConversationsListResponse,
+        ConversationDeleteResponse,
+        ResponsesCancelResponse,
+        ResponsesDeleteResponse,
+        ResponsesCreateRequest,
+        Instruction,
+        InstructionCreateRequest,
+        InstructionUpdateRequest,
+        InstructionListParams,
+        InstructionListResponse,
+        InstructionDeleteResponse
     }
 }
 
@@ -215,6 +277,32 @@ declare function authenticate(attestationDocumentBase64: string, trustedRootCert
 
 declare const AWS_ROOT_CERT_DER: Uint8Array;
 
+/**
+ * Cancels an in-progress response
+ * @param responseId - The UUID of the response to cancel
+ * @returns A promise resolving to the cancelled response
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The response is not found
+ * - The response is not in 'in_progress' status
+ * - The user doesn't have access to the response
+ *
+ * @description
+ * This function cancels a response that is currently being processed.
+ * Only responses with status 'in_progress' can be cancelled.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const cancelled = await cancelResponse("550e8400-e29b-41d4-a716-446655440000");
+ *   console.log("Response cancelled:", cancelled.status);
+ * } catch (error) {
+ *   console.error("Cannot cancel:", error.message);
+ * }
+ * ```
+ */
+declare function cancelResponse(responseId: string): Promise<ResponsesCancelResponse>;
+
 declare function changePassword(currentPassword: string, newPassword: string): Promise<void>;
 
 /**
@@ -298,6 +386,57 @@ declare function confirmPlatformPasswordReset(email: string, alphanumericCode: s
     message: string;
 }>;
 
+export declare type Conversation = {
+    id: string;
+    object: "conversation";
+    created_at: number;
+    metadata?: Record<string, any>;
+};
+
+export declare type ConversationCreateRequest = {
+    metadata?: Record<string, any>;
+};
+
+export declare type ConversationDeleteResponse = {
+    id: string;
+    object: "conversation.deleted";
+    deleted: boolean;
+};
+
+export declare type ConversationItem = {
+    id: string;
+    type: "message";
+    status: "completed" | "in_progress" | "incomplete";
+    role: "user" | "assistant" | "system";
+    content: Array<{
+        type: "text" | "input_text" | "input_audio" | "item";
+        text?: string;
+        audio?: string;
+        transcript?: string;
+        id?: string;
+    }>;
+};
+
+export declare type ConversationItemsResponse = {
+    object: "list";
+    data: ConversationItem[];
+    first_id?: string;
+    last_id?: string;
+    has_more: boolean;
+};
+
+export declare type ConversationsListResponse = {
+    object: "list";
+    data: Conversation[];
+    first_id?: string;
+    last_id?: string;
+    has_more: boolean;
+};
+
+export declare type ConversationUpdateRequest = {
+    metadata?: Record<string, any>;
+};
+
 declare function convertGuestToEmailAccount(email: string, password: string, name?: string | null): Promise<void>;
 
 /**
@@ -322,7 +461,56 @@ declare function convertGuestToEmailAccount(email: string, password: string, nam
  */
 export declare function createApiKey(name: string): Promise<ApiKeyCreateResponse>;
 
-export declare function createCustomFetch(options?: CustomFetchOptions): (url: RequestInfo, init?: RequestInit) => Promise<Response>;
+/**
+ * Creates a new conversation
+ * @param metadata - Optional metadata to attach to the conversation
+ * @returns A promise resolving to the created conversation
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The request fails
+ *
+ * @description
+ * This function creates a new conversation that can be used to group
+ * related responses together. The conversation can have metadata
+ * attached for organization and filtering purposes.
+ *
+ * NOTE: Prefer using the OpenAI client directly for conversation operations:
+ * ```typescript
+ * const openai = new OpenAI({ fetch: customFetch });
+ * const conversation = await openai.conversations.create({
+ *   metadata: { title: "Product Support", category: "technical" }
+ * });
+ * ```
+ *
+ * @deprecated Use openai.conversations.create() instead
+ */
+declare function createConversation(metadata?: Record<string, any>): Promise<Conversation>;
+
+export declare function createCustomFetch(options?: CustomFetchOptions): (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+/**
+ * Creates a new instruction
+ * @param request - The instruction creation parameters
+ * @returns A promise resolving to the created instruction
+ * @throws {Error} If:\n * - The user is not authenticated
+ * - The request fails
+ * - Name or prompt are empty strings
+ *
+ * @description
+ * This function creates a new user instruction (system prompt).
+ * If is_default is set to true, all other instructions are automatically set to is_default: false.
+ * The prompt_tokens field is automatically calculated.
+ *
+ * @example
+ * ```typescript
+ * const instruction = await createInstruction({
+ *   name: "Helpful Assistant",
+ *   prompt: "You are a helpful assistant that...",
+ *   is_default: true
+ * });
+ * ```
+ */
+declare function createInstruction(request: InstructionCreateRequest): Promise<Instruction>;
 
 declare function createOrganization(name: string): Promise<Organization>;
 
@@ -330,6 +518,38 @@ declare function createProject(orgId: string, name: string, description?: string
 
 declare function createProjectSecret(orgId: string, projectId: string, keyName: string, secret: string): Promise<ProjectSecret>;
 
+/**
+ * Creates a new response with conversation support
+ * @param request - The request parameters for creating a response
+ * @returns A promise resolving to the created response or a stream
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The request fails
+ *
+ * @description
+ * This function creates a new response in the OpenAI-compatible API.
+ * It supports both the new conversation parameter and the deprecated
+ * previous_response_id parameter for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * // Create a response in a conversation
+ * const response = await createResponse({
+ *   model: "gpt-4",
+ *   input: "Hello, how are you?",
+ *   conversation: "550e8400-e29b-41d4-a716-446655440000"
+ * });
+ *
+ * // Or with the deprecated previous_response_id
+ * const response = await createResponse({
+ *   model: "gpt-4",
+ *   input: "Tell me more",
+ *   previous_response_id: "response-uuid"
+ * });
+ * ```
+ */
+declare function createResponse(request: ResponsesCreateRequest): Promise<any>;
+
 export declare interface CustomFetchOptions {
     apiKey?: string;
 }
@@ -401,6 +621,52 @@ declare type DecryptDataRequest = {
  */
 export declare function deleteApiKey(name: string): Promise<void>;
 
+/**
+ * @deprecated Use openai.conversations.delete() instead
+ * Deletes a conversation permanently
+ * @param conversationId - The UUID of the conversation to delete
+ * @returns A promise resolving to deletion confirmation
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The conversation is not found
+ * - The user doesn't have access to the conversation
+ *
+ * @description
+ * This function permanently deletes a conversation and all associated items.
+ * This action cannot be undone.
+ *
+ * @example
+ * ```typescript
+ * const result = await deleteConversation("550e8400-e29b-41d4-a716-446655440000");
+ * if (result.deleted) {
+ *   console.log("Conversation deleted successfully");
+ * }
+ * ```
+ */
+declare function deleteConversation(conversationId: string): Promise<ConversationDeleteResponse>;
+
+/**
+ * Deletes an instruction permanently
+ * @param instructionId - The UUID of the instruction to delete
+ * @returns A promise resolving to deletion confirmation
+ * @throws {Error} If:\n * - The user is not authenticated
+ * - The instruction is not found (404)
+ * - The user doesn't have access to the instruction
+ *
+ * @description
+ * This function permanently deletes an instruction.
+ * This action cannot be undone.
+ *
+ * @example
+ * ```typescript
+ * const result = await deleteInstruction("550e8400-e29b-41d4-a716-446655440000");
+ * if (result.deleted) {
+ *   console.log("Instruction deleted successfully");
+ * }
+ * ```
+ */
+declare function deleteInstruction(instructionId: string): Promise<InstructionDeleteResponse>;
+
 declare function deleteOrganization(orgId: string): Promise<void>;
 
 declare function deleteOrganizationInvite(orgId: string, inviteCode: string): Promise<{
@@ -411,6 +677,29 @@ declare function deleteProject(orgId: string, projectId: string): Promise<void>;
 
 declare function deleteProjectSecret(orgId: string, projectId: string, keyName: string): Promise<void>;
 
+/**
+ * Deletes a response permanently
+ * @param responseId - The UUID of the response to delete
+ * @returns A promise resolving to deletion confirmation
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The response is not found
+ * - The user doesn't have access to the response
+ *
+ * @description
+ * This function permanently deletes a response and all associated data.
+ * This action cannot be undone.
+ *
+ * @example
+ * ```typescript
+ * const result = await deleteResponse("550e8400-e29b-41d4-a716-446655440000");
+ * if (result.deleted) {
+ *   console.log("Response deleted successfully");
+ * }
+ * ```
+ */
+declare function deleteResponse(responseId: string): Promise<ResponsesDeleteResponse>;
+
 declare type DeveloperResponse = PlatformUser & {
     organizations: PlatformOrg[];
 };
@@ -609,6 +898,68 @@ declare function fetchPublicKey(algorithm: SigningAlgorithm, key_options?: KeyOp
 
 declare function fetchPut(key: string, value: string): Promise<string>;
 
+/**
+ * Retrieves a single response by ID
+ * @param responseId - The UUID of the response to retrieve
+ * @returns A promise resolving to the response details
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The response is not found
+ * - The user doesn't have access to the response
+ *
+ * @description
+ * This function fetches detailed information about a specific response,
+ * including full output and usage statistics.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetchResponse("550e8400-e29b-41d4-a716-446655440000");
+ * console.log(response.output); // The full response text
+ * console.log(response.usage);  // Token usage statistics
+ * ```
+ */
+declare function fetchResponse(responseId: string): Promise<ResponsesRetrieveResponse>;
+
+/**
+ * Lists user's conversation threads with pagination
+ * @param params - Optional parameters for pagination and filtering
+ * @returns A promise resolving to a paginated list of conversation threads
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The request fails
+ * - Invalid pagination parameters
+ *
+ * @description
+ * This function fetches a paginated list of the user's conversation threads.
+ * Each thread represents a conversation, not individual messages.
+ * Threads are sorted by updated_at (most recently active threads first).
+ *
+ * Query Parameters:
+ * - limit: Number of results per page (1-100, default: 20)
+ * - after: UUID cursor for forward pagination
+ * - before: UUID cursor for backward pagination
+ * - order: Sort order (currently not implemented, reserved for future use)
+ *
+ * Pagination Examples:
+ * ```typescript
+ * // First page
+ * const threads = await fetchResponsesList({ limit: 20 });
+ *
+ * // Next page
+ * const nextPage = await fetchResponsesList({
+ *   limit: 20,
+ *   after: threads.last_id
+ * });
+ *
+ * // Previous page
+ * const prevPage = await fetchResponsesList({
+ *   limit: 20,
+ *   before: threads.first_id
+ * });
+ * ```
+ */
+declare function fetchResponsesList(params?: ResponsesListParams): Promise<ResponsesListResponse>;
+
 declare function fetchSignUp(email: string, password: string, inviteCode: string, client_id: string, name?: string | null): Promise<LoginResponse>;
 
 declare function fetchUser(): Promise<UserResponse>;
@@ -630,8 +981,42 @@ declare function getApiUrl(): string;
 
 declare function getAttestation(forceRefresh?: boolean, explicitApiUrl?: string): Promise<Attestation>;
 
+/**
+ * @deprecated Use openai.conversations.retrieve() instead
+ * Retrieves a conversation by ID
+ * @param conversationId - The UUID of the conversation to retrieve
+ * @returns A promise resolving to the conversation
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The conversation is not found
+ * - The user doesn't have access to the conversation
+ *
+ * @example
+ * ```typescript
+ * const conversation = await getConversation("550e8400-e29b-41d4-a716-446655440000");
+ * console.log(conversation.metadata);
+ * ```
+ */
+declare function getConversation(conversationId: string): Promise<Conversation>;
+
 declare function getEmailSettings(orgId: string, projectId: string): Promise<EmailSettings>;
 
+/**
+ * Retrieves a single instruction by ID
+ * @param instructionId - The UUID of the instruction to retrieve
+ * @returns A promise resolving to the instruction details
+ * @throws {Error} If:\n * - The user is not authenticated
+ * - The instruction is not found (404)
+ * - The user doesn't have access to the instruction
+ *
+ * @example
+ * ```typescript
+ * const instruction = await getInstruction("550e8400-e29b-41d4-a716-446655440000");
+ * console.log(instruction.name, instruction.prompt);
+ * ```
+ */
+declare function getInstruction(instructionId: string): Promise<Instruction>;
+
 declare function getOAuthSettings(orgId: string, projectId: string): Promise<OAuthSettings>;
 
 declare function getOrganizationInvite(orgId: string, inviteCode: string): Promise<OrganizationInvite>;
@@ -718,6 +1103,50 @@ declare function initiateGitHubAuth(client_id: string, inviteCode?: string): Pro
 
 declare function initiateGoogleAuth(client_id: string, inviteCode?: string): Promise<GoogleAuthResponse>;
 
+declare type Instruction = {
+    id: string;
+    object: "instruction";
+    name: string;
+    prompt: string;
+    prompt_tokens: number;
+    is_default: boolean;
+    created_at: number;
+    updated_at: number;
+};
+
+declare type InstructionCreateRequest = {
+    name: string;
+    prompt: string;
+    is_default?: boolean;
+};
+
+declare type InstructionDeleteResponse = {
+    id: string;
+    object: "instruction.deleted";
+    deleted: true;
+};
+
+declare type InstructionListParams = {
+    limit?: number;
+    after?: string;
+    before?: string;
+    order?: string;
+};
+
+declare type InstructionListResponse = {
+    object: "list";
+    data: Instruction[];
+    has_more: boolean;
+    first_id: string | null;
+    last_id: string | null;
+};
+
+declare type InstructionUpdateRequest = {
+    name?: string;
+    prompt?: string;
+    is_default?: boolean;
+};
+
 declare function inviteDeveloper(orgId: string, email: string, role?: string): Promise<OrganizationInvite>;
 
 declare function keyExchange(clientPublicKey: string, nonce: string, explicitApiUrl?: string): Promise<{
@@ -772,6 +1201,90 @@ export declare function listApiKeys(): Promise<{
     keys: ApiKeyListResponse;
 }>;
 
+/**
+ * @deprecated Use openai.conversations.items.list() instead
+ * Lists items in a conversation
+ * @param conversationId - The UUID of the conversation
+ * @param params - Optional pagination parameters
+ * @returns A promise resolving to a paginated list of conversation items
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The conversation is not found
+ * - The user doesn't have access to the conversation
+ *
+ * @example
+ * ```typescript
+ * const items = await listConversationItems("550e8400-e29b-41d4-a716-446655440000", {
+ *   limit: 20
+ * });
+ * for (const item of items.data) {
+ *   console.log(item.role, item.content);
+ * }
+ * ```
+ */
+declare function listConversationItems(conversationId: string, params?: {
+    limit?: number;
+    after?: string;
+    before?: string;
+}): Promise<ConversationItemsResponse>;
+
+/**
+ * Lists all conversations with pagination (non-standard endpoint)
+ * @param params - Optional pagination parameters
+ * @returns A promise resolving to a paginated list of conversations
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The request fails
+ *
+ * @description
+ * This is a custom extension not part of the standard OpenAI Conversations API.
+ * This function fetches a paginated list of the user's conversations.
+ * Conversations are sorted by created_at (most recent first).
+ *
+ * @example
+ * ```typescript
+ * const conversations = await listConversations({ limit: 20 });
+ * for (const conv of conversations.data) {
+ *   console.log(conv.id, conv.metadata);
+ * }
+ * ```
+ */
+declare function listConversations(params?: {
+    limit?: number;
+    after?: string;
+    before?: string;
+}): Promise<ConversationsListResponse>;
+
+/**
+ * Lists user's instructions with pagination
+ * @param params - Optional parameters for pagination and ordering
+ * @returns A promise resolving to a paginated list of instructions
+ * @throws {Error} If:\n * - The user is not authenticated
+ * - The request fails
+ *
+ * @description
+ * This function fetches a paginated list of the user's instructions.
+ * Results are ordered by updated_at by default (most recently updated first).
+ *
+ * Query Parameters:
+ * - limit: Number of results per page (1-100, default: 20)
+ * - after: UUID cursor for forward pagination
+ * - before: UUID cursor for backward pagination
+ * - order: Sort order ("asc" or "desc", default: "desc")
+ *
+ * @example
+ * ```typescript
+ * const instructions = await listInstructions({ limit: 20 });
+ *
+ * // Next page
+ * const nextPage = await listInstructions({
+ *   limit: 20,
+ *   after: instructions.last_id
+ * });
+ * ```
+ */
+declare function listInstructions(params?: InstructionListParams): Promise<InstructionListResponse>;
+
 declare function listOrganizationInvites(orgId: string): Promise<OrganizationInvite[]>;
 
 declare function listOrganizationMembers(orgId: string): Promise<OrganizationMember[]>;
@@ -1131,7 +1644,7 @@ export declare type OpenSecretContextType = {
      * });
      * ```
      */
-    aiCustomFetch: (url: RequestInfo, init?: RequestInit) => Promise<Response>;
+    aiCustomFetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
     /**
      * Returns the current OpenSecret enclave API URL being used
      * @returns The current API URL
@@ -1418,6 +1931,152 @@ export declare type OpenSecretContextType = {
      * ```
      */
     transcribeAudio: typeof api.transcribeAudio;
+    /**
+     * Lists user's responses with pagination
+     * @param params - Optional parameters for pagination and filtering
+     * @returns A promise resolving to a paginated list of responses
+     * @throws {Error} If:
+     * - The user is not authenticated
+     * - The request fails
+     * - Invalid pagination parameters
+     *
+     * @description
+     * This function fetches a paginated list of the user's responses.
+     * In list view, the usage and output fields are always null for performance reasons.
+     *
+     * Query Parameters:
+     * - limit: Number of results per page (1-100, default: 20)
+     * - after: UUID cursor for forward pagination
+     * - before: UUID cursor for backward pagination
+     * - order: Sort order (currently not implemented, reserved for future use)
+     *
+     * Pagination Examples:
+     * ```typescript
+     * // First page
+     * const responses = await context.fetchResponsesList({ limit: 20 });
+     *
+     * // Next page
+     * const nextPage = await context.fetchResponsesList({
+     *   limit: 20,
+     *   after: responses.last_id
+     * });
+     *
+     * // Previous page
+     * const prevPage = await context.fetchResponsesList({
+     *   limit: 20,
+     *   before: responses.first_id
+     * });
+     * ```
+     */
+    fetchResponsesList: (params?: api.ResponsesListParams) => Promise<api.ResponsesListResponse>;
+    /**
+     * Retrieves a single response by ID
+     * @param responseId - The UUID of the response to retrieve
+     * @returns A promise resolving to the response details
+     */
+    fetchResponse: (responseId: string) => Promise<api.ResponsesRetrieveResponse>;
+    /**
+     * Cancels an in-progress response
+     * @param responseId - The UUID of the response to cancel
+     * @returns A promise resolving to the cancelled response
+     */
+    cancelResponse: (responseId: string) => Promise<api.ResponsesCancelResponse>;
+    /**
+     * Deletes a response permanently
+     * @param responseId - The UUID of the response to delete
+     * @returns A promise resolving to deletion confirmation
+     */
+    deleteResponse: (responseId: string) => Promise<api.ResponsesDeleteResponse>;
+    /**
+     * Creates a new response with conversation support
+     * @param request - The request parameters for creating a response
+     * @returns A promise resolving to the created response or a stream
+     */
+    createResponse: (request: api.ResponsesCreateRequest) => Promise<any>;
+    /**
+     * Lists all conversations with pagination (non-standard endpoint)
+     * @param params - Optional pagination parameters
+     * @returns A promise resolving to a paginated list of conversations
+     * @description
+     * This is a custom extension not part of the standard OpenAI API.
+     * For standard conversation operations, use the OpenAI client directly:
+     * - openai.conversations.create()
+     * - openai.conversations.retrieve()
+     * - openai.conversations.update()
+     * - openai.conversations.delete()
+     * - openai.conversations.items.list()
+     * - openai.conversations.items.retrieve()
+     */
+    listConversations: (params?: {
+        limit?: number;
+        after?: string;
+        before?: string;
+    }) => Promise<api.ConversationsListResponse>;
+    /**
+     * Creates a new instruction
+     * @param request - The instruction creation parameters
+     * @returns A promise resolving to the created instruction
+     * @throws {Error} If the user is not authenticated or the request fails
+     *
+     * @description
+     * Creates a new user instruction (system prompt).
+     * If is_default is set to true, all other instructions are automatically set to is_default: false.
+     * The prompt_tokens field is automatically calculated.
+     */
+    createInstruction: typeof api.createInstruction;
+    /**
+     * Lists user's instructions with pagination
+     * @param params - Optional parameters for pagination and ordering
+     * @returns A promise resolving to a paginated list of instructions
+     * @throws {Error} If the user is not authenticated or the request fails
+     *
+     * @description
+     * Fetches a paginated list of the user's instructions.
+     * Results are ordered by updated_at by default (most recently updated first).
+     */
+    listInstructions: typeof api.listInstructions;
+    /**
+     * Retrieves a single instruction by ID
+     * @param instructionId - The UUID of the instruction to retrieve
+     * @returns A promise resolving to the instruction details
+     * @throws {Error} If the instruction is not found or user doesn't have access
+     */
+    getInstruction: typeof api.getInstruction;
+    /**
+     * Updates an existing instruction
+     * @param instructionId - The UUID of the instruction to update
+     * @param request - The fields to update
+     * @returns A promise resolving to the updated instruction
+     * @throws {Error} If the instruction is not found or validation fails
+     *
+     * @description
+     * At least one field must be provided.
+     * If is_default: true is set, all other instructions are automatically set to is_default: false.
+     * The prompt_tokens field is recalculated automatically if prompt changes.
+     */
+    updateInstruction: typeof api.updateInstruction;
+    /**
+     * Deletes an instruction permanently
+     * @param instructionId - The UUID of the instruction to delete
+     * @returns A promise resolving to deletion confirmation
+     * @throws {Error} If the instruction is not found or user doesn't have access
+     *
+     * @description
+     * Permanently deletes an instruction. This action cannot be undone.
+     */
+    deleteInstruction: typeof api.deleteInstruction;
+    /**
+     * Sets an instruction as the default
+     * @param instructionId - The UUID of the instruction to set as default
+     * @returns A promise resolving to the updated instruction
+     * @throws {Error} If the instruction is not found
+     *
+     * @description
+     * Sets the specified instruction as the default.
+     * All other instructions for this user are automatically set to is_default: false.
+     * This operation is idempotent.
+     */
+    setDefaultInstruction: typeof api.setDefaultInstruction;
 };
 
 /**
@@ -2093,8 +2752,88 @@ declare function requestPasswordReset(email: string, hashedSecret: string, clien
  */
 declare function requestPlatformPasswordReset(email: string, hashedSecret: string): Promise<void>;
 
+export declare type ResponsesCancelResponse = {
+    id: string;
+    object: "response";
+    created_at: number;
+    status: "cancelled";
+    model: string;
+};
+
+export declare type ResponsesCreateRequest = {
+    model: string;
+    input: string;
+    conversation?: string | {
+        id: string;
+    };
+    previous_response_id?: string;
+    stream?: boolean;
+    metadata?: Record<string, any>;
+};
+
+export declare type ResponsesDeleteResponse = {
+    id: string;
+    object: "response.deleted";
+    deleted: boolean;
+};
+
+export declare type ResponsesListParams = {
+    limit?: number;
+    after?: string;
+    before?: string;
+    order?: string;
+};
+
+export declare type ResponsesListResponse = {
+    object: "list";
+    data: ThreadListItem[];
+    has_more: boolean;
+    first_id?: string;
+    last_id?: string;
+};
+
+export declare type ResponsesRetrieveResponse = {
+    id: string;
+    object: "response";
+    created_at: number;
+    status: "queued" | "in_progress" | "completed" | "failed" | "cancelled";
+    model: string;
+    usage?: {
+        input_tokens: number;
+        input_tokens_details: {
+            cached_tokens: number;
+        };
+        output_tokens: number;
+        output_tokens_details: {
+            reasoning_tokens: number;
+        };
+        total_tokens: number;
+    };
+    output?: string;
+};
+
 declare function setApiUrl(url: string): void;
 
+/**
+ * Sets an instruction as the default
+ * @param instructionId - The UUID of the instruction to set as default
+ * @returns A promise resolving to the updated instruction
+ * @throws {Error} If:\n * - The user is not authenticated
+ * - The instruction is not found (404)
+ *
+ * @description
+ * This function sets the specified instruction as the default.
+ * All other instructions for this user are automatically set to is_default: false.
+ * This operation is idempotent - calling it on an already-default instruction succeeds.
+ *
+ * @example
+ * ```typescript
+ * const instruction = await setDefaultInstruction("550e8400-e29b-41d4-a716-446655440000");
+ * console.log(instruction.is_default); // Always true
+ * ```
+ */
+declare function setDefaultInstruction(instructionId: string): Promise<Instruction>;
+
 declare function setPlatformApiUrl(url: string): void;
 
 declare type SigningAlgorithm = "schnorr" | "ecdsa";
@@ -2162,6 +2901,14 @@ declare type ThirdPartyTokenResponse = {
     token: string;
 };
 
+declare type ThreadListItem = {
+    id: string;
+    object: "thread";
+    created_at: number;
+    updated_at: number;
+    title: string;
+};
+
 /**
  * Transcribes audio using the Whisper API
  * @param file - The audio file to transcribe (File or Blob object)
@@ -2198,8 +2945,53 @@ declare type ThirdPartyTokenResponse = {
  */
 declare function transcribeAudio(file: File | Blob, model?: string, language?: string, prompt?: string, temperature?: number, apiKey?: string): Promise<WhisperTranscriptionResponse>;
 
+/**
+ * @deprecated Use openai.conversations.update() instead
+ * Updates a conversation's metadata
+ * @param conversationId - The UUID of the conversation to update
+ * @param metadata - The metadata to update
+ * @returns A promise resolving to the updated conversation
+ * @throws {Error} If:
+ * - The user is not authenticated
+ * - The conversation is not found
+ * - The user doesn't have access to the conversation
+ *
+ * @example
+ * ```typescript
+ * const updated = await updateConversation("550e8400-e29b-41d4-a716-446655440000", {
+ *   metadata: { title: "Updated Title", status: "resolved" }
+ * });
+ * ```
+ */
+declare function updateConversation(conversationId: string, metadata: Record<string, any>): Promise<Conversation>;
+
 declare function updateEmailSettings(orgId: string, projectId: string, settings: EmailSettings): Promise<EmailSettings>;
 
+/**
+ * Updates an existing instruction
+ * @param instructionId - The UUID of the instruction to update
+ * @param request - The fields to update
+ * @returns A promise resolving to the updated instruction
+ * @throws {Error} If:\n * - The user is not authenticated
+ * - The instruction is not found (404)
+ * - No fields are provided (400)
+ * - Name or prompt are empty strings (400)
+ *
+ * @description
+ * At least one field must be provided.
+ * If is_default: true is set, all other instructions are automatically set to is_default: false.
+ * The prompt_tokens field is recalculated automatically if prompt changes.
+ *
+ * @example
+ * ```typescript
+ * const updated = await updateInstruction("550e8400-e29b-41d4-a716-446655440000", {
+ *   name: "Updated Name",
+ *   prompt: "Updated prompt text"
+ * });
+ * ```
+ */
+declare function updateInstruction(instructionId: string, request: InstructionUpdateRequest): Promise<Instruction>;
+
 declare function updateMemberRole(orgId: string, userId: string, role: string): Promise<OrganizationMember>;
 
 declare function updateOAuthSettings(orgId: string, projectId: string, settings: OAuthSettings): Promise<OAuthSettings>;