@runtypelabs/sdk 1.7.2 → 1.7.3

package/dist/endpoints.d.ts

@@ -1,1353 +0,0 @@
-/**
- * API endpoint handlers with automatic camelCase/snake_case transformation
- */
-import type { Flow, Prompt, RuntypeRecord, ApiKey, ModelConfig, UserProfile, PaginationResponse, ListParams, RecordListParams, CreateFlowRequest, CreatePromptRequest, CreateRecordRequest, CreateApiKeyRequest, CreateModelConfigRequest, DispatchRequest, BulkEditRequest, BulkEditResponse, Tool, ToolExecution, CreateToolRequest, UpdateToolRequest, ExecuteToolRequest, ExecuteToolResponse, BuiltInTool, ModelUsageResponse, ModelUsageQueryParams, RuntimeTool } from './types';
-import type { ClientToken, CreateClientTokenRequest, CreateClientTokenResponse, UpdateClientTokenRequest, ListConversationsResponse } from './client-token-types';
-import { type ApplyGeneratedProposalOptions, type ApplyGeneratedProposalResult, type AttachRuntimeToolsOptions, type GeneratedRuntimeToolGateDecision, type GeneratedRuntimeToolGateOptions } from './generated-tool-gate';
-export interface ApiClient {
-    get<T>(path: string, params?: {
-        [key: string]: any;
-    }): Promise<T>;
-    post<T>(path: string, data?: any): Promise<T>;
-    put<T>(path: string, data?: any): Promise<T>;
-    patch<T>(path: string, data?: any): Promise<T>;
-    delete<T>(path: string, data?: any): Promise<T>;
-    postFormData<T>(path: string, formData: FormData): Promise<T>;
-    requestStream(path: string, options?: RequestInit): Promise<Response>;
-}
-/**
- * Flows endpoint handlers
- */
-export declare class FlowsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all flows for the authenticated user
-     */
-    list(params?: ListParams): Promise<PaginationResponse<Flow>>;
-    /**
-     * Get a specific flow by ID
-     */
-    get(id: string): Promise<Flow>;
-    /**
-     * Create a new flow
-     */
-    create(data: CreateFlowRequest): Promise<Flow>;
-    /**
-     * Update an existing flow
-     */
-    update(id: string, data: Partial<CreateFlowRequest>): Promise<Flow>;
-    /**
-     * Delete a flow
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Run a flow on all records of a specific type
-     */
-    runOnRecordType(id: string, recordType: string): Promise<any>;
-    /**
-     * Publish flow (promote draft to published)
-     */
-    publish(id: string): Promise<{
-        success: boolean;
-        publishedVersionId: string;
-        message: string;
-    }>;
-}
-/**
- * Prompts endpoint handlers
- */
-export declare class PromptsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all prompts for the authenticated user
-     */
-    list(params?: ListParams & {
-        flowId?: string;
-    }): Promise<PaginationResponse<Prompt>>;
-    /**
-     * Get a specific prompt by ID
-     */
-    get(id: string): Promise<Prompt>;
-    /**
-     * Create a new prompt
-     */
-    create(data: CreatePromptRequest): Promise<Prompt>;
-    /**
-     * Update an existing prompt
-     */
-    update(id: string, data: Partial<CreatePromptRequest>): Promise<Prompt>;
-    /**
-     * Delete a prompt
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Run a prompt on a specific record
-     */
-    runOnRecord(id: string, recordId: string): Promise<any>;
-    /**
-     * Get flows using this prompt
-     */
-    getFlows(id: string): Promise<{
-        flows: any[];
-    }>;
-    /**
-     * Update flow attachments for a prompt
-     */
-    updateFlows(id: string, flowIds: string[]): Promise<{
-        success: boolean;
-        attachedFlows: number;
-    }>;
-}
-/**
- * Records endpoint handlers
- */
-export declare class RecordsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all records for the authenticated user
-     */
-    list(params?: RecordListParams): Promise<PaginationResponse<RuntypeRecord>>;
-    /**
-     * Get a specific record by ID
-     */
-    get(id: string): Promise<RuntypeRecord>;
-    /**
-     * Create a new record
-     */
-    create(data: CreateRecordRequest): Promise<RuntypeRecord>;
-    /**
-     * Update an existing record
-     */
-    update(id: string, data: Partial<CreateRecordRequest>): Promise<RuntypeRecord>;
-    /**
-     * Delete a record
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Bulk delete multiple records
-     */
-    bulkDelete(ids: string[]): Promise<{
-        success: boolean;
-        deleted: number;
-        deletedIds: string[];
-        notFoundIds?: string[];
-    }>;
-    /**
-     * Bulk edit multiple records
-     */
-    bulkEdit(data: BulkEditRequest): Promise<BulkEditResponse>;
-    /**
-     * Get results for a record
-     */
-    getResults(id: string, params?: {
-        flowId?: string;
-        fromDate?: string;
-        toDate?: string;
-    }): Promise<any[]>;
-    /**
-     * Delete a specific result for a record
-     */
-    deleteResult(id: string, resultId: string): Promise<void>;
-    /**
-     * Upload CSV file to create multiple records
-     */
-    uploadCsv(file: File, params?: {
-        typeColumn?: string;
-        nameColumn?: string;
-    }): Promise<any>;
-    /**
-     * Get record types (distinct values)
-     */
-    getTypes(): Promise<{
-        data: string[];
-        total: number;
-    }>;
-    /**
-     * Get example record by type and/or name
-     */
-    getExample(params: {
-        type?: string;
-        name?: string;
-    }): Promise<PaginationResponse<RuntypeRecord>>;
-}
-/**
- * API Keys endpoint handlers
- */
-export declare class ApiKeysEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all API keys for the authenticated user
-     */
-    list(): Promise<ApiKey[]>;
-    /**
-     * Get a specific API key by ID
-     */
-    get(id: string): Promise<ApiKey>;
-    /**
-     * Create a new API key
-     */
-    create(data: CreateApiKeyRequest): Promise<{
-        apiKey: ApiKey;
-        plainKey: string;
-        warning: string;
-    }>;
-    /**
-     * Update an existing API key
-     */
-    update(id: string, data: Partial<CreateApiKeyRequest>): Promise<{
-        apiKey: ApiKey;
-    }>;
-    /**
-     * Delete an API key
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Regenerate an API key
-     */
-    regenerate(id: string): Promise<{
-        apiKey: ApiKey;
-        plainKey: string;
-        warning: string;
-    }>;
-    /**
-     * Get API key analytics
-     */
-    getAnalytics(id: string): Promise<any>;
-    /**
-     * Get usage logs for an API key
-     */
-    getUsage(id: string, params?: {
-        startDate?: string;
-        endDate?: string;
-        limit?: number;
-    }): Promise<any>;
-    /**
-     * Get API key analytics (all keys or specific key)
-     */
-    getAnalyticsEnhanced(apiKeyId: string | 'all', params?: Record<string, string>): Promise<any>;
-    /**
-     * Get API key usage logs (all keys or specific key)
-     */
-    getLogs(apiKeyId: string | 'all', params?: Record<string, string>): Promise<any>;
-    /**
-     * Get API key permission options
-     */
-    getPermissionOptions(): Promise<any>;
-    /**
-     * Get API key security logs
-     */
-    getSecurityLogs(id: string): Promise<any>;
-    /**
-     * Update API key security settings
-     */
-    updateSecurity(id: string, data: any): Promise<any>;
-    /**
-     * Clear suspicious activity for API key
-     */
-    clearSuspiciousActivity(id: string): Promise<any>;
-}
-/**
- * Model Configurations endpoint handlers
- */
-export declare class ModelConfigsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Get available models catalog
-     */
-    getAvailable(): Promise<ModelConfig[]>;
-    /**
-     * Get search-capable models (all available, regardless of user configuration)
-     */
-    getSearchCapable(): Promise<ModelConfig[]>;
-    /**
-     * Get configured search-capable models (only user's configured and enabled models)
-     */
-    getSearchConfigured(): Promise<ModelConfig[]>;
-    /**
-     * List user's model configurations
-     */
-    list(): Promise<ModelConfig[]>;
-    /**
-     * Create a new model configuration
-     */
-    create(data: CreateModelConfigRequest): Promise<ModelConfig>;
-    /**
-     * Update an existing model configuration
-     */
-    update(id: string, data: Partial<CreateModelConfigRequest>): Promise<ModelConfig>;
-    /**
-     * Delete a model configuration
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Enable/disable a model configuration
-     */
-    updateStatus(id: string, isEnabled: boolean): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Set a model configuration as default
-     */
-    setDefault(id: string): Promise<{
-        success: boolean;
-        message: string;
-        data: ModelConfig;
-    }>;
-    /**
-     * Get usage statistics
-     */
-    getUsage(): Promise<any>;
-}
-/**
- * Dispatch endpoint handler for atomic record/flow creation and execution
- */
-export declare class DispatchEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Dispatch: create and/or execute flows on records atomically
-     */
-    execute(data: DispatchRequest): Promise<any>;
-    /**
-     * Dispatch with streaming response
-     */
-    executeStream(data: DispatchRequest): Promise<Response>;
-    /**
-     * Resume paused flow execution
-     * API expects snake_case field names
-     *
-     * @param data.execution_id - The execution ID to resume
-     * @param data.tool_outputs - Tool outputs to inject into the flow
-     * @param data.stream_response - Whether to stream the response
-     * @param data.messages - Optional messages to override the original dispatch messages
-     */
-    resume(data: {
-        executionId: string;
-        toolOutputs?: Record<string, any>;
-        streamResponse?: boolean;
-        messages?: Array<{
-            role: 'system' | 'user' | 'assistant';
-            content: string | Array<{
-                type: string;
-                text?: string;
-                image?: string;
-            }>;
-        }>;
-    }): Promise<any>;
-    /**
-     * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
-     * Useful for local `propose_runtime_tool` handlers before redispatch.
-     */
-    gateGeneratedRuntimeToolProposal(proposal: unknown, options?: GeneratedRuntimeToolGateOptions): GeneratedRuntimeToolGateDecision;
-    /**
-     * Build standardized local-tool output for a generated tool proposal.
-     * Returns `{ approved, reason, violations, tool? }`.
-     */
-    buildGeneratedRuntimeToolGateOutput(proposal: unknown, options?: GeneratedRuntimeToolGateOptions): {
-        approved: boolean;
-        reason: string;
-        violations: string[];
-        tool?: RuntimeTool;
-    };
-    /**
-     * Attach approved runtime tools to a prompt step in a redispatch request.
-     * Returns a new request object and does not mutate the original.
-     */
-    attachApprovedRuntimeTools(request: DispatchRequest, runtimeTools: RuntimeTool[], options?: AttachRuntimeToolsOptions): DispatchRequest;
-    /**
-     * Validate a generated runtime tool proposal and attach it to the redispatch
-     * request if approved, in one call.
-     */
-    applyGeneratedRuntimeToolProposal(request: DispatchRequest, proposal: unknown, options?: ApplyGeneratedProposalOptions): ApplyGeneratedProposalResult;
-}
-/**
- * Chat endpoint handler
- */
-export declare class ChatEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Send a chat message
-     */
-    send(message: string): Promise<any>;
-    /**
-     * Send a chat message with streaming response
-     */
-    sendStream(message: string, options?: any): Promise<Response>;
-}
-/**
- * Users endpoint handlers
- */
-export declare class UsersEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Get current user profile
-     */
-    getProfile(): Promise<UserProfile>;
-    /**
-     * Update user profile
-     */
-    updateProfile(data: Partial<UserProfile>): Promise<UserProfile>;
-}
-/**
- * Analytics endpoint handlers
- */
-export declare class AnalyticsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Get analytics stats
-     */
-    getStats(params?: Record<string, string>): Promise<any>;
-    /**
-     * Get analytics executions
-     */
-    getExecutions(params?: Record<string, string>): Promise<any>;
-    /**
-     * Get all record results (same as executions)
-     */
-    getAllRecordResults(params?: Record<string, string>): Promise<any>;
-    /**
-     * Get model usage analytics
-     */
-    getModelUsage(params?: ModelUsageQueryParams): Promise<ModelUsageResponse>;
-}
-/**
- * Flow Steps endpoint handlers
- *
- * @deprecated Flow steps are now consolidated into the flows endpoint.
- * Use `flows.get(id)` to get a flow with embedded `flowSteps`.
- * Use `flows.update(id, { flow_steps: [...] })` to update flow steps.
- */
-export declare class FlowStepsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Get flow steps for a flow
-     * @deprecated Use `flows.get(flowId)` instead - flow steps are now embedded in the flow response as `flowSteps`
-     */
-    getByFlow(flowId: string): Promise<any[]>;
-    /**
-     * Get a specific flow step
-     * @deprecated Use `flows.get(flowId)` and find the step in `flowSteps` array
-     */
-    get(id: string): Promise<any>;
-    /**
-     * Create a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` to add steps
-     */
-    create(data: any): Promise<any>;
-    /**
-     * Update a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` to update steps
-     */
-    update(id: string, data: any): Promise<any>;
-    /**
-     * Delete a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` with the step removed
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Reorder flow steps
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` with updated order values
-     */
-    reorder(flowId: string, stepOrders: Array<{
-        id: string;
-        order: number;
-    }>): Promise<any>;
-}
-/**
- * Context Templates endpoint handlers
- */
-export declare class ContextTemplatesEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List context templates
-     */
-    list(params?: Record<string, string>): Promise<any[]>;
-    /**
-     * Get a specific context template
-     */
-    get(id: string): Promise<any>;
-    /**
-     * Create a context template
-     */
-    create(data: any): Promise<any>;
-    /**
-     * Update a context template
-     */
-    update(id: string, data: any): Promise<any>;
-    /**
-     * Delete a context template
-     */
-    delete(id: string): Promise<void>;
-}
-/**
- * Tools endpoint handlers
- */
-export declare class ToolsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all tools for the authenticated user
-     */
-    list(params?: ListParams): Promise<PaginationResponse<Tool>>;
-    /**
-     * Get a specific tool by ID
-     */
-    get(id: string): Promise<Tool>;
-    /**
-     * Create a new tool
-     */
-    create(data: CreateToolRequest): Promise<Tool>;
-    /**
-     * Update an existing tool
-     */
-    update(id: string, data: UpdateToolRequest): Promise<Tool>;
-    /**
-     * Delete a tool
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Execute a tool
-     */
-    execute(id: string, data: ExecuteToolRequest): Promise<ExecuteToolResponse>;
-    /**
-     * Execute a tool with streaming response
-     */
-    executeStream(id: string, data: ExecuteToolRequest): Promise<Response>;
-    /**
-     * Test a tool (same as execute but for testing purposes)
-     */
-    test(id: string, data: ExecuteToolRequest): Promise<ExecuteToolResponse>;
-    /**
-     * Get tool executions for a specific tool
-     */
-    getExecutions(toolId: string, params?: ListParams): Promise<PaginationResponse<ToolExecution>>;
-    /**
-     * Get AI SDK compatible tool schemas
-     */
-    getSchemas(params?: {
-        toolIds?: string[];
-    }): Promise<any[]>;
-    /**
-     * Get available tools for prompts
-     */
-    getAvailable(): Promise<Tool[]>;
-    /**
-     * Convert a flow to a tool
-     */
-    convertFromFlow(flowId: string, data: {
-        name: string;
-        description: string;
-        parameterMapping?: Record<string, string>;
-        outputMapping?: string;
-    }): Promise<Tool>;
-    /**
-     * Get all built-in tools
-     */
-    getBuiltInTools(): Promise<PaginationResponse<BuiltInTool>>;
-    /**
-     * Get built-in tools compatible with a specific model and provider
-     */
-    getCompatibleBuiltInTools(model: string, provider: string): Promise<PaginationResponse<BuiltInTool>>;
-    /**
-     * Get parameter schema for a specific built-in tool
-     */
-    getBuiltInToolSchema(toolId: string): Promise<BuiltInTool>;
-}
-/**
- * Eval endpoint handlers
- */
-export declare class EvalEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * Run virtual eval with streaming response
-     * Executes multiple eval configs simultaneously and streams results via multiplexed SSE
-     */
-    runVirtualEval(data: {
-        record?: {
-            name?: string;
-            type?: string;
-            metadata?: Record<string, any>;
-        };
-        messages?: Array<{
-            role: 'system' | 'user' | 'assistant';
-            content: string;
-        }>;
-        flowId?: string;
-        flowDefinition?: any;
-        evalConfigs: Array<{
-            evalConfigId?: string;
-            evalName?: string;
-            stepOverrides?: Record<string, any>;
-        }>;
-        evalGroupId?: string;
-    }): Promise<Response>;
-}
-/**
- * Client Tokens endpoint handlers
- *
- * Manages client tokens for secure browser-to-API communication.
- * Client tokens enable embedding chat widgets in external applications.
- */
-export declare class ClientTokensEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all client tokens for the authenticated user
-     */
-    list(): Promise<ClientToken[]>;
-    /**
-     * Get a specific client token by ID
-     */
-    get(id: string): Promise<ClientToken>;
-    /**
-     * Create a new client token
-     *
-     * @returns The created token with the plain token value (shown only once)
-     */
-    create(data: CreateClientTokenRequest): Promise<CreateClientTokenResponse>;
-    /**
-     * Update an existing client token
-     */
-    update(id: string, data: UpdateClientTokenRequest): Promise<ClientToken>;
-    /**
-     * Delete a client token
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Regenerate a client token's value
-     *
-     * @returns The updated token with the new plain token value (shown only once)
-     */
-    regenerate(id: string): Promise<CreateClientTokenResponse>;
-    /**
-     * Get the plain token value for a client token
-     *
-     * Note: Only works if the token was just created or regenerated in the same session
-     */
-    getToken(id: string): Promise<{
-        token: string;
-    }>;
-    /**
-     * List conversations for a client token
-     */
-    listConversations(id: string, params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<ListConversationsResponse>;
-}
-/**
- * Agent event types for streaming
- */
-export type AgentEventType = 'agent_start' | 'agent_iteration_start' | 'agent_turn_start' | 'agent_turn_delta' | 'agent_turn_complete' | 'agent_tool_start' | 'agent_tool_delta' | 'agent_tool_complete' | 'agent_iteration_complete' | 'agent_reflection' | 'agent_complete' | 'agent_error' | 'agent_ping' | 'agent_await';
-/**
- * Base agent event with common fields
- */
-export interface BaseAgentEvent {
-    type: AgentEventType;
-    executionId: string;
-    seq: number;
-}
-/**
- * Agent start event
- */
-export interface AgentStartEvent extends BaseAgentEvent {
-    type: 'agent_start';
-    agentId: string;
-    agentName: string;
-    maxTurns: number;
-    startedAt: string;
-    config?: {
-        model?: string;
-        enableReflection?: boolean;
-    };
-}
-/**
- * Agent iteration start event
- */
-export interface AgentIterationStartEvent extends BaseAgentEvent {
-    type: 'agent_iteration_start';
-    iteration: number;
-    maxTurns: number;
-    totalCost?: number;
-    startedAt: string;
-}
-/**
- * Agent turn start event
- */
-export interface AgentTurnStartEvent extends BaseAgentEvent {
-    type: 'agent_turn_start';
-    iteration: number;
-    turnId: string;
-    turnIndex: number;
-    role: 'user' | 'assistant' | 'system';
-}
-/**
- * Agent turn delta event (streaming content)
- */
-export interface AgentTurnDeltaEvent extends BaseAgentEvent {
-    type: 'agent_turn_delta';
-    iteration: number;
-    turnId: string;
-    delta: string;
-    contentType: 'text' | 'thinking' | 'tool_input';
-}
-/**
- * Agent turn complete event
- */
-export interface AgentTurnCompleteEvent extends BaseAgentEvent {
-    type: 'agent_turn_complete';
-    iteration: number;
-    turnId: string;
-    role: 'user' | 'assistant' | 'system';
-    completedAt: string;
-    content?: string;
-    tokens?: {
-        input: number;
-        output: number;
-    };
-    cost?: number;
-}
-/**
- * Agent tool start event
- */
-export interface AgentToolStartEvent extends BaseAgentEvent {
-    type: 'agent_tool_start';
-    iteration: number;
-    toolCallId: string;
-    toolName: string;
-    toolType: 'flow' | 'mcp' | 'builtin' | 'custom' | 'external';
-    parameters?: Record<string, unknown>;
-}
-/**
- * Agent tool delta event
- */
-export interface AgentToolDeltaEvent extends BaseAgentEvent {
-    type: 'agent_tool_delta';
-    iteration: number;
-    toolCallId: string;
-    delta: string;
-}
-/**
- * Agent tool complete event
- */
-export interface AgentToolCompleteEvent extends BaseAgentEvent {
-    type: 'agent_tool_complete';
-    iteration: number;
-    toolCallId: string;
-    toolName: string;
-    success: boolean;
-    result?: unknown;
-    executionTime?: number;
-}
-/**
- * Agent iteration complete event
- */
-export interface AgentIterationCompleteEvent extends BaseAgentEvent {
-    type: 'agent_iteration_complete';
-    iteration: number;
-    completedAt: string;
-    output?: string;
-    toolCallsMade: number;
-    cost?: number;
-    tokens?: {
-        input: number;
-        output: number;
-    };
-    duration?: number;
-    stopConditionMet: boolean;
-}
-/**
- * Agent reflection event
- */
-export interface AgentReflectionEvent extends BaseAgentEvent {
-    type: 'agent_reflection';
-    iteration: number;
-    reflection?: string;
-}
-/**
- * Agent complete event
- */
-export interface AgentCompleteEvent extends BaseAgentEvent {
-    type: 'agent_complete';
-    agentId: string;
-    success: boolean;
-    iterations: number;
-    stopReason: 'complete' | 'end_turn' | 'max_turns' | 'max_cost' | 'timeout' | 'error';
-    completedAt: string;
-    totalCost?: number;
-    totalTokens?: {
-        input: number;
-        output: number;
-    };
-    finalOutput?: string;
-    duration?: number;
-    error?: string;
-}
-/**
- * Agent error event
- */
-export interface AgentErrorEvent extends BaseAgentEvent {
-    type: 'agent_error';
-    iteration?: number;
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-    recoverable: boolean;
-}
-/**
- * Agent ping event (keep-alive)
- */
-export interface AgentPingEvent extends BaseAgentEvent {
-    type: 'agent_ping';
-    timestamp: string;
-}
-/**
- * Agent await event (execution awaiting local tool result from client).
- */
-export interface AgentPausedEvent extends BaseAgentEvent {
-    type: 'agent_await';
-    executionId: string;
-    toolId: string;
-    toolName: string;
-    parameters?: Record<string, unknown>;
-    awaitedAt: string;
-}
-/**
- * Union of all agent event types
- */
-export type AgentEvent = AgentStartEvent | AgentIterationStartEvent | AgentTurnStartEvent | AgentTurnDeltaEvent | AgentTurnCompleteEvent | AgentToolStartEvent | AgentToolDeltaEvent | AgentToolCompleteEvent | AgentIterationCompleteEvent | AgentReflectionEvent | AgentCompleteEvent | AgentErrorEvent | AgentPingEvent | AgentPausedEvent;
-/**
- * Parsed SSE event with event type and data
- */
-interface ParsedSSEEvent {
-    eventType: string | null;
-    data: unknown;
-}
-/**
- * Callbacks for agent stream events
- */
-export interface AgentStreamCallbacks {
-    onAgentStart?: (event: AgentStartEvent) => void;
-    onIterationStart?: (event: AgentIterationStartEvent) => void;
-    onTurnStart?: (event: AgentTurnStartEvent) => void;
-    onTurnDelta?: (event: AgentTurnDeltaEvent) => void;
-    onTurnComplete?: (event: AgentTurnCompleteEvent) => void;
-    onToolStart?: (event: AgentToolStartEvent) => void;
-    onToolDelta?: (event: AgentToolDeltaEvent) => void;
-    onToolComplete?: (event: AgentToolCompleteEvent) => void;
-    onIterationComplete?: (event: AgentIterationCompleteEvent) => void;
-    onReflection?: (event: AgentReflectionEvent) => void;
-    onAgentComplete?: (event: AgentCompleteEvent) => void;
-    onAgentPaused?: (event: AgentPausedEvent) => void;
-    onError?: (event: AgentErrorEvent) => void;
-    onPing?: (event: AgentPingEvent) => void;
-    onUnknownEvent?: (event: ParsedSSEEvent) => void;
-}
-/**
- * Agent message format
- */
-export interface AgentMessage {
-    role: 'system' | 'user' | 'assistant';
-    content: string | Array<{
-        type: string;
-        text?: string;
-        image?: string;
-        data?: string;
-    }>;
-}
-/**
- * Definition for a local tool that executes on the client side.
- * Pairs the tool schema (sent to the server) with a handler (executed locally).
- */
-export interface LocalToolDefinition {
-    /** Human-readable description of what the tool does */
-    description: string;
-    /** JSON Schema describing the tool's parameters */
-    parametersSchema: Record<string, unknown>;
-    /** Handler that executes locally when the agent invokes this tool */
-    execute: (args: Record<string, unknown>) => Promise<unknown>;
-}
-/**
- * Runtime tool definition shape accepted by agent execution endpoints.
- */
-export interface AgentRuntimeToolDefinition {
-    name: string;
-    description: string;
-    toolType: 'flow' | 'custom' | 'external' | 'local';
-    parametersSchema: Record<string, unknown>;
-    config?: Record<string, unknown>;
-}
-/**
- * Agent execute request
- */
-export interface AgentExecuteRequest {
-    /** Conversation messages */
-    messages: AgentMessage[];
-    /** Variables to pass to the agent */
-    variables?: Record<string, unknown>;
-    /** Enable streaming response (default: true) */
-    streamResponse?: boolean;
-    /** Enable debug mode to include all fields in events */
-    debugMode?: boolean;
-    /** Model ID to use for this session (overrides agent config) */
-    model?: string;
-    /** Runtime tools to make available during execution */
-    tools?: {
-        runtimeTools?: AgentRuntimeToolDefinition[];
-    };
-}
-/**
- * Agent execute response (non-streaming)
- */
-export interface AgentExecuteResponse {
-    success: boolean;
-    result: string;
-    iterations: number;
-    totalCost: number;
-    stopReason: 'complete' | 'end_turn' | 'max_turns' | 'max_cost' | 'timeout' | 'error';
-    reflections?: string[];
-    error?: string;
-}
-interface LocalToolExecutionLoopSnapshot {
-    executionId: string;
-    pauseCount: number;
-    discoveryPauseCount: number;
-    consecutiveDiscoveryPauseCount: number;
-    toolName: string;
-    toolNameCount: number;
-    parameters: Record<string, unknown>;
-    toolResult: unknown;
-    accumulatedOutput: string;
-    actionKey: string;
-    actionKeyCount: number;
-    recentActionKeys: string[];
-}
-interface ExecuteWithLocalToolsOptions {
-    onLocalToolResult?: (snapshot: LocalToolExecutionLoopSnapshot) => AgentCompleteEvent | null | undefined;
-}
-/**
- * Status of a long-task agent run
- */
-export type RunTaskStatus = 'running' | 'complete' | 'paused' | 'error' | 'budget_exceeded' | 'max_sessions';
-/**
- * A continuation point within a long-task run (for marathon resume).
- */
-export interface RunTaskContinuation {
-    /** ISO timestamp when this continuation started */
-    continuedAt: string;
-    /** Session count at the time of continuation (from-session) */
-    fromSession: number;
-    /** User message provided on resume, if any */
-    userMessage?: string;
-    /** Model used for this continuation segment */
-    model?: string;
-    /** Cost of sessions in this continuation segment */
-    segmentCost: number;
-}
-/**
- * Summary of a single session within a long-task run
- */
-export interface RunTaskSessionSummary {
-    /** 1-based session index */
-    index: number;
-    /** Cost of this individual session (USD) */
-    cost: number;
-    /** Number of loop iterations in this session */
-    iterations: number;
-    /** Why this session stopped */
-    stopReason: AgentExecuteResponse['stopReason'];
-    /** Truncated output from this session */
-    outputPreview: string;
-    /** Compact summary of tool/discovery activity captured during the session */
-    toolTraceSummary?: string;
-    /** Whether repo discovery tools were used during the session */
-    discoveryPerformed?: boolean;
-    /** Whether the session attempted a file write even if it did not complete */
-    attemptedWrite?: boolean;
-    /** Whether the session wrote any files */
-    wroteFiles?: boolean;
-    /** Whether the assistant produced final text output */
-    hadTextOutput?: boolean;
-    /** Whether a verification command was run during the session */
-    verificationAttempted?: boolean;
-    /** Whether the latest verification command passed during the session */
-    verificationPassed?: boolean;
-    /** Best candidate file identified during the session */
-    bestCandidatePath?: string;
-    /** Recent action keys used during the session */
-    actionKeys?: string[];
-    /** ISO timestamp when this session completed */
-    completedAt: string;
-}
-/**
- * Accumulated state for a long-task agent run.
- * This is both the in-memory state and the record metadata shape.
- */
-export interface RunTaskState {
-    agentId: string;
-    agentName?: string;
-    taskName: string;
-    status: RunTaskStatus;
-    /** Total sessions completed so far */
-    sessionCount: number;
-    /** Total cost across all sessions (USD) */
-    totalCost: number;
-    /** Last agent output (full text) */
-    lastOutput: string;
-    /** Last terminal error captured from agent execution */
-    lastError?: string;
-    /** Last stop reason */
-    lastStopReason: AgentExecuteResponse['stopReason'];
-    /** Per-session summaries (kept trimmed to last N) */
-    sessions: RunTaskSessionSummary[];
-    /** ISO timestamp of first session */
-    startedAt: string;
-    /** ISO timestamp of last update */
-    updatedAt: string;
-    /** Original task message (first invocation) */
-    originalMessage?: string;
-    /** Full conversation message history (source of truth for resume) */
-    messages?: AgentMessage[];
-    /** History of continuation points */
-    continuations?: RunTaskContinuation[];
-    /** Per-model cost breakdown */
-    costByModel?: Record<string, number>;
-    /** Auto-generated repo bootstrap hints derived from the original task */
-    bootstrapContext?: string;
-    /** Current structured marathon workflow phase */
-    workflowPhase?: 'research' | 'planning' | 'execution' | 'complete';
-    /** Suggested markdown plan path for the task */
-    planPath?: string;
-    /** Whether the planning artifact has been written */
-    planWritten?: boolean;
-    /** Summary of the most recent automatic phase transition */
-    phaseTransitionSummary?: string;
-    /** Best current file candidate for the task */
-    bestCandidatePath?: string;
-    /** Reason the best candidate was selected */
-    bestCandidateReason?: string;
-    /** Recent candidate file paths discovered across sessions */
-    candidatePaths?: string[];
-    /** Recent file paths read by the agent */
-    recentReadPaths?: string[];
-    /** Recent action keys used across sessions for loop detection */
-    recentActionKeys?: string[];
-    /** Whether the current best candidate still needs a post-write verification read */
-    bestCandidateNeedsVerification?: boolean;
-    /** Whether the current best candidate has been re-read after the latest write */
-    bestCandidateVerified?: boolean;
-    /** Whether completion requires a successful verification command */
-    verificationRequired?: boolean;
-    /** Whether the latest verification command succeeded */
-    lastVerificationPassed?: boolean;
-}
-export type RunTaskResumeState = Pick<RunTaskState, 'originalMessage' | 'bootstrapContext' | 'workflowPhase' | 'planPath' | 'planWritten' | 'bestCandidatePath' | 'bestCandidateReason' | 'candidatePaths' | 'recentReadPaths' | 'recentActionKeys' | 'bestCandidateNeedsVerification' | 'bestCandidateVerified' | 'verificationRequired' | 'lastVerificationPassed'>;
-/**
- * Callback invoked after each session completes.
- * Return `false` to stop the loop early.
- */
-export type RunTaskOnSession = (state: RunTaskState) => void | false | Promise<void | false>;
-/**
- * Options for `agents.runTask()`
- */
-export interface RunTaskOptions {
-    /** The user message / task instruction for the agent */
-    message: string;
-    /** Maximum number of sessions to run (default: 50) */
-    maxSessions?: number;
-    /** Maximum total cost in USD across all sessions */
-    maxCost?: number;
-    /** Whether to use streaming for each session execution (default: true) */
-    stream?: boolean;
-    /** Enable debug mode on each session */
-    debugMode?: boolean;
-    /** Called after each session. Return false to stop early. */
-    onSession?: RunTaskOnSession;
-    /**
-     * Sync progress to a Runtype record after each session.
-     * Pass `true` to use the agent name, or a string for a custom task name.
-     * The record will have type "agent-task" and be upserted by name.
-     */
-    trackProgress?: boolean | string;
-    /** Callbacks for streaming events (only used when stream: true) */
-    streamCallbacks?: AgentStreamCallbacks;
-    /**
-     * Local tools that execute on the client side.
-     * When the agent invokes a tool with `toolType: 'local'`, the SDK will
-     * pause, call the matching handler, and resume the agent with the result.
-     * Requires `stream: true` (default).
-     */
-    localTools?: Record<string, LocalToolDefinition>;
-    /** Model ID to use (overrides agent's configured model) */
-    model?: string;
-    /** Previous messages from a prior run (for continuation/resume) */
-    previousMessages?: AgentMessage[];
-    /** New user message for continuation (appended after previous context) */
-    continuationMessage?: string;
-    /** Use compact summary instead of full message history for continuation */
-    compact?: boolean;
-    /** Saved workflow state to seed a resumed or restarted marathon run */
-    resumeState?: RunTaskResumeState;
-}
-/**
- * Final result returned by `agents.runTask()`
- */
-export interface RunTaskResult {
-    status: RunTaskStatus;
-    sessionCount: number;
-    totalCost: number;
-    lastOutput: string;
-    sessions: RunTaskSessionSummary[];
-    /** The record ID if trackProgress was enabled */
-    recordId?: string;
-}
-/**
- * Agent data
- */
-export interface Agent {
-    id: string;
-    name: string;
-    description: string | null;
-    agentType: string;
-    primaryFlowId: string | null;
-    config: Record<string, unknown> | null;
-    externalConfig: Record<string, unknown> | null;
-    createdAt: string;
-    updatedAt: string;
-}
-/**
- * Agents endpoint handlers
- */
-export declare class AgentsEndpoint {
-    private client;
-    constructor(client: ApiClient);
-    /**
-     * List all agents for the authenticated user
-     */
-    list(params?: ListParams): Promise<PaginationResponse<Agent>>;
-    /**
-     * Get a specific agent by ID
-     */
-    get(id: string): Promise<Agent>;
-    /**
-     * Create a new agent
-     */
-    create(data: Partial<Agent>): Promise<Agent>;
-    /**
-     * Update an existing agent
-     */
-    update(id: string, data: Partial<Agent>): Promise<Agent>;
-    /**
-     * Delete an agent
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
-     * Useful for local `propose_runtime_tool` handlers before follow-up execution.
-     */
-    gateGeneratedRuntimeToolProposal(proposal: unknown, options?: GeneratedRuntimeToolGateOptions): GeneratedRuntimeToolGateDecision;
-    /**
-     * Build standardized local-tool output for a generated tool proposal.
-     * Returns `{ approved, reason, violations, tool? }`.
-     */
-    buildGeneratedRuntimeToolGateOutput(proposal: unknown, options?: GeneratedRuntimeToolGateOptions): {
-        approved: boolean;
-        reason: string;
-        violations: string[];
-        tool?: RuntimeTool;
-    };
-    /**
-     * Create a local tool definition that validates model-proposed runtime tools.
-     * Plug this into `executeWithLocalTools()` under a name like `propose_runtime_tool`.
-     */
-    createGeneratedRuntimeToolGateLocalTool(options?: GeneratedRuntimeToolGateOptions & {
-        description?: string;
-    }): LocalToolDefinition;
-    /**
-     * Attach approved runtime tools to an agent execute request.
-     * Returns a new request object and does not mutate the original.
-     */
-    attachApprovedRuntimeTools(request: AgentExecuteRequest, runtimeTools: RuntimeTool[]): AgentExecuteRequest;
-    /**
-     * Validate a generated runtime tool proposal and append it to an agent execute
-     * request if approved, in one call.
-     */
-    applyGeneratedRuntimeToolProposal(request: AgentExecuteRequest, proposal: unknown, options?: GeneratedRuntimeToolGateOptions): {
-        decision: GeneratedRuntimeToolGateDecision;
-        request: AgentExecuteRequest;
-    };
-    /**
-     * Execute an agent (non-streaming)
-     */
-    execute(id: string, data: AgentExecuteRequest): Promise<AgentExecuteResponse>;
-    /**
-     * Execute an agent with streaming response
-     *
-     * Returns a Response object with SSE stream.
-     * Use `executeWithCallbacks` for easier handling.
-     *
-     * @example
-     * ```typescript
-     * const response = await client.agents.executeStream('agt_123', {
-     *   messages: [{ role: 'user', content: 'Write me a poem' }],
-     *   debugMode: true,
-     * })
-     *
-     * // Process the stream manually
-     * const reader = response.body?.getReader()
-     * // ...
-     * ```
-     */
-    executeStream(id: string, data: AgentExecuteRequest): Promise<Response>;
-    /**
-     * Execute an agent with streaming and callbacks
-     *
-     * Processes the SSE stream and calls the appropriate callbacks for each event type.
-     * This is the recommended way to handle agent streaming.
-     *
-     * @example
-     * ```typescript
-     * let content = ''
-     *
-     * const result = await client.agents.executeWithCallbacks('agt_123', {
-     *   messages: [{ role: 'user', content: 'Write me a poem' }],
-     *   debugMode: true,
-     * }, {
-     *   onTurnDelta: (event) => {
-     *     content += event.delta
-     *     process.stdout.write(event.delta)
-     *   },
-     *   onIterationComplete: (event) => {
-     *     console.log(`\nIteration ${event.iteration} complete`)
-     *   },
-     *   onAgentComplete: (event) => {
-     *     console.log(`\nAgent finished: ${event.stopReason}`)
-     *   },
-     *   onError: (event) => {
-     *     console.error(`Error: ${event.error.message}`)
-     *   },
-     * })
-     *
-     * console.log('Final result:', result)
-     * ```
-     */
-    executeWithCallbacks(id: string, data: AgentExecuteRequest, callbacks: AgentStreamCallbacks): Promise<AgentCompleteEvent | null>;
-    /**
-     * Execute an agent with local tool support (pause/resume loop)
-     *
-     * When the agent hits a tool with `toolType: 'local'`, the server emits
-     * `agent_await`. This method automatically executes the local tool and
-     * resumes execution, repeating until the agent completes.
-     *
-     * @example
-     * ```typescript
-     * const result = await client.agents.executeWithLocalTools('agt_123', {
-     *   messages: [{ role: 'user', content: 'Create a file called hello.txt' }],
-     * }, {
-     *   write_file: async ({ path, content }) => {
-     *     fs.writeFileSync(path, content)
-     *     return 'ok'
-     *   },
-     * })
-     * ```
-     */
-    executeWithLocalTools(id: string, data: AgentExecuteRequest, localTools: Record<string, LocalToolDefinition>, callbacks?: AgentStreamCallbacks, options?: ExecuteWithLocalToolsOptions): Promise<AgentCompleteEvent | null>;
-    private createEmptyToolTrace;
-    private isDiscoveryLocalTool;
-    private buildLocalToolActionKey;
-    private buildProspectiveStateForSessionTrace;
-    private buildForcedLocalToolTurnCompleteEvent;
-    private createLocalToolLoopGuard;
-    private pushToolTraceEntry;
-    private isPreservationSensitiveTask;
-    private getLikelySupportingCandidatePaths;
-    private hasSufficientResearchEvidence;
-    private buildEffectiveSessionOutput;
-    private canAcceptTaskCompletion;
-    private summarizeUnknownForTrace;
-    private summarizeTextBlockForTrace;
-    private parseVerificationResult;
-    private normalizeCandidatePath;
-    private dedupeNormalizedCandidatePaths;
-    private isMarathonArtifactPath;
-    private isDiscoveryToolName;
-    private sanitizeTaskSlug;
-    private getDefaultPlanPath;
-    private dirnameOfCandidatePath;
-    private joinCandidatePath;
-    private scoreCandidatePath;
-    private addCandidateToTrace;
-    private extractCandidatePathsFromText;
-    private parseSearchRepoResultForCandidates;
-    private extractBestCandidateFromBootstrapContext;
-    private sanitizeResumeState;
-    private buildPhaseInstructions;
-    private updateWorkflowPhase;
-    private wrapLocalToolsForTrace;
-    private createTraceCallbacks;
-    private buildToolTraceSummary;
-    private extractBootstrapQueries;
-    private generateBootstrapDiscoveryContext;
-    private buildStuckTurnRecoveryMessage;
-    /**
-     * Run a long-task agent across multiple sessions with automatic state management.
-     *
-     * Each session is a single agent execution. The SDK drives the loop client-side,
-     * calling the agent's execute endpoint repeatedly and accumulating context.
-     * Progress is optionally synced to a Runtype record for dashboard visibility.
-     *
-     * @example
-     * ```typescript
-     * const result = await client.agents.runTask('agt_123', {
-     *   message: 'Build a REST API with CRUD endpoints',
-     *   maxSessions: 20,
-     *   maxCost: 5.00,
-     *   trackProgress: true,
-     *   onSession: (state) => {
-     *     console.log(`Session ${state.sessionCount}: ${state.lastStopReason} ($${state.totalCost.toFixed(4)})`)
-     *   },
-     * })
-     *
-     * console.log(`Finished: ${result.status} after ${result.sessionCount} sessions`)
-     * ```
-     */
-    runTask(id: string, options: RunTaskOptions): Promise<RunTaskResult>;
-    /** Stop phrases that indicate the agent considers its task complete. */
-    private static readonly STOP_PHRASES;
-    /**
-     * Client-side fallback for detecting task completion in agent output.
-     * Mirrors the API's detectAutoComplete() for non-loop agents that return 'end_turn'.
-     */
-    private detectTaskCompletion;
-    /**
-     * Generate a compact summary of prior work for continuation context.
-     * Used when compact mode is enabled to keep token usage low.
-     */
-    private generateCompactSummary;
-    /**
-     * Build messages for a session, injecting progress context for continuation sessions.
-     * Optionally accepts continuation context for marathon resume scenarios.
-     */
-    private buildSessionMessages;
-    /**
-     * Upsert a record to sync long-task progress to the dashboard.
-     * Creates the record on first call, updates it on subsequent calls.
-     */
-    private syncProgressRecord;
-}
-export {};
-//# sourceMappingURL=endpoints.d.ts.map