@yourgpt/copilot-sdk 0.1.0

package/dist/core/index.d.ts

@@ -0,0 +1,870 @@
+import { S as ScreenshotOptions, a as ScreenshotResult, C as ConsoleLogOptions, b as ConsoleLogResult, c as ConsoleLogEntry, N as NetworkRequestOptions, d as NetworkRequestResult, e as NetworkRequestEntry, T as ToolDefinition, f as Source, g as ToolExecutionStatus, h as ToolResponse, J as JSONSchemaProperty, i as ToolInputSchema, j as ToolLocation, k as ToolContext, M as MessageAttachment } from '../thread-C2FjuGLb.js';
+export { ae as AIContent, a3 as AIProvider, ad as AIResponseMode, O as ActionDefinition, K as ActionParameter, Q as ActionRenderProps, ab as AgentLoopConfig, ac as AgentLoopState, v as CapturedContext, E as CloudConfig, q as ConsoleLogType, G as CopilotConfig, w as CustomKeywords, au as DEFAULT_MODELS, F as Extension, H as HttpMethod, I as IntentDetectionResult, Y as InternalKnowledgeBaseConfig, Z as InternalKnowledgeBaseResult, _ as InternalKnowledgeBaseSearchResponse, U as KnowledgeBaseConfig, R as KnowledgeBaseProvider, V as KnowledgeBaseResult, W as KnowledgeBaseSearchRequest, X as KnowledgeBaseSearchResponse, D as LLMConfig, L as LLMProvider, y as Message, z as MessageMetadata, x as MessageRole, P as ParameterType, af as PermissionLevel, ai as PermissionStorageAdapter, ah as PermissionStorageConfig, a1 as PersistenceConfig, $ as Thread, a0 as ThreadData, a2 as ThreadStorageAdapter, B as TokenUsage, a9 as ToolApprovalStatus, A as ToolCall, a5 as ToolConfig, t as ToolConsentRequest, u as ToolConsentResponse, aa as ToolExecution, ag as ToolPermission, a4 as ToolRenderProps, a6 as ToolSet, r as ToolType, s as ToolsConfig, a7 as UnifiedToolCall, a8 as UnifiedToolResult, as as actionToTool, am as createAssistantMessage, p as createCustomDetector, ak as createMessage, ao as createToolCall, an as createToolMessage, ay as createToolResult, al as createUserMessage, l as detectIntent, aA as failure, o as generateSuggestionReason, aj as generateThreadTitle, at as getDefaultModel, n as getPrimaryTool, aq as hasToolCalls, m as hasToolSuggestions, ar as isToolResult, ap as parseToolCallArgs, az as success, av as tool, ax as toolToAnthropicFormat, aw as toolToOpenAIFormat } from '../thread-C2FjuGLb.js';
+
+/**
+ * Screenshot Capture Tool
+ *
+ * Captures screenshots of the current viewport or specific elements.
+ * Uses html2canvas for reliable DOM-to-canvas conversion.
+ */
+
+/**
+ * Capture a screenshot of an element or the viewport
+ *
+ * Uses html2canvas for reliable DOM-to-canvas conversion.
+ * Handles complex CSS, images, flexbox, grid, etc.
+ *
+ * @param options - Screenshot options
+ * @returns Promise resolving to screenshot result
+ *
+ * @example
+ * ```typescript
+ * // Capture viewport
+ * const screenshot = await captureScreenshot();
+ *
+ * // Capture specific element
+ * const screenshot = await captureScreenshot({
+ *   element: document.getElementById('my-element'),
+ *   format: 'jpeg',
+ *   quality: 0.9,
+ * });
+ * ```
+ */
+declare function captureScreenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
+/**
+ * Check if screenshot capture is supported
+ */
+declare function isScreenshotSupported(): boolean;
+/**
+ * Resize a screenshot result
+ */
+declare function resizeScreenshot(screenshot: ScreenshotResult, maxWidth: number, maxHeight: number): Promise<ScreenshotResult>;
+
+/**
+ * Console Log Capture Tool
+ *
+ * Intercepts console methods to capture logs for AI analysis.
+ * Framework-agnostic implementation.
+ */
+
+/**
+ * Start capturing console logs
+ *
+ * @param options - Capture options
+ *
+ * @example
+ * ```typescript
+ * // Start capturing all logs
+ * startConsoleCapture();
+ *
+ * // Capture only errors and warnings
+ * startConsoleCapture({ types: ['error', 'warn'] });
+ *
+ * // Custom filter
+ * startConsoleCapture({
+ *   filter: (entry) => !entry.message.includes('[HMR]')
+ * });
+ * ```
+ */
+declare function startConsoleCapture(options?: ConsoleLogOptions): void;
+/**
+ * Stop capturing console logs
+ */
+declare function stopConsoleCapture(): void;
+/**
+ * Get captured console logs
+ *
+ * @param options - Filter options
+ * @returns Captured log entries
+ *
+ * @example
+ * ```typescript
+ * // Get all captured logs
+ * const { logs } = getConsoleLogs();
+ *
+ * // Get only errors from last minute
+ * const { logs } = getConsoleLogs({
+ *   types: ['error'],
+ *   filter: (entry) => entry.timestamp > Date.now() - 60000
+ * });
+ * ```
+ */
+declare function getConsoleLogs(options?: ConsoleLogOptions): ConsoleLogResult;
+/**
+ * Clear captured console logs
+ */
+declare function clearConsoleLogs(): void;
+/**
+ * Check if console capture is active
+ */
+declare function isConsoleCaptureActive(): boolean;
+/**
+ * Get console errors only (convenience function)
+ */
+declare function getConsoleErrors(limit?: number): ConsoleLogEntry[];
+/**
+ * Get console warnings only (convenience function)
+ */
+declare function getConsoleWarnings(limit?: number): ConsoleLogEntry[];
+/**
+ * Format console logs for AI context
+ *
+ * @param logs - Log entries to format
+ * @returns Formatted string for AI consumption
+ */
+declare function formatLogsForAI(logs: ConsoleLogEntry[]): string;
+/**
+ * Create a one-time capture of current logs
+ * Useful for getting logs without starting persistent capture
+ */
+declare function captureCurrentLogs(options?: ConsoleLogOptions): ConsoleLogResult;
+
+/**
+ * Network Request Capture Tool
+ *
+ * Intercepts fetch and XHR requests to capture network activity.
+ * Framework-agnostic implementation.
+ */
+
+/**
+ * Start capturing network requests
+ *
+ * @param options - Capture options
+ *
+ * @example
+ * ```typescript
+ * // Start capturing failed requests only (default)
+ * startNetworkCapture();
+ *
+ * // Capture all requests
+ * startNetworkCapture({ failedOnly: false });
+ *
+ * // Capture only specific API
+ * startNetworkCapture({
+ *   includeUrls: [/api\.example\.com/],
+ *   failedOnly: false
+ * });
+ * ```
+ */
+declare function startNetworkCapture(options?: NetworkRequestOptions): void;
+/**
+ * Stop capturing network requests
+ */
+declare function stopNetworkCapture(): void;
+/**
+ * Get captured network requests
+ *
+ * @param options - Filter options
+ * @returns Captured requests
+ *
+ * @example
+ * ```typescript
+ * // Get all captured requests
+ * const { requests } = getNetworkRequests();
+ *
+ * // Get only failed POST requests
+ * const { requests } = getNetworkRequests({
+ *   methods: ['POST'],
+ *   failedOnly: true
+ * });
+ * ```
+ */
+declare function getNetworkRequests(options?: NetworkRequestOptions): NetworkRequestResult;
+/**
+ * Clear captured network requests
+ */
+declare function clearNetworkRequests(): void;
+/**
+ * Check if network capture is active
+ */
+declare function isNetworkCaptureActive(): boolean;
+/**
+ * Get failed requests only (convenience function)
+ */
+declare function getFailedRequests(limit?: number): NetworkRequestEntry[];
+/**
+ * Format network requests for AI context
+ *
+ * @param requests - Request entries to format
+ * @returns Formatted string for AI consumption
+ */
+declare function formatRequestsForAI(requests: NetworkRequestEntry[]): string;
+
+/**
+ * Built-in Screenshot Tool
+ *
+ * A pre-configured tool that captures screenshots of the user's viewport.
+ * Can be used with useTools() hook in React.
+ */
+/**
+ * Screenshot tool - captures the user's screen
+ *
+ * @example
+ * ```tsx
+ * import { screenshotTool } from '@yourgpt/copilot-sdk-core';
+ *
+ * // In your component
+ * useTools({
+ *   capture_screenshot: screenshotTool,
+ * });
+ * ```
+ */
+declare const screenshotTool: Omit<ToolDefinition<{
+    quality?: number;
+}>, "name">;
+/**
+ * Create a custom screenshot tool with different options
+ */
+declare function createScreenshotTool(options?: {
+    needsApproval?: boolean;
+    approvalMessage?: string;
+    defaultQuality?: number;
+}): Omit<ToolDefinition<{
+    quality?: number;
+}>, "name">;
+
+/**
+ * Built-in Console Logs Tool
+ *
+ * A pre-configured tool that retrieves browser console logs.
+ * Can be used with useTools() hook in React.
+ */
+/**
+ * Console logs tool - retrieves browser console output
+ *
+ * @example
+ * ```tsx
+ * import { consoleLogsTool } from '@yourgpt/copilot-sdk-core';
+ *
+ * // In your component
+ * useTools({
+ *   get_console_logs: consoleLogsTool,
+ * });
+ * ```
+ */
+declare const consoleLogsTool: Omit<ToolDefinition<{
+    limit?: number;
+    types?: string[];
+}>, "name">;
+/**
+ * Create a custom console logs tool with different options
+ */
+declare function createConsoleLogsTool(options?: {
+    needsApproval?: boolean;
+    approvalMessage?: string;
+    defaultLimit?: number;
+}): Omit<ToolDefinition<{
+    limit?: number;
+    types?: string[];
+}>, "name">;
+
+/**
+ * Built-in Network Requests Tool
+ *
+ * A pre-configured tool that retrieves browser network requests.
+ * Can be used with useTools() hook in React.
+ */
+/**
+ * Network requests tool - retrieves browser network activity
+ *
+ * @example
+ * ```tsx
+ * import { networkRequestsTool } from '@yourgpt/copilot-sdk-core';
+ *
+ * // In your component
+ * useTools({
+ *   get_network_requests: networkRequestsTool,
+ * });
+ * ```
+ */
+declare const networkRequestsTool: Omit<ToolDefinition<{
+    limit?: number;
+    failedOnly?: boolean;
+}>, "name">;
+/**
+ * Create a custom network requests tool with different options
+ */
+declare function createNetworkRequestsTool(options?: {
+    needsApproval?: boolean;
+    approvalMessage?: string;
+    defaultLimit?: number;
+}): Omit<ToolDefinition<{
+    limit?: number;
+    failedOnly?: boolean;
+}>, "name">;
+
+/**
+ * Built-in Tools
+ *
+ * Pre-configured tools for common client-side operations.
+ * These can be registered using the useTools() hook.
+ *
+ * @example
+ * ```tsx
+ * import { builtinTools } from '@yourgpt/copilot-sdk-core';
+ *
+ * // Register all built-in tools
+ * useTools(builtinTools);
+ *
+ * // Or register specific tools
+ * useTools({
+ *   capture_screenshot: builtinTools.capture_screenshot,
+ * });
+ * ```
+ */
+
+/**
+ * All built-in tools as a ToolSet
+ *
+ * @example
+ * ```tsx
+ * import { builtinTools } from '@yourgpt/copilot-sdk-core';
+ *
+ * // Use with useTools hook
+ * useTools(builtinTools);
+ *
+ * // Or spread with custom tools
+ * useTools({
+ *   ...builtinTools,
+ *   my_custom_tool: myTool,
+ * });
+ * ```
+ */
+declare const builtinTools: Record<string, ToolDefinition>;
+
+/**
+ * Stream event types
+ */
+type StreamEventType = "message:start" | "message:delta" | "message:end" | "thinking:start" | "thinking:delta" | "thinking:end" | "source:add" | "action:start" | "action:args" | "action:end" | "tool_calls" | "tool:status" | "tool:result" | "loop:iteration" | "loop:complete" | "error" | "done";
+/**
+ * Base event interface
+ */
+interface BaseEvent {
+    type: StreamEventType;
+}
+/**
+ * Message started streaming
+ */
+interface MessageStartEvent extends BaseEvent {
+    type: "message:start";
+    /** Message ID */
+    id: string;
+}
+/**
+ * Message content delta (incremental update)
+ */
+interface MessageDeltaEvent extends BaseEvent {
+    type: "message:delta";
+    /** Content chunk */
+    content: string;
+}
+/**
+ * Message finished streaming
+ */
+interface MessageEndEvent extends BaseEvent {
+    type: "message:end";
+}
+/**
+ * Thinking/reasoning started (for models like Claude, DeepSeek)
+ */
+interface ThinkingStartEvent extends BaseEvent {
+    type: "thinking:start";
+}
+/**
+ * Thinking content delta (incremental update)
+ */
+interface ThinkingDeltaEvent extends BaseEvent {
+    type: "thinking:delta";
+    /** Thinking content chunk */
+    content: string;
+}
+/**
+ * Thinking finished
+ */
+interface ThinkingEndEvent extends BaseEvent {
+    type: "thinking:end";
+}
+/**
+ * Knowledge base source added
+ */
+interface SourceAddEvent extends BaseEvent {
+    type: "source:add";
+    /** Source document */
+    source: Source;
+}
+/**
+ * Action/tool execution started
+ */
+interface ActionStartEvent extends BaseEvent {
+    type: "action:start";
+    /** Tool call ID */
+    id: string;
+    /** Action name */
+    name: string;
+}
+/**
+ * Action arguments (streaming)
+ */
+interface ActionArgsEvent extends BaseEvent {
+    type: "action:args";
+    /** Tool call ID */
+    id: string;
+    /** Partial arguments JSON */
+    args: string;
+}
+/**
+ * Action execution completed
+ */
+interface ActionEndEvent extends BaseEvent {
+    type: "action:end";
+    /** Tool call ID */
+    id: string;
+    /** Action name */
+    name?: string;
+    /** Result of the action */
+    result?: unknown;
+    /** Error if failed */
+    error?: string;
+}
+/**
+ * Error event
+ */
+interface ErrorEvent extends BaseEvent {
+    type: "error";
+    /** Error message */
+    message: string;
+    /** Error code */
+    code?: string;
+}
+/**
+ * Message format for done event (API format with snake_case)
+ */
+interface DoneEventMessage {
+    role: "assistant" | "tool";
+    content: string | null;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    tool_call_id?: string;
+}
+/**
+ * Stream completed
+ */
+interface DoneEvent extends BaseEvent {
+    type: "done";
+    /**
+     * True when client needs to execute tools and send results in next request
+     * (Vercel AI SDK pattern)
+     */
+    requiresAction?: boolean;
+    /**
+     * All new messages created during this request (for client to append to state)
+     * This includes: assistant messages with tool_calls, tool result messages, final response
+     */
+    messages?: DoneEventMessage[];
+}
+/**
+ * Tool call information for client execution
+ */
+interface ToolCallInfo {
+    /** Unique tool call ID */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Tool arguments (parsed JSON) */
+    args: Record<string, unknown>;
+}
+/**
+ * Assistant message with tool calls (for including in next request)
+ */
+interface AssistantToolMessage {
+    role: "assistant";
+    content: string | null;
+    tool_calls: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+/**
+ * Server detected tool calls - client should execute and send results in next request
+ * (Vercel AI SDK pattern - replaces tool:execute)
+ */
+interface ToolCallsEvent extends BaseEvent {
+    type: "tool_calls";
+    /** Tool calls to execute */
+    toolCalls: ToolCallInfo[];
+    /**
+     * Assistant message to include in next request's messages
+     * This preserves the tool_calls structure for the LLM
+     */
+    assistantMessage: AssistantToolMessage;
+}
+/**
+ * Tool execution status update
+ */
+interface ToolStatusEvent extends BaseEvent {
+    type: "tool:status";
+    /** Tool call ID */
+    id: string;
+    /** Execution status */
+    status: ToolExecutionStatus;
+}
+/**
+ * Tool result received (from client or server)
+ */
+interface ToolResultEvent extends BaseEvent {
+    type: "tool:result";
+    /** Tool call ID */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Tool result */
+    result: ToolResponse;
+}
+/**
+ * Loop iteration progress
+ */
+interface LoopIterationEvent extends BaseEvent {
+    type: "loop:iteration";
+    /** Current iteration number (1-based) */
+    iteration: number;
+    /** Maximum iterations allowed */
+    maxIterations: number;
+}
+/**
+ * Loop completed
+ */
+interface LoopCompleteEvent extends BaseEvent {
+    type: "loop:complete";
+    /** Total iterations executed */
+    iterations: number;
+    /** Whether loop was aborted by user */
+    aborted?: boolean;
+    /** Whether max iterations was reached */
+    maxIterationsReached?: boolean;
+}
+/**
+ * Union of all stream events
+ */
+type StreamEvent = MessageStartEvent | MessageDeltaEvent | MessageEndEvent | ThinkingStartEvent | ThinkingDeltaEvent | ThinkingEndEvent | SourceAddEvent | ActionStartEvent | ActionArgsEvent | ActionEndEvent | ToolCallsEvent | ToolStatusEvent | ToolResultEvent | LoopIterationEvent | LoopCompleteEvent | ErrorEvent | DoneEvent;
+/**
+ * Parse a stream event from JSON
+ */
+declare function parseStreamEvent(data: string): StreamEvent | null;
+/**
+ * Serialize a stream event to JSON
+ */
+declare function serializeStreamEvent(event: StreamEvent): string;
+/**
+ * Format event for SSE
+ */
+declare function formatSSE(event: StreamEvent): string;
+
+/**
+ * Parse SSE stream data
+ */
+declare function parseSSELine(line: string): StreamEvent | null;
+/**
+ * Create an async iterator from SSE response
+ */
+declare function streamSSE(response: Response): AsyncGenerator<StreamEvent, void, undefined>;
+/**
+ * Create SSE response from async generator
+ */
+declare function createSSEStream(generator: AsyncGenerator<StreamEvent, void, undefined>): ReadableStream<Uint8Array>;
+
+/**
+ * Generate a unique ID with optional prefix
+ */
+declare function generateId(prefix?: string): string;
+/**
+ * Generate a message ID
+ */
+declare function generateMessageId(): string;
+/**
+ * Generate a conversation/thread ID
+ */
+declare function generateThreadId(): string;
+/**
+ * Generate a tool call ID
+ */
+declare function generateToolCallId(): string;
+
+/**
+ * Zod to JSON Schema conversion utilities
+ *
+ * Provides helpers to convert Zod schemas to JSON Schema format
+ * for use with LLM tool definitions.
+ */
+
+/**
+ * Convert a Zod schema to JSON Schema property
+ */
+declare function zodToJsonSchema(schema: unknown): JSONSchemaProperty;
+/**
+ * Convert a Zod object schema to ToolInputSchema
+ *
+ * Note: For Zod 4.x+, the react package uses z.toJSONSchema() directly.
+ * This fallback implementation is for older Zod versions.
+ */
+declare function zodObjectToInputSchema(schema: unknown): ToolInputSchema;
+/**
+ * Configuration for defining a tool with Zod schema
+ */
+interface DefineToolConfig<TSchema extends {
+    _output: Record<string, unknown>;
+}> {
+    /** Unique tool name */
+    name: string;
+    /** Tool description for LLM */
+    description: string;
+    /** Where the tool executes */
+    location: ToolLocation;
+    /** Zod schema for parameters */
+    schema: TSchema;
+    /** Handler function */
+    handler?: (params: TSchema["_output"], context?: ToolContext) => Promise<ToolResponse> | ToolResponse;
+    /** Optional render function */
+    render?: (props: {
+        status: "pending" | "executing" | "completed" | "error";
+        args: TSchema["_output"];
+        result?: ToolResponse;
+        error?: string;
+    }) => unknown;
+    /** Whether the tool is available */
+    available?: boolean;
+    /**
+     * Human-readable title for UI display.
+     * Can be a static string or a function that generates title from args.
+     */
+    title?: string | ((args: TSchema["_output"]) => string);
+    /**
+     * Title shown while executing (present tense with "...").
+     */
+    executingTitle?: string | ((args: TSchema["_output"]) => string);
+    /**
+     * Title shown after completion.
+     */
+    completedTitle?: string | ((args: TSchema["_output"]) => string);
+    /**
+     * How the AI should respond when this tool's result is rendered as UI.
+     * - 'none': AI generates minimal response
+     * - 'brief': AI receives summary context, gives brief acknowledgment
+     * - 'full': AI receives complete data (default)
+     */
+    aiResponseMode?: "none" | "brief" | "full";
+    /**
+     * Context/summary sent to AI instead of (or along with) full result.
+     */
+    aiContext?: string | ((result: ToolResponse, args: Record<string, unknown>) => string);
+    /**
+     * Require user approval before execution.
+     * - true: Always require approval
+     * - false: No approval needed (default)
+     * - function: Conditional approval based on input
+     */
+    needsApproval?: boolean | ((params: TSchema["_output"]) => boolean | Promise<boolean>);
+    /**
+     * Custom message shown in the approval UI.
+     */
+    approvalMessage?: string | ((params: TSchema["_output"]) => string);
+}
+/**
+ * Define a tool using a Zod schema
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { defineTool } from "@yourgpt/copilot-sdk-core";
+ *
+ * const navigateTool = defineTool({
+ *   name: "navigate",
+ *   description: "Navigate to a page",
+ *   location: "client",
+ *   schema: z.object({
+ *     path: z.string().describe("The path to navigate to"),
+ *   }),
+ *   handler: async ({ path }) => {
+ *     router.push(path);
+ *     return { success: true, message: `Navigated to ${path}` };
+ *   },
+ * });
+ * ```
+ */
+declare function defineTool<TSchema extends {
+    _output: Record<string, unknown>;
+}>(config: DefineToolConfig<TSchema>): ToolDefinition<TSchema["_output"]>;
+/**
+ * Define a client-side tool using a Zod schema
+ *
+ * Shorthand for defineTool with location: "client".
+ * Client tools run in the browser and can interact with UI.
+ *
+ * @example
+ * ```ts
+ * const navigateTool = defineClientTool({
+ *   name: "navigate",
+ *   description: "Navigate to a page",
+ *   schema: z.object({ path: z.string() }),
+ *   handler: async ({ path }) => {
+ *     router.push(path);
+ *     return { success: true };
+ *   },
+ * });
+ * ```
+ */
+declare function defineClientTool<TSchema extends {
+    _output: Record<string, unknown>;
+}>(config: Omit<DefineToolConfig<TSchema>, "location">): ToolDefinition<TSchema["_output"]>;
+/**
+ * Define a server-side (backend) tool using a Zod schema
+ *
+ * Server tools run on your backend with full access to:
+ * - Environment variables and secrets
+ * - Database connections
+ * - Internal microservices
+ * - External APIs with server-side authentication
+ *
+ * The handler receives a context object with request headers for auth.
+ *
+ * @example
+ * ```ts
+ * const getOrderTool = defineServerTool({
+ *   name: "get_order",
+ *   description: "Get order details by ID",
+ *   schema: z.object({
+ *     orderId: z.string().describe("Order ID"),
+ *   }),
+ *   handler: async ({ orderId }, context) => {
+ *     // Access auth from context
+ *     const token = context?.headers?.authorization;
+ *     if (!token) return failure("Authentication required");
+ *
+ *     const order = await orderService.get(orderId, token);
+ *     return success(order);
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With AI response control
+ * const sensitiveDataTool = defineServerTool({
+ *   name: "get_sensitive_data",
+ *   description: "Fetch sensitive records",
+ *   schema: z.object({ id: z.string() }),
+ *   aiResponseMode: "brief",
+ *   aiContext: (result) => `Retrieved record - displayed to user`,
+ *   handler: async ({ id }) => {
+ *     const data = await db.sensitiveRecords.findUnique({ where: { id } });
+ *     return success(data);
+ *   },
+ * });
+ * ```
+ */
+declare function defineServerTool<TSchema extends {
+    _output: Record<string, unknown>;
+}>(config: Omit<DefineToolConfig<TSchema>, "location">): ToolDefinition<TSchema["_output"]>;
+
+/**
+ * System Prompt Utilities
+ *
+ * Default system message generation for Copilot SDK.
+ */
+/**
+ * Function type for generating system messages
+ */
+type SystemMessageFunction = (contextString: string, additionalInstructions?: string) => string;
+/**
+ * Default system message for Copilot SDK
+ *
+ * @param contextString - Context from useReadable hooks
+ * @param additionalInstructions - Additional instructions from user
+ */
+declare function defaultSystemMessage(contextString: string, additionalInstructions?: string): string;
+
+/**
+ * Cloud Storage Service
+ *
+ * Provides managed file storage for premium users.
+ * Files are uploaded to managed cloud via presigned URLs.
+ */
+
+/**
+ * Upload result from storage service
+ */
+interface UploadResult {
+    /** Public URL of the uploaded file */
+    url: string;
+    /** Expiration timestamp (if applicable) */
+    expiresAt?: number;
+}
+/**
+ * Upload options
+ */
+interface UploadOptions {
+    /** Progress callback */
+    onProgress?: (progress: number) => void;
+}
+/**
+ * Storage service interface
+ */
+interface StorageService {
+    /** Check if cloud storage is available */
+    isAvailable(): boolean;
+    /** Upload file and get URL */
+    upload(file: File, options?: UploadOptions): Promise<UploadResult>;
+}
+/**
+ * Storage configuration
+ */
+interface StorageConfig {
+    /** Cloud API key (must start with "ygpt_" for premium) */
+    apiKey: string;
+    /** Custom API endpoint */
+    endpoint?: string;
+    /** Maximum file size in bytes (default: 25MB for premium) */
+    maxFileSize?: number;
+}
+/** Default max file size for cloud storage (25MB) */
+declare const CLOUD_MAX_FILE_SIZE: number;
+/** Default Cloud API endpoint */
+declare const DEFAULT_YOURGPT_ENDPOINT = "https://api.yourgpt.ai";
+/**
+ * Create managed cloud storage service
+ *
+ * @example
+ * ```ts
+ * const storage = createCloudStorage({
+ *   apiKey: "ygpt_...",
+ * });
+ *
+ * if (storage.isAvailable()) {
+ *   const { url } = await storage.upload(file);
+ *   // url = "https://cdn.yourgpt.ai/..."
+ * }
+ * ```
+ */
+declare function createCloudStorage(config: StorageConfig): StorageService;
+/**
+ * Helper to get attachment type from MIME type
+ */
+declare function getAttachmentTypeFromMime(mimeType: string): "image" | "file" | "audio" | "video";
+/**
+ * Process file to MessageAttachment using storage service
+ *
+ * - If storage is available, uploads to cloud and returns URL-based attachment
+ * - Otherwise, converts to base64 (fallback for free tier)
+ */
+declare function processFileToAttachment(file: File, storage?: StorageService | null): Promise<MessageAttachment>;
+
+export { type ActionArgsEvent, type ActionEndEvent, type ActionStartEvent, type AssistantToolMessage, CLOUD_MAX_FILE_SIZE, ConsoleLogEntry, ConsoleLogOptions, ConsoleLogResult, DEFAULT_YOURGPT_ENDPOINT, type DefineToolConfig, type DoneEvent, type DoneEventMessage, type ErrorEvent, JSONSchemaProperty, type LoopCompleteEvent, type LoopIterationEvent, MessageAttachment, type MessageDeltaEvent, type MessageEndEvent, type MessageStartEvent, NetworkRequestEntry, NetworkRequestOptions, NetworkRequestResult, ScreenshotOptions, ScreenshotResult, Source, type SourceAddEvent, type StorageConfig, type StorageService, type StreamEvent, type StreamEventType, type SystemMessageFunction, type ToolCallInfo, type ToolCallsEvent, ToolContext, ToolDefinition, ToolExecutionStatus, ToolInputSchema, ToolLocation, ToolResponse, type ToolResultEvent, type ToolStatusEvent, type UploadOptions, type UploadResult, builtinTools, captureCurrentLogs, captureScreenshot, clearConsoleLogs, clearNetworkRequests, consoleLogsTool, createCloudStorage, createConsoleLogsTool, createNetworkRequestsTool, createSSEStream, createScreenshotTool, defaultSystemMessage, defineClientTool, defineServerTool, defineTool, formatLogsForAI, formatRequestsForAI, formatSSE, generateId, generateMessageId, generateThreadId, generateToolCallId, getAttachmentTypeFromMime, getConsoleErrors, getConsoleLogs, getConsoleWarnings, getFailedRequests, getNetworkRequests, isConsoleCaptureActive, isNetworkCaptureActive, isScreenshotSupported, networkRequestsTool, parseSSELine, parseStreamEvent, processFileToAttachment, resizeScreenshot, screenshotTool, serializeStreamEvent, startConsoleCapture, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, streamSSE, zodObjectToInputSchema, zodToJsonSchema };