@omnikit-ai/sdk 2.0.10 → 2.2.1

package/dist/index.d.mts

@@ -1,5 +1,70 @@
 export { cleanTokenFromUrl, getAccessToken, isTokenInUrl, removeAccessToken, saveAccessToken, setAccessToken } from './auth-utils.mjs';
 
+/**
+ * Omnikit SDK - Connectors Module
+ *
+ * Provides access to connected external services (Slack, Google Calendar, Notion, etc.)
+ * Like Base44's connectors module - allows backend functions to get access tokens
+ * for making direct API calls to external services.
+ *
+ * SECURITY: getAccessToken requires service token authentication.
+ * Only available to backend functions, not frontend code.
+ */
+type ConnectorType = 'slack' | 'google_calendar' | 'gmail' | 'notion' | 'salesforce';
+interface ConnectorAccessTokenResponse {
+    success: boolean;
+    access_token: string;
+    connector_type: string;
+    external_workspace_id?: string;
+    external_workspace_name?: string;
+}
+interface ConnectorStatusResponse {
+    success: boolean;
+    connector?: {
+        connector_type: string;
+        status: string;
+        external_workspace_id?: string;
+        external_workspace_name?: string;
+        external_user_email?: string;
+    };
+}
+interface ConnectorsModule$1 {
+    /**
+     * Get access token for a connector.
+     *
+     * SECURITY: Requires service token authentication.
+     * Only available in backend functions, not frontend code.
+     *
+     * @example
+     * ```typescript
+     * // In a backend function
+     * const { access_token } = await omnikit.connectors.getAccessToken('slack');
+     *
+     * // Make direct Slack API call
+     * const response = await fetch('https://slack.com/api/chat.postMessage', {
+     *   method: 'POST',
+     *   headers: {
+     *     'Authorization': `Bearer ${access_token}`,
+     *     'Content-Type': 'application/json',
+     *   },
+     *   body: JSON.stringify({
+     *     channel: '#general',
+     *     text: 'Hello from Omnikit!'
+     *   })
+     * });
+     * ```
+     */
+    getAccessToken(connectorType: ConnectorType): Promise<ConnectorAccessTokenResponse>;
+    /**
+     * Check if a connector is connected.
+     */
+    isConnected(connectorType: ConnectorType): Promise<boolean>;
+    /**
+     * Get connector status and info.
+     */
+    getStatus(connectorType: ConnectorType): Promise<ConnectorStatusResponse>;
+}
+
 /**
  * Omnikit SDK Type Definitions v2.0
  */
@@ -235,6 +300,53 @@ 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>;
+}
 interface LLMParams {
     /** Message-based format for advanced use */
     messages?: LLMMessage[];
@@ -293,6 +405,106 @@ 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>;
+}
+/**
+ * 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
@@ -313,14 +525,63 @@ 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[];
+    /** @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') */
@@ -655,11 +916,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>;
@@ -726,10 +1021,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
@@ -795,6 +1091,48 @@ interface AuthModule {
      */
     onUserChange(callback: (user: UserInfo | null) => void): () => void;
 }
+/**
+ * Connectors module interface for accessing external service tokens.
+ * SECURITY: Only available via client.service for backend functions.
+ */
+interface ConnectorsModule {
+    /**
+     * Get access token for a connector (e.g., Slack, Google Calendar).
+     * SECURITY: Only available in backend functions, not frontend code.
+     *
+     * @example
+     * ```typescript
+     * const omnikit = createServerClient(req);
+     * const { access_token } = await omnikit.service.connectors.getAccessToken('slack');
+     *
+     * // Make direct Slack API call
+     * await fetch('https://slack.com/api/chat.postMessage', {
+     *   headers: { Authorization: `Bearer ${access_token}` },
+     *   body: JSON.stringify({ channel: '#general', text: 'Hello!' })
+     * });
+     * ```
+     */
+    getAccessToken(connectorType: string): Promise<{
+        success: boolean;
+        access_token: string;
+        connector_type: string;
+        external_workspace_id?: string;
+        external_workspace_name?: string;
+    }>;
+    /** Check if a connector is connected */
+    isConnected(connectorType: string): Promise<boolean>;
+    /** Get connector status */
+    getStatus(connectorType: string): Promise<{
+        success: boolean;
+        connector?: {
+            connector_type: string;
+            status: string;
+            external_workspace_id?: string;
+            external_workspace_name?: string;
+            external_user_email?: string;
+        };
+    }>;
+}
 /**
  * Service role client interface (elevated admin operations)
  * Available when serviceToken is provided in config
@@ -808,6 +1146,17 @@ interface ServiceRoleClient {
     services: Record<string, IntegrationMethod>;
     /** @deprecated Use services instead. Integration operations with service role privileges */
     integrations: Record<string, Record<string, IntegrationMethod>>;
+    /**
+     * Connectors module for accessing external service tokens (Slack, Google Calendar, etc.)
+     * SECURITY: Only available via client.service for backend functions.
+     *
+     * @example
+     * ```typescript
+     * const omnikit = createServerClient(req);
+     * const { access_token } = await omnikit.service.connectors.getAccessToken('slack');
+     * ```
+     */
+    connectors: ConnectorsModule;
 }
 /**
  * Main Omnikit Client interface
@@ -867,11 +1216,36 @@ interface OmnikitClient {
     /** Authentication methods */
     auth: AuthModule;
     /**
-     * Service role operations (admin/elevated privileges)
-     * Only available when serviceToken is provided in config
-     * Throws error if accessed without serviceToken
+     * Service-level operations (elevated privileges).
+     * Only available when serviceToken is provided (e.g., via createServerClient).
+     * Throws error if accessed without serviceToken.
+     *
+     * @example
+     * ```typescript
+     * // In a backend function
+     * const omnikit = createServerClient(req);
+     * const { access_token } = await omnikit.service.connectors.getAccessToken('slack');
+     * ```
+     */
+    service?: ServiceRoleClient;
+    /**
+     * @deprecated Use service instead. Will be removed in next major version.
      */
     asServiceRole?: ServiceRoleClient;
+    /**
+     * Connectors module for accessing external service tokens.
+     *
+     * SECURITY: getAccessToken requires service token authentication.
+     * Prefer using omnikit.service.connectors in backend functions.
+     *
+     * @example
+     * ```typescript
+     * // In a backend function (using service role)
+     * const omnikit = createServerClient(req);
+     * const { access_token } = await omnikit.service.connectors.getAccessToken('slack');
+     * ```
+     */
+    connectors: ConnectorsModule;
     /** @internal */
     getAppMetadata(): Promise<AppSchema>;
     /** @internal */
@@ -1183,6 +1557,7 @@ declare class APIClient implements OmnikitClient {
     private _integrations;
     private _auth;
     private _asServiceRole?;
+    private _connectors?;
     private _metadata;
     private _metadataListeners;
     private _userListeners;
@@ -1269,10 +1644,42 @@ declare class APIClient implements OmnikitClient {
      */
     get auth(): AuthModule;
     /**
-     * Lazy getter for service role operations
-     * Only available when serviceToken is provided
+     * Service-level operations (elevated privileges).
+     * Only available when serviceToken is provided (e.g., via createServerClient).
+     */
+    get service(): ServiceRoleClient;
+    /**
+     * @deprecated Use service instead
      */
     get asServiceRole(): ServiceRoleClient;
+    /**
+     * Lazy getter for connectors module
+     * Like Base44's connectors - provides access to external service tokens
+     *
+     * SECURITY: getAccessToken requires service token authentication.
+     * Only use in backend functions, not frontend code.
+     *
+     * @example
+     * ```typescript
+     * // In a backend function
+     * const { access_token } = await omnikit.connectors.getAccessToken('slack');
+     *
+     * // Make direct Slack API call
+     * const response = await fetch('https://slack.com/api/chat.postMessage', {
+     *   method: 'POST',
+     *   headers: { Authorization: `Bearer ${access_token}` },
+     *   body: JSON.stringify({ channel: '#general', text: 'Hello!' })
+     * });
+     * ```
+     */
+    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
      */
@@ -1480,6 +1887,60 @@ declare class APIClient implements OmnikitClient {
  * ```
  */
 declare function createClient(config: OmnikitConfig): OmnikitClient;
+/**
+ * Request object interface for createServerClient.
+ * Matches Deno/Node HTTP request interface.
+ */
+interface ServerRequest {
+    headers: {
+        get?(name: string): string | null;
+        [key: string]: any;
+    };
+}
+/**
+ * Create an Omnikit client for server-side (backend function) use.
+ *
+ * Extracts authentication tokens from HTTP headers injected by the Omnikit platform:
+ * - Authorization: Bearer <user_jwt> (identifies the user making the request)
+ * - X-Omnikit-Service-Authorization: <service_token> (for privileged operations)
+ * - X-Omnikit-App-Id: <app_id> (identifies the app)
+ * - X-Omnikit-Server-Url: <server_url> (API server URL)
+ *
+ * SECURITY: The service token is injected at runtime by the platform,
+ * ensuring it cannot be leaked through source code.
+ *
+ * @example
+ * ```typescript
+ * // In a backend function (Deno Edge Function)
+ * import { createServerClient } from '@omnikit-ai/sdk';
+ *
+ * Deno.serve(async (req) => {
+ *   const omnikit = createServerClient(req);
+ *
+ *   // Access user data (user JWT auth)
+ *   const currentUser = await omnikit.auth.me();
+ *
+ *   // Access connectors (requires service token)
+ *   const { access_token } = await omnikit.service.connectors.getAccessToken('slack');
+ *
+ *   // Make direct Slack API call
+ *   await fetch('https://slack.com/api/chat.postMessage', {
+ *     headers: { Authorization: `Bearer ${access_token}` },
+ *     body: JSON.stringify({ channel: '#general', text: `Hello from ${currentUser.email}!` })
+ *   });
+ *
+ *   return new Response(JSON.stringify({ success: true }));
+ * });
+ * ```
+ *
+ * @param request - HTTP request object with headers
+ * @returns Omnikit client configured with tokens from headers
+ */
+declare function createServerClient(request: ServerRequest): OmnikitClient;
+/**
+ * @deprecated Use createServerClient instead
+ */
+declare const createClientFromRequest: typeof createServerClient;
 
 /**
  * Live Voice Session Implementation
@@ -1561,4 +2022,103 @@ declare class LiveVoiceSessionImpl implements LiveVoiceSession {
     private cleanup;
 }
 
-export { APIClient, 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 EmailParams, type Entity, type EntityClass, type EntityDefinition, type EntityField, type EntityRecord, 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, createClient };
+/**
+ * Omnikit Analytics Module
+ *
+ * Provides automatic event tracking for generated apps.
+ * Supports page views, errors, auth events, and custom events.
+ *
+ * @example
+ * ```typescript
+ * import { Analytics } from '@omnikit/sdk';
+ *
+ * const analytics = new Analytics({
+ *   appId: 'your-app-id',
+ *   apiUrl: 'https://api.omnikit.ai'
+ * });
+ *
+ * // Log events
+ * analytics.logPageView('/dashboard');
+ * analytics.logEvent('button_click', { action: 'submit' });
+ * ```
+ */
+interface EventPayload {
+    page_name?: string;
+    action?: string;
+    inputs?: Record<string, any>;
+    metadata?: Record<string, any>;
+    error_message?: string;
+    error_stack?: string;
+}
+interface AnalyticsConfig {
+    appId: string;
+    apiUrl: string;
+    sessionId?: string;
+    userId?: string;
+    enabled?: boolean;
+}
+declare class Analytics {
+    private config;
+    private sessionId;
+    private userId?;
+    private eventQueue;
+    private flushTimer?;
+    private enabled;
+    constructor(config: AnalyticsConfig);
+    private initSession;
+    private generateId;
+    private saveSession;
+    /**
+     * Get the current session ID
+     */
+    getSessionId(): string;
+    /**
+     * Start a new session (e.g., after logout)
+     */
+    startNewSession(): string;
+    /**
+     * Associate events with a user ID
+     */
+    setUserId(userId: string): void;
+    /**
+     * Clear user association (e.g., on logout)
+     */
+    clearUserId(): void;
+    /**
+     * Log a custom event
+     */
+    logEvent(eventType: string, payload?: EventPayload): Promise<void>;
+    /**
+     * Log a page view event
+     */
+    logPageView(pageName: string, metadata?: Record<string, any>): Promise<void>;
+    /**
+     * Log an error event
+     */
+    logError(error: Error, componentStack?: string): Promise<void>;
+    /**
+     * Log an API error event
+     */
+    logApiError(endpoint: string, statusCode: number, errorMessage: string, metadata?: Record<string, any>): Promise<void>;
+    private startFlushTimer;
+    /**
+     * Flush all queued events to the server
+     */
+    flush(): Promise<void>;
+    private sendEvent;
+    /**
+     * Enable or disable analytics
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if analytics is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}
+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 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 QueryOptions, type RequestOptions, type SMSParams, type ServiceDefinition, type ServiceResponse, type ServiceRoleClient, type ServicesSchema, type SpeechParams, type TemplateDefinition, 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 };