@omnikit-ai/sdk 2.2.0 → 2.2.2

package/dist/index.d.mts

@@ -10,7 +10,7 @@ export { cleanTokenFromUrl, getAccessToken, isTokenInUrl, removeAccessToken, sav
  * SECURITY: getAccessToken requires service token authentication.
  * Only available to backend functions, not frontend code.
  */
-type ConnectorType = 'slack' | 'google_calendar' | 'notion' | 'salesforce';
+type ConnectorType = 'slack' | 'google_calendar' | 'gmail' | 'notion' | 'salesforce';
 interface ConnectorAccessTokenResponse {
     success: boolean;
     access_token: string;
@@ -178,7 +178,30 @@ interface AppSchema {
     platform_version?: number;
 }
 /**
- * MongoDB-style list options (Mongoose-compatible)
+ * Paginated response for cursor-based pagination (Google/Notion style)
+ * Returned by list() and filter() methods
+ *
+ * @example
+ * ```typescript
+ * // First page
+ * const page1 = await Task.list({}, { limit: 100 });
+ * // page1 = { data: [...], hasMore: true, nextCursor: "abc123" }
+ *
+ * // Next page
+ * const page2 = await Task.list({}, { limit: 100, after: page1.nextCursor });
+ * // page2 = { data: [...], hasMore: false, nextCursor: null }
+ * ```
+ */
+interface PaginatedResult<T = CollectionRecord> {
+    /** Array of records for this page */
+    data: T[];
+    /** Whether there are more records after this page */
+    hasMore: boolean;
+    /** Cursor to pass to 'after' parameter for next page (null if no more pages) */
+    nextCursor: string | null;
+}
+/**
+ * MongoDB-style list options with cursor-based pagination
  * Used in the second parameter of list(filter, options)
  *
  * @example
@@ -189,17 +212,29 @@ interface AppSchema {
  * // Sort descending by timestamp
  * await Entity.list({}, { sort: { timestamp: -1 } })
  *
- * // With pagination
+ * // Cursor-based pagination (RECOMMENDED for large datasets)
+ * const page1 = await Entity.list({}, { limit: 100 });
+ * const page2 = await Entity.list({}, { limit: 100, after: page1.nextCursor });
+ *
+ * // Legacy offset pagination (still supported)
  * await Entity.list({}, { sort: { created_at: -1 }, limit: 20, offset: 10 })
  * ```
  */
 interface ListOptions {
     /** Sort order: { field: 1 } for ascending, { field: -1 } for descending. Also accepts string format: 'field' or '-field' */
     sort?: Record<string, 1 | -1> | string;
-    /** Maximum number of results to return */
+    /** Maximum number of results to return (default: 100) */
     limit?: number;
-    /** Number of results to skip (for pagination) */
+    /**
+     * Number of results to skip (for offset-based pagination)
+     * @deprecated Use 'after' cursor for better performance on large datasets
+     */
     offset?: number;
+    /**
+     * Cursor for pagination - pass nextCursor from previous response
+     * More efficient than offset for large datasets (O(1) vs O(n))
+     */
+    after?: string;
 }
 /**
  * @deprecated Use separate filter and ListOptions parameters instead
@@ -300,6 +335,80 @@ interface LLMMessage {
  * - Legacy aliases: 'gemini-flash', 'gemini-pro', 'gemini-pro-3' (for backward compatibility)
  */
 type LLMModel = 'gemini-2.5-flash-lite' | 'gemini-2.5-flash' | 'gemini-2.5-pro' | 'gemini-3-flash' | 'gemini-3-pro' | 'gemini-flash' | 'gemini-pro' | 'gemini-pro-3';
+/**
+ * Parameter definition for a tool (OpenAPI/Gemini compatible format)
+ */
+interface ToolParameter {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+        items?: {
+            type: string;
+        };
+    }>;
+    required?: string[];
+}
+/**
+ * Tool definition for LLM function calling.
+ *
+ * @example
+ * ```typescript
+ * const markStepTool: ToolDefinition = {
+ *   name: 'mark_step_complete',
+ *   description: 'Mark a workshop step as completed',
+ *   parameters: {
+ *     type: 'object',
+ *     properties: {
+ *       step_id: { type: 'string', description: 'The step ID' },
+ *       summary: { type: 'string', description: 'Summary of completion' }
+ *     },
+ *     required: ['step_id', 'summary']
+ *   }
+ * };
+ * ```
+ */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolParameter;
+}
+/**
+ * A tool call returned by the LLM during streaming or in response
+ */
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, any>;
+}
+/**
+ * Configuration for server-side persistence of LLM results.
+ * When provided, the backend automatically saves the result to the specified collection,
+ * ensuring data is not lost if the user navigates away before polling completes.
+ *
+ * @example
+ * ```typescript
+ * await invokeLLM({
+ *   prompt: 'Analyze this data...',
+ *   saveResult: {
+ *     collection: 'analysis_results',
+ *     field: 'result',
+ *     additionalFields: { status: 'completed' }
+ *   }
+ * });
+ * ```
+ */
+interface SaveResultConfig {
+    /** Collection name to save the result to */
+    collection: string;
+    /** Document ID to update. If omitted, creates a new document */
+    documentId?: string;
+    /** Field name to save the LLM result to (default: 'content') */
+    field?: string;
+    /** Additional fields to include when creating/updating the document */
+    additionalFields?: Record<string, any>;
+}
 interface LLMParams {
     /** Message-based format for advanced use */
     messages?: LLMMessage[];
@@ -358,6 +467,125 @@ interface LLMParams {
      * @param error - The error that occurred
      */
     onError?: (error: Error) => void;
+    /**
+     * Tool definitions for function calling.
+     * When provided, the LLM can request tool calls which are executed client-side.
+     *
+     * @example
+     * ```typescript
+     * await omnikit.services.InvokeLLM({
+     *   messages: [...],
+     *   stream: true,
+     *   tools: [{
+     *     name: 'mark_step_complete',
+     *     description: 'Mark a step as completed',
+     *     parameters: {
+     *       type: 'object',
+     *       properties: {
+     *         step_id: { type: 'string', description: 'Step ID' }
+     *       },
+     *       required: ['step_id']
+     *     }
+     *   }],
+     *   onToolCall: async (toolCall) => {
+     *     if (toolCall.name === 'mark_step_complete') {
+     *       await markStepComplete(toolCall.arguments.step_id);
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    tools?: ToolDefinition[];
+    /**
+     * Callback when LLM requests a tool call (fires during streaming).
+     * Handle the tool execution and optionally continue the conversation.
+     *
+     * @param toolCall - The tool call with id, name, and arguments
+     */
+    onToolCall?: (toolCall: ToolCall) => void | Promise<void>;
+    /**
+     * Server-side persistence configuration.
+     * When provided, the backend saves the LLM result directly to the app's database,
+     * ensuring data is not lost if the user navigates away before polling completes.
+     *
+     * @example
+     * ```typescript
+     * await invokeLLM({
+     *   prompt: 'Analyze this data...',
+     *   saveResult: {
+     *     collection: 'analysis_results',
+     *     field: 'result',
+     *     additionalFields: { status: 'completed' }
+     *   }
+     * });
+     * // Result is saved server-side even if user navigates away!
+     * ```
+     */
+    saveResult?: SaveResultConfig;
+}
+/**
+ * Grounding chunk from Google Search results
+ */
+interface GroundingChunk {
+    /** Web source */
+    web?: {
+        /** URL of the source */
+        uri: string;
+        /** Title of the source */
+        title: string;
+    };
+}
+/**
+ * Grounding support linking text segments to sources
+ */
+interface GroundingSupport {
+    /** Text segment in the response */
+    segment?: {
+        startIndex: number;
+        endIndex: number;
+        text: string;
+    };
+    /** Indices into groundingChunks array */
+    groundingChunkIndices?: number[];
+}
+/**
+ * Metadata from Google Search grounding
+ */
+interface GroundingMetadata {
+    /** Search queries that were executed */
+    webSearchQueries?: string[];
+    /** HTML/CSS for search suggestions widget (per Gemini API ToS) */
+    searchEntryPoint?: {
+        renderedContent: string;
+    };
+    /** Source chunks from web search */
+    groundingChunks?: GroundingChunk[];
+    /** Text-to-source mappings for citations */
+    groundingSupports?: GroundingSupport[];
+    /** Items array (alternative format) */
+    items?: any[];
+}
+/**
+ * URL retrieval status
+ */
+type UrlRetrievalStatus = 'URL_RETRIEVAL_STATUS_SUCCESS' | 'URL_RETRIEVAL_STATUS_UNSAFE' | 'URL_RETRIEVAL_STATUS_FAILED' | 'URL_RETRIEVAL_STATUS_UNSPECIFIED';
+/**
+ * Metadata for a single URL context retrieval
+ */
+interface UrlMetadata {
+    /** The URL that was retrieved */
+    retrieved_url: string;
+    /** Status of the retrieval */
+    url_retrieval_status: UrlRetrievalStatus;
+}
+/**
+ * Metadata from URL context tool
+ */
+interface UrlContextMetadata {
+    /** Array of URL metadata for each URL processed */
+    url_metadata?: UrlMetadata[];
+    /** Items array (alternative format) */
+    items?: any[];
 }
 /**
  * Result from streaming LLM completion
@@ -378,14 +606,71 @@ interface LLMStreamResult {
     /** Whether files were in the input */
     has_files?: boolean;
 }
+/**
+ * Full LLM response (non-streaming)
+ */
+interface LLMResponse {
+    /** Whether the request was successful */
+    success: boolean;
+    /** Response content (string or parsed JSON when response_format is used) */
+    result: any;
+    /** Model that was used */
+    model_used: string;
+    /** Whether images were in the input */
+    has_images?: boolean;
+    /** Whether files were in the input */
+    has_files?: boolean;
+    /** Whether Google Search grounding was used */
+    google_search_used?: boolean;
+    /** Whether URL context was used */
+    url_context_used?: boolean;
+    /** Number of continuation requests made for long outputs */
+    continuation_count?: number;
+    /** Token usage statistics */
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    /**
+     * Grounding metadata from Google Search (when google_search: true)
+     * Contains search queries, source URLs, and text-to-source mappings for citations
+     */
+    grounding_metadata?: GroundingMetadata;
+    /**
+     * URL context metadata (when url_context: true)
+     * Contains info about which URLs were retrieved and their status
+     */
+    url_context_metadata?: UrlContextMetadata;
+    /**
+     * Tool calls requested by the LLM (when tools are provided).
+     * In streaming mode, these are delivered via onToolCall callback.
+     * In non-streaming mode, they are included in the response.
+     */
+    tool_calls?: ToolCall[];
+    /**
+     * Server-side save result (when saveResult was provided in the request).
+     * Contains the collection and document ID where the result was saved.
+     */
+    saved_to?: {
+        collection: string;
+        document_id: string;
+    };
+    /** @deprecated Use google_search_used instead */
+    web_search_used?: boolean;
+}
 /**
  * SSE event types for LLM streaming
  */
 interface LLMStreamEvent {
     /** Event type */
-    type: 'token' | 'done' | 'error';
+    type: 'token' | 'done' | 'error' | 'tool_call';
     /** Token content (for type: 'token') */
     content?: string;
+    /** Tool call data (for type: 'tool_call') */
+    id?: string;
+    name?: string;
+    arguments?: Record<string, any>;
     /** Complete result (for type: 'done') */
     result?: string;
     /** Model used (for type: 'done') */
@@ -720,11 +1005,45 @@ interface BuiltInIntegration {
     SendSMS(params: SMSParams): Promise<ServiceResponse>;
     /**
      * Invoke LLM for text/vision/file processing
-     * @param params - LLM parameters
+     *
+     * Features:
+     * - Multi-modal inputs: text, images, PDFs, videos, audio, YouTube URLs
+     * - Google Search grounding: Enable `google_search: true` for real-time web data
+     * - URL context: Enable `url_context: true` to have the model read URLs in your prompt
+     * - Streaming: Enable `stream: true` with callbacks for real-time token output
+     * - JSON output: Use `response_format: { type: 'json_object' }` for structured responses
+     *
+     * @param params - LLM parameters including messages, google_search, url_context, etc.
      * @param options - Async options for handling long-running operations
-     * @returns Result or AsyncJobCreatedResponse (if async_mode or returnJobId)
+     * @returns LLMResponse with result, grounding_metadata, and url_context_metadata
+     *
+     * @example Basic usage
+     * ```typescript
+     * const response = await InvokeLLM({ prompt: 'Hello, world!' });
+     * console.log(response.result);
+     * ```
+     *
+     * @example With Google Search grounding
+     * ```typescript
+     * const response = await InvokeLLM({
+     *   prompt: 'What are the latest AI news?',
+     *   google_search: true
+     * });
+     * console.log(response.result);
+     * console.log(response.grounding_metadata?.groundingChunks); // Source URLs
+     * ```
+     *
+     * @example With URL context
+     * ```typescript
+     * const response = await InvokeLLM({
+     *   prompt: 'Summarize the content at https://example.com/article',
+     *   url_context: true
+     * });
+     * console.log(response.result);
+     * console.log(response.url_context_metadata?.url_metadata); // Retrieval status
+     * ```
      */
-    InvokeLLM(params: LLMParams, options?: AsyncOptions): Promise<ServiceResponse | AsyncJobCreatedResponse>;
+    InvokeLLM(params: LLMParams, options?: AsyncOptions): Promise<LLMResponse | AsyncJobCreatedResponse>;
     UploadFile(params: {
         file: File;
         metadata?: Record<string, any>;
@@ -791,10 +1110,11 @@ interface AuthModule {
      */
     me(): Promise<UserInfo>;
     /**
-     * Redirect to platform login page
-     * @param returnPath - Path to return to after login
+     * Redirect to platform login page, or navigate directly if already authenticated.
+     * Smart login: checks auth state first, only shows modal if not logged in.
+     * @param returnPath - Path to return to after login (relative paths are resolved to absolute)
      */
-    login(returnPath?: string): void;
+    login(returnPath?: string): void | Promise<void>;
     /**
      * Request a passwordless login code to email
      * @param email - User email
@@ -1168,6 +1488,156 @@ interface IntegrationPackage {
 interface IntegrationSchema {
     installed_packages: IntegrationPackage[];
 }
+/**
+ * Message in an assistant thread
+ */
+interface AssistantMessage {
+    role: 'user' | 'assistant' | 'tool';
+    content: string;
+}
+/**
+ * Action call made by the assistant during execution
+ */
+interface AssistantActionCall {
+    id: string;
+    name: string;
+    arguments: Record<string, any>;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    output?: any;
+    error?: string;
+}
+/**
+ * Parameters for running an assistant
+ */
+interface AssistantRunParams {
+    /**
+     * Messages to send to the assistant
+     */
+    messages: AssistantMessage[];
+    /**
+     * Optional thread ID to continue an existing conversation.
+     * If not provided, a new thread will be created.
+     */
+    threadId?: string;
+    /**
+     * Callback when a text token is received during streaming
+     */
+    onToken?: (token: string) => void;
+    /**
+     * Callback when an action starts executing
+     */
+    onActionStart?: (action: {
+        id: string;
+        name: string;
+        arguments: Record<string, any>;
+    }) => void;
+    /**
+     * Callback when an action completes successfully
+     */
+    onActionComplete?: (action: {
+        id: string;
+        name: string;
+        output: any;
+    }) => void;
+    /**
+     * Callback when an action fails
+     */
+    onActionFailed?: (action: {
+        id: string;
+        name: string;
+        error: string;
+    }) => void;
+    /**
+     * Callback when the run completes
+     */
+    onComplete?: (result: AssistantRunResult) => void;
+    /**
+     * Callback when an error occurs
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result from running an assistant
+ */
+interface AssistantRunResult {
+    /** Thread ID (for continuing the conversation) */
+    threadId: string;
+    /** Number of messages in the thread */
+    messageCount: number;
+    /** Full response text from the assistant */
+    response: string;
+}
+/**
+ * Callbacks for thread subscription via WebSocket
+ */
+interface ThreadSubscriptionCallbacks {
+    /**
+     * Called when connection is established
+     */
+    onConnected?: (info: {
+        threadId: string;
+        assistantName: string;
+        messageCount: number;
+    }) => void;
+    /**
+     * Called when a text token is received
+     */
+    onToken?: (token: string) => void;
+    /**
+     * Called when an action starts
+     */
+    onActionStart?: (action: {
+        id: string;
+        name: string;
+        arguments: Record<string, any>;
+    }) => void;
+    /**
+     * Called when an action completes
+     */
+    onActionComplete?: (action: {
+        id: string;
+        name: string;
+        output: any;
+    }) => void;
+    /**
+     * Called when an action fails
+     */
+    onActionFailed?: (action: {
+        id: string;
+        name: string;
+        error: string;
+    }) => void;
+    /**
+     * Called when the run completes
+     */
+    onRunComplete?: (result: {
+        threadId: string;
+        messageCount: number;
+    }) => void;
+    /**
+     * Called when an error occurs
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when connection closes
+     */
+    onDisconnect?: () => void;
+}
+/**
+ * SSE event types for assistant streaming
+ */
+interface AssistantStreamEvent {
+    type: 'token' | 'action_start' | 'action_complete' | 'action_failed' | 'done' | 'error';
+    content?: string;
+    id?: string;
+    name?: string;
+    arguments?: Record<string, any>;
+    output?: any;
+    error?: string;
+    message?: string;
+    thread_id?: string;
+    message_count?: number;
+}
 /**
  * Available voice options for Live Voice AI
  */
@@ -1442,6 +1912,13 @@ declare class APIClient implements OmnikitClient {
      * ```
      */
     get connectors(): ConnectorsModule$1;
+    /**
+     * Resolve a return URL to an absolute URL.
+     * Handles relative paths like "/profile" by combining with current location.
+     * This fixes the OAuth redirect bug where relative URLs like "/profile" become
+     * "https://omnikit.ai/profile" instead of "https://omnikit.ai/app-builder/{id}/preview/profile"
+     */
+    private _resolveReturnUrl;
     /**
      * Create auth proxy that auto-initializes
      */
@@ -1584,6 +2061,63 @@ declare class APIClient implements OmnikitClient {
      * @returns A LiveVoiceSession object to control the session
      */
     createLiveVoiceSession(config?: LiveVoiceConfig): LiveVoiceSession;
+    /**
+     * Run an assistant with streaming response.
+     *
+     * Assistants are server-side AI agents with custom instructions and built-in actions.
+     * They can create/update/delete records, send emails, make HTTP requests, etc.
+     *
+     * @example
+     * ```typescript
+     * const result = await omnikit.runAssistant('customer_support', {
+     *   messages: [{ role: 'user', content: 'Help me track my order #12345' }],
+     *   onToken: (token) => setResponse(prev => prev + token),
+     *   onActionStart: (action) => console.log(`Starting: ${action.name}`),
+     *   onActionComplete: (action) => console.log(`Completed: ${action.name}`),
+     * });
+     *
+     * // Continue the conversation
+     * await omnikit.runAssistant('customer_support', {
+     *   messages: [{ role: 'user', content: 'When will it arrive?' }],
+     *   threadId: result.threadId,
+     *   onToken: (token) => setResponse(prev => prev + token),
+     * });
+     * ```
+     *
+     * @param assistantName - Name of the assistant to run
+     * @param params - Run parameters including messages and callbacks
+     * @returns Promise resolving to the run result with threadId
+     */
+    runAssistant(assistantName: string, params: AssistantRunParams): Promise<AssistantRunResult>;
+    /**
+     * Subscribe to a thread via WebSocket for real-time updates.
+     *
+     * Use this to watch a thread without triggering a run. Useful for:
+     * - Showing live updates when another client runs the assistant
+     * - Reconnecting after page navigation
+     * - Observing thread activity in real-time
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to a thread
+     * const unsubscribe = omnikit.subscribeToThread(threadId, {
+     *   onConnected: (info) => console.log(`Connected to ${info.assistantName}`),
+     *   onToken: (token) => setResponse(prev => prev + token),
+     *   onActionStart: (action) => console.log(`Action: ${action.name}`),
+     *   onActionComplete: (action) => console.log(`Result: ${JSON.stringify(action.output)}`),
+     *   onRunComplete: (result) => console.log(`Run complete, ${result.messageCount} messages`),
+     *   onError: (error) => console.error(error),
+     * });
+     *
+     * // Later: disconnect
+     * unsubscribe();
+     * ```
+     *
+     * @param threadId - Thread ID to subscribe to
+     * @param callbacks - Event callbacks for real-time updates
+     * @returns Unsubscribe function to close the WebSocket
+     */
+    subscribeToThread(threadId: string, callbacks: ThreadSubscriptionCallbacks): () => void;
     /**
      * Invoke a backend function by name.
      *
@@ -1883,4 +2417,4 @@ declare class Analytics {
 }
 declare function createAnalytics(config: AnalyticsConfig): Analytics;
 
-export { APIClient, Analytics, type AnalyticsConfig, type AppMetadata, type AppSchema, type AsyncJobCreatedResponse, type AsyncJobStatus, type AsyncJobStatusResponse, type AsyncJobType, type AsyncOptions, type AuthModule, type AuthResponse, type BuiltInIntegration, type BulkResult, type CachedMetadata, type CheckJobStatusParams, type CollectionClass, type CollectionDefinition, type CollectionField, type CollectionRecord, type ConnectorAccessTokenResponse, type ConnectorStatusResponse, type ConnectorType, type ConnectorsModule, type EmailParams, type Entity, type EntityClass, type EntityDefinition, type EntityField, type EntityRecord, type EventPayload, type ExtractParams, type ImageParams, type ImportResult, type InitialMetadata, type IntegrationEndpoint, type IntegrationMethod, type IntegrationPackage, type IntegrationSchema, type LLMMessage, type LLMModel, type LLMParams, type LLMStreamEvent, type LLMStreamResult, type ListOptions, type LiveVoiceClientMessage, type LiveVoiceConfig, type LiveVoiceServerMessage, type LiveVoiceSession, LiveVoiceSessionImpl, type LiveVoiceStatus, type LiveVoiceVoice, type OAuthProvider, type OAuthProvidersResponse, type OmnikitClient, type OmnikitConfig, OmnikitError, type QueryOptions, type RequestOptions, type SMSParams, type ServiceDefinition, type ServiceResponse, type ServiceRoleClient, type ServicesSchema, type SpeechParams, type TemplateDefinition, type UserCollectionClass, type UserEntityClass, type UserInfo, type VideoParams, type VideoStatusParams, createAnalytics, createClient, createClientFromRequest, createServerClient };
+export { APIClient, Analytics, type AnalyticsConfig, type AppMetadata, type AppSchema, type AssistantActionCall, type AssistantMessage, type AssistantRunParams, type AssistantRunResult, type AssistantStreamEvent, type AsyncJobCreatedResponse, type AsyncJobStatus, type AsyncJobStatusResponse, type AsyncJobType, type AsyncOptions, type AuthModule, type AuthResponse, type BuiltInIntegration, type BulkResult, type CachedMetadata, type CheckJobStatusParams, type CollectionClass, type CollectionDefinition, type CollectionField, type CollectionRecord, type ConnectorAccessTokenResponse, type ConnectorStatusResponse, type ConnectorType, type ConnectorsModule, type EmailParams, type Entity, type EntityClass, type EntityDefinition, type EntityField, type EntityRecord, type EventPayload, type ExtractParams, type GroundingChunk, type GroundingMetadata, type GroundingSupport, type ImageParams, type ImportResult, type InitialMetadata, type IntegrationEndpoint, type IntegrationMethod, type IntegrationPackage, type IntegrationSchema, type LLMMessage, type LLMModel, type LLMParams, type LLMResponse, type LLMStreamEvent, type LLMStreamResult, type ListOptions, type LiveVoiceClientMessage, type LiveVoiceConfig, type LiveVoiceServerMessage, type LiveVoiceSession, LiveVoiceSessionImpl, type LiveVoiceStatus, type LiveVoiceVoice, type OAuthProvider, type OAuthProvidersResponse, type OmnikitClient, type OmnikitConfig, OmnikitError, type PaginatedResult, type QueryOptions, type RequestOptions, type SMSParams, type SaveResultConfig, type ServiceDefinition, type ServiceResponse, type ServiceRoleClient, type ServicesSchema, type SpeechParams, type TemplateDefinition, type ThreadSubscriptionCallbacks, type ToolCall, type ToolDefinition, type ToolParameter, type UrlContextMetadata, type UrlMetadata, type UrlRetrievalStatus, type UserCollectionClass, type UserEntityClass, type UserInfo, type VideoParams, type VideoStatusParams, createAnalytics, createClient, createClientFromRequest, createServerClient };