@runtypelabs/sdk 1.7.1 → 1.7.3

package/dist/endpoints.js

@@ -1,1649 +0,0 @@
-"use strict";
-/**
- * API endpoint handlers with automatic camelCase/snake_case transformation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentsEndpoint = exports.ClientTokensEndpoint = exports.EvalEndpoint = exports.ToolsEndpoint = exports.ContextTemplatesEndpoint = exports.FlowStepsEndpoint = exports.AnalyticsEndpoint = exports.UsersEndpoint = exports.ChatEndpoint = exports.DispatchEndpoint = exports.ModelConfigsEndpoint = exports.ApiKeysEndpoint = exports.RecordsEndpoint = exports.PromptsEndpoint = exports.FlowsEndpoint = void 0;
-const generated_tool_gate_1 = require("./generated-tool-gate");
-/**
- * Flows endpoint handlers
- */
-class FlowsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all flows for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/flows', params);
-    }
-    /**
-     * Get a specific flow by ID
-     */
-    async get(id) {
-        const response = await this.client.get(`/flows/${id}`);
-        return response;
-    }
-    /**
-     * Create a new flow
-     */
-    async create(data) {
-        return this.client.post('/flows', data);
-    }
-    /**
-     * Update an existing flow
-     */
-    async update(id, data) {
-        return this.client.put(`/flows/${id}`, data);
-    }
-    /**
-     * Delete a flow
-     */
-    async delete(id) {
-        return this.client.delete(`/flows/${id}`);
-    }
-    /**
-     * Run a flow on all records of a specific type
-     */
-    async runOnRecordType(id, recordType) {
-        return this.client.post(`/flows/${id}/run-on-record-type`, {
-            recordType,
-        });
-    }
-    /**
-     * Publish flow (promote draft to published)
-     */
-    async publish(id) {
-        return this.client.post(`/flows/${id}/publish`);
-    }
-}
-exports.FlowsEndpoint = FlowsEndpoint;
-/**
- * Prompts endpoint handlers
- */
-class PromptsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all prompts for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/prompts', params);
-    }
-    /**
-     * Get a specific prompt by ID
-     */
-    async get(id) {
-        return this.client.get(`/prompts/${id}`);
-    }
-    /**
-     * Create a new prompt
-     */
-    async create(data) {
-        return this.client.post('/prompts', data);
-    }
-    /**
-     * Update an existing prompt
-     */
-    async update(id, data) {
-        return this.client.put(`/prompts/${id}`, data);
-    }
-    /**
-     * Delete a prompt
-     */
-    async delete(id) {
-        return this.client.delete(`/prompts/${id}`);
-    }
-    /**
-     * Run a prompt on a specific record
-     */
-    async runOnRecord(id, recordId) {
-        return this.client.post(`/prompts/${id}/run-on-record`, { recordId });
-    }
-    /**
-     * Get flows using this prompt
-     */
-    async getFlows(id) {
-        return this.client.get(`/prompts/${id}/flows`);
-    }
-    /**
-     * Update flow attachments for a prompt
-     */
-    async updateFlows(id, flowIds) {
-        return this.client.put(`/prompts/${id}/flows`, { flowIds });
-    }
-}
-exports.PromptsEndpoint = PromptsEndpoint;
-/**
- * Records endpoint handlers
- */
-class RecordsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all records for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/records', params);
-    }
-    /**
-     * Get a specific record by ID
-     */
-    async get(id) {
-        return this.client.get(`/records/${id}`);
-    }
-    /**
-     * Create a new record
-     */
-    async create(data) {
-        return this.client.post('/records', data);
-    }
-    /**
-     * Update an existing record
-     */
-    async update(id, data) {
-        return this.client.put(`/records/${id}`, data);
-    }
-    /**
-     * Delete a record
-     */
-    async delete(id) {
-        return this.client.delete(`/records/${id}`);
-    }
-    /**
-     * Bulk delete multiple records
-     */
-    async bulkDelete(ids) {
-        return this.client.post('/records/bulk-delete', { ids });
-    }
-    /**
-     * Bulk edit multiple records
-     */
-    async bulkEdit(data) {
-        return this.client.post('/records/bulk-edit', data);
-    }
-    /**
-     * Get results for a record
-     */
-    async getResults(id, params) {
-        return this.client.get(`/records/${id}/results`, params);
-    }
-    /**
-     * Delete a specific result for a record
-     */
-    async deleteResult(id, resultId) {
-        return this.client.delete(`/records/${id}/results`, { resultId });
-    }
-    /**
-     * Upload CSV file to create multiple records
-     */
-    async uploadCsv(file, params) {
-        const formData = new FormData();
-        formData.append('file', file);
-        if (params?.typeColumn) {
-            formData.append('typeColumn', params.typeColumn);
-        }
-        if (params?.nameColumn) {
-            formData.append('nameColumn', params.nameColumn);
-        }
-        return this.client.postFormData('/records/upload-csv', formData);
-    }
-    /**
-     * Get record types (distinct values)
-     */
-    async getTypes() {
-        return this.client.get('/records?distinct=types');
-    }
-    /**
-     * Get example record by type and/or name
-     */
-    async getExample(params) {
-        return this.client.get('/records', {
-            ...params,
-            includeFields: true,
-            limit: 1,
-        });
-    }
-}
-exports.RecordsEndpoint = RecordsEndpoint;
-/**
- * API Keys endpoint handlers
- */
-class ApiKeysEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all API keys for the authenticated user
-     */
-    async list() {
-        const response = await this.client.get('/api-keys');
-        return response.apiKeys;
-    }
-    /**
-     * Get a specific API key by ID
-     */
-    async get(id) {
-        return this.client.get(`/api-keys/${id}`);
-    }
-    /**
-     * Create a new API key
-     */
-    async create(data) {
-        return this.client.post('/api-keys', data);
-    }
-    /**
-     * Update an existing API key
-     */
-    async update(id, data) {
-        return this.client.put(`/api-keys/${id}`, data);
-    }
-    /**
-     * Delete an API key
-     */
-    async delete(id) {
-        return this.client.delete(`/api-keys/${id}`);
-    }
-    /**
-     * Regenerate an API key
-     */
-    async regenerate(id) {
-        return this.client.post(`/api-keys/${id}/regenerate`);
-    }
-    /**
-     * Get API key analytics
-     */
-    async getAnalytics(id) {
-        return this.client.get(`/api-keys/${id}/analytics`);
-    }
-    /**
-     * Get usage logs for an API key
-     */
-    async getUsage(id, params) {
-        return this.client.get(`/api-keys/${id}/usage`, params);
-    }
-    /**
-     * Get API key analytics (all keys or specific key)
-     */
-    async getAnalyticsEnhanced(apiKeyId, params) {
-        const endpoint = apiKeyId === 'all' ? '/api-keys/analytics' : `/api-keys/${apiKeyId}/analytics`;
-        return this.client.get(endpoint, params);
-    }
-    /**
-     * Get API key usage logs (all keys or specific key)
-     */
-    async getLogs(apiKeyId, params) {
-        const endpoint = apiKeyId === 'all' ? '/api-keys/logs' : `/api-keys/${apiKeyId}/logs`;
-        return this.client.get(endpoint, params);
-    }
-    /**
-     * Get API key permission options
-     */
-    async getPermissionOptions() {
-        return this.client.get('/api-keys/options');
-    }
-    /**
-     * Get API key security logs
-     */
-    async getSecurityLogs(id) {
-        return this.client.get(`/api-keys/${id}/security-logs`);
-    }
-    /**
-     * Update API key security settings
-     */
-    async updateSecurity(id, data) {
-        return this.client.put(`/api-keys/${id}/security`, data);
-    }
-    /**
-     * Clear suspicious activity for API key
-     */
-    async clearSuspiciousActivity(id) {
-        return this.client.post(`/api-keys/${id}/clear-suspicious`);
-    }
-}
-exports.ApiKeysEndpoint = ApiKeysEndpoint;
-/**
- * Model Configurations endpoint handlers
- */
-class ModelConfigsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get available models catalog
-     */
-    async getAvailable() {
-        const response = await this.client.get('/model-configs/available');
-        // Handle both wrapped and direct array responses
-        return Array.isArray(response) ? response : response.data || [];
-    }
-    /**
-     * Get search-capable models (all available, regardless of user configuration)
-     */
-    async getSearchCapable() {
-        const response = await this.client.get('/model-configs/search-capable');
-        return response.data || [];
-    }
-    /**
-     * Get configured search-capable models (only user's configured and enabled models)
-     */
-    async getSearchConfigured() {
-        const response = await this.client.get('/model-configs/search-configured');
-        return response.data || [];
-    }
-    /**
-     * List user's model configurations
-     */
-    async list() {
-        const response = await this.client.get('/model-configs');
-        // Handle both wrapped and direct array responses
-        return Array.isArray(response) ? response : response.data || [];
-    }
-    /**
-     * Create a new model configuration
-     */
-    async create(data) {
-        return this.client.post('/model-configs', data);
-    }
-    /**
-     * Update an existing model configuration
-     */
-    async update(id, data) {
-        return this.client.put(`/model-configs/${id}`, data);
-    }
-    /**
-     * Delete a model configuration
-     */
-    async delete(id) {
-        return this.client.delete(`/model-configs/${id}`);
-    }
-    /**
-     * Enable/disable a model configuration
-     */
-    async updateStatus(id, isEnabled) {
-        return this.client.patch(`/model-configs/${id}/status`, { isEnabled });
-    }
-    /**
-     * Set a model configuration as default
-     */
-    async setDefault(id) {
-        return this.client.patch(`/model-configs/${id}/default`);
-    }
-    /**
-     * Get usage statistics
-     */
-    async getUsage() {
-        return this.client.get('/model-configs/usage');
-    }
-}
-exports.ModelConfigsEndpoint = ModelConfigsEndpoint;
-/**
- * Dispatch endpoint handler for atomic record/flow creation and execution
- */
-class DispatchEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Dispatch: create and/or execute flows on records atomically
-     */
-    async execute(data) {
-        return this.client.post('/dispatch', data);
-    }
-    /**
-     * Dispatch with streaming response
-     */
-    async executeStream(data) {
-        return this.client.requestStream('/dispatch', {
-            method: 'POST',
-            body: JSON.stringify(data),
-        });
-    }
-    /**
-     * 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
-     */
-    async resume(data) {
-        if (data.streamResponse) {
-            return this.client.requestStream('/dispatch/resume', {
-                method: 'POST',
-                body: JSON.stringify(data),
-            });
-        }
-        return this.client.post('/dispatch/resume', data);
-    }
-    /**
-     * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
-     * Useful for local `propose_runtime_tool` handlers before redispatch.
-     */
-    gateGeneratedRuntimeToolProposal(proposal, options) {
-        return (0, generated_tool_gate_1.evaluateGeneratedRuntimeToolProposal)(proposal, options);
-    }
-    /**
-     * Build standardized local-tool output for a generated tool proposal.
-     * Returns `{ approved, reason, violations, tool? }`.
-     */
-    buildGeneratedRuntimeToolGateOutput(proposal, options) {
-        return (0, generated_tool_gate_1.buildGeneratedRuntimeToolGateOutput)(proposal, options);
-    }
-    /**
-     * 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, runtimeTools, options) {
-        return (0, generated_tool_gate_1.attachRuntimeToolsToDispatchRequest)(request, runtimeTools, options);
-    }
-    /**
-     * Validate a generated runtime tool proposal and attach it to the redispatch
-     * request if approved, in one call.
-     */
-    applyGeneratedRuntimeToolProposal(request, proposal, options) {
-        return (0, generated_tool_gate_1.applyGeneratedRuntimeToolProposalToDispatchRequest)(request, proposal, options);
-    }
-}
-exports.DispatchEndpoint = DispatchEndpoint;
-/**
- * Chat endpoint handler
- */
-class ChatEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Send a chat message
-     */
-    async send(message) {
-        return this.client.post('/chat', { message });
-    }
-    /**
-     * Send a chat message with streaming response
-     */
-    async sendStream(message, options) {
-        return this.client.requestStream('/chat', {
-            method: 'POST',
-            body: JSON.stringify({ message, ...options }),
-        });
-    }
-}
-exports.ChatEndpoint = ChatEndpoint;
-/**
- * Users endpoint handlers
- */
-class UsersEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get current user profile
-     */
-    async getProfile() {
-        return this.client.get('/users/profile');
-    }
-    /**
-     * Update user profile
-     */
-    async updateProfile(data) {
-        return this.client.put('/users/profile', data);
-    }
-}
-exports.UsersEndpoint = UsersEndpoint;
-/**
- * Analytics endpoint handlers
- */
-class AnalyticsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get analytics stats
-     */
-    async getStats(params) {
-        return this.client.get('/analytics/stats', params);
-    }
-    /**
-     * Get analytics executions
-     */
-    async getExecutions(params) {
-        return this.client.get('/analytics/record-results', params);
-    }
-    /**
-     * Get all record results (same as executions)
-     */
-    async getAllRecordResults(params) {
-        return this.client.get('/analytics/record-results', params);
-    }
-    /**
-     * Get model usage analytics
-     */
-    async getModelUsage(params) {
-        return this.client.get('/model-usage', params);
-    }
-}
-exports.AnalyticsEndpoint = AnalyticsEndpoint;
-/**
- * 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.
- */
-class FlowStepsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get flow steps for a flow
-     * @deprecated Use `flows.get(flowId)` instead - flow steps are now embedded in the flow response as `flowSteps`
-     */
-    async getByFlow(flowId) {
-        console.warn('[Runtype SDK] flowSteps.getByFlow() is deprecated. Use flows.get(flowId) instead - flow steps are now embedded in the flow response as flowSteps.');
-        return this.client.get(`/flow-steps/flow/${flowId}`);
-    }
-    /**
-     * Get a specific flow step
-     * @deprecated Use `flows.get(flowId)` and find the step in `flowSteps` array
-     */
-    async get(id) {
-        console.warn('[Runtype SDK] flowSteps.get() is deprecated. Use flows.get(flowId) and find the step in flowSteps array.');
-        return this.client.get(`/flow-steps/${id}`);
-    }
-    /**
-     * Create a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` to add steps
-     */
-    async create(data) {
-        console.warn('[Runtype SDK] flowSteps.create() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) to add steps.');
-        return this.client.post('/flow-steps', data);
-    }
-    /**
-     * Update a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` to update steps
-     */
-    async update(id, data) {
-        console.warn('[Runtype SDK] flowSteps.update() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) to update steps.');
-        return this.client.put(`/flow-steps/${id}`, data);
-    }
-    /**
-     * Delete a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` with the step removed
-     */
-    async delete(id) {
-        console.warn('[Runtype SDK] flowSteps.delete() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) with the step removed.');
-        return this.client.delete(`/flow-steps/${id}`);
-    }
-    /**
-     * Reorder flow steps
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` with updated order values
-     */
-    async reorder(flowId, stepOrders) {
-        console.warn('[Runtype SDK] flowSteps.reorder() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) with updated order values.');
-        return this.client.post('/flow-steps/reorder', {
-            flowId,
-            stepOrders,
-        });
-    }
-}
-exports.FlowStepsEndpoint = FlowStepsEndpoint;
-/**
- * Context Templates endpoint handlers
- */
-class ContextTemplatesEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List context templates
-     */
-    async list(params) {
-        return this.client.get('/context-templates', params);
-    }
-    /**
-     * Get a specific context template
-     */
-    async get(id) {
-        return this.client.get(`/context-templates/${id}`);
-    }
-    /**
-     * Create a context template
-     */
-    async create(data) {
-        return this.client.post('/context-templates', data);
-    }
-    /**
-     * Update a context template
-     */
-    async update(id, data) {
-        return this.client.put(`/context-templates/${id}`, data);
-    }
-    /**
-     * Delete a context template
-     */
-    async delete(id) {
-        return this.client.delete(`/context-templates/${id}`);
-    }
-}
-exports.ContextTemplatesEndpoint = ContextTemplatesEndpoint;
-/**
- * Tools endpoint handlers
- */
-class ToolsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all tools for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/tools', params);
-    }
-    /**
-     * Get a specific tool by ID
-     */
-    async get(id) {
-        return this.client.get(`/tools/${id}`);
-    }
-    /**
-     * Create a new tool
-     */
-    async create(data) {
-        return this.client.post('/tools', data);
-    }
-    /**
-     * Update an existing tool
-     */
-    async update(id, data) {
-        return this.client.put(`/tools/${id}`, data);
-    }
-    /**
-     * Delete a tool
-     */
-    async delete(id) {
-        return this.client.delete(`/tools/${id}`);
-    }
-    /**
-     * Execute a tool
-     */
-    async execute(id, data) {
-        return this.client.post(`/tools/${id}/execute`, data);
-    }
-    /**
-     * Execute a tool with streaming response
-     */
-    async executeStream(id, data) {
-        return this.client.requestStream(`/tools/${id}/execute`, {
-            method: 'POST',
-            body: JSON.stringify(data),
-        });
-    }
-    /**
-     * Test a tool (same as execute but for testing purposes)
-     */
-    async test(id, data) {
-        return this.client.post(`/tools/${id}/test`, data);
-    }
-    /**
-     * Get tool executions for a specific tool
-     */
-    async getExecutions(toolId, params) {
-        return this.client.get(`/tools/${toolId}/executions`, params);
-    }
-    /**
-     * Get AI SDK compatible tool schemas
-     */
-    async getSchemas(params) {
-        return this.client.get('/tools/schema', params);
-    }
-    /**
-     * Get available tools for prompts
-     */
-    async getAvailable() {
-        const response = await this.client.get('/tools', {
-            isActive: true,
-            limit: 200,
-        });
-        const payload = response;
-        if (Array.isArray(payload?.data)) {
-            return payload.data;
-        }
-        if (Array.isArray(payload)) {
-            return payload;
-        }
-        return [];
-    }
-    /**
-     * Convert a flow to a tool
-     */
-    async convertFromFlow(flowId, data) {
-        return this.client.post(`/flows/${flowId}/convert-to-tool`, data);
-    }
-    /**
-     * Get all built-in tools
-     */
-    async getBuiltInTools() {
-        return this.client.get('/tools/builtin');
-    }
-    /**
-     * Get built-in tools compatible with a specific model and provider
-     */
-    async getCompatibleBuiltInTools(model, provider) {
-        return this.client.get('/tools/builtin/compatible', {
-            model,
-            provider,
-        });
-    }
-    /**
-     * Get parameter schema for a specific built-in tool
-     */
-    async getBuiltInToolSchema(toolId) {
-        return this.client.get(`/tools/builtin/${toolId}/schema`);
-    }
-}
-exports.ToolsEndpoint = ToolsEndpoint;
-/**
- * Eval endpoint handlers
- */
-class EvalEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Run virtual eval with streaming response
-     * Executes multiple eval configs simultaneously and streams results via multiplexed SSE
-     */
-    async runVirtualEval(data) {
-        return this.client.requestStream('/eval/stream', {
-            method: 'POST',
-            body: JSON.stringify(data),
-        });
-    }
-}
-exports.EvalEndpoint = EvalEndpoint;
-/**
- * Client Tokens endpoint handlers
- *
- * Manages client tokens for secure browser-to-API communication.
- * Client tokens enable embedding chat widgets in external applications.
- */
-class ClientTokensEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all client tokens for the authenticated user
-     */
-    async list() {
-        const response = await this.client.get('/client-tokens');
-        return response.clientTokens;
-    }
-    /**
-     * Get a specific client token by ID
-     */
-    async get(id) {
-        return this.client.get(`/client-tokens/${id}`);
-    }
-    /**
-     * Create a new client token
-     *
-     * @returns The created token with the plain token value (shown only once)
-     */
-    async create(data) {
-        return this.client.post('/client-tokens', data);
-    }
-    /**
-     * Update an existing client token
-     */
-    async update(id, data) {
-        return this.client.put(`/client-tokens/${id}`, data);
-    }
-    /**
-     * Delete a client token
-     */
-    async delete(id) {
-        return this.client.delete(`/client-tokens/${id}`);
-    }
-    /**
-     * Regenerate a client token's value
-     *
-     * @returns The updated token with the new plain token value (shown only once)
-     */
-    async regenerate(id) {
-        return this.client.post(`/client-tokens/${id}/regenerate`);
-    }
-    /**
-     * Get the plain token value for a client token
-     *
-     * Note: Only works if the token was just created or regenerated in the same session
-     */
-    async getToken(id) {
-        return this.client.get(`/client-tokens/${id}/token`);
-    }
-    /**
-     * List conversations for a client token
-     */
-    async listConversations(id, params) {
-        return this.client.get(`/client-tokens/${id}/conversations`, params);
-    }
-}
-exports.ClientTokensEndpoint = ClientTokensEndpoint;
-/**
- * Parse SSE stream chunks into individual events with event type support
- */
-function parseSSEChunkWithEventType(chunk, buffer) {
-    buffer += chunk;
-    // Split on double newlines to get complete events
-    const parts = buffer.split('\n\n');
-    const remainingBuffer = parts.pop() || '';
-    const events = [];
-    for (const part of parts) {
-        if (!part.trim())
-            continue;
-        const lines = part.split('\n');
-        let eventType = null;
-        let dataStr = null;
-        for (const line of lines) {
-            if (line.startsWith('event: ')) {
-                eventType = line.slice(7).trim();
-            }
-            else if (line.startsWith('data: ')) {
-                dataStr = line.slice(6).trim();
-            }
-        }
-        if (dataStr && dataStr !== '[DONE]') {
-            try {
-                const data = JSON.parse(dataStr);
-                events.push({ eventType, data });
-            }
-            catch {
-                // Invalid JSON, skip
-            }
-        }
-    }
-    return { events, remainingBuffer };
-}
-/**
- * Dispatch a parsed agent event to the appropriate callback
- */
-function dispatchAgentEvent(event, callbacks) {
-    const { eventType, data } = event;
-    const typedData = data;
-    // If no event type, try to get it from the data
-    const type = eventType || typedData?.type;
-    // @snake-case-ok-start: Agent event type identifiers use snake_case to match flow events
-    switch (type) {
-        case 'agent_start':
-            callbacks.onAgentStart?.(typedData);
-            break;
-        case 'agent_iteration_start':
-            callbacks.onIterationStart?.(typedData);
-            break;
-        case 'agent_turn_start':
-            callbacks.onTurnStart?.(typedData);
-            break;
-        case 'agent_turn_delta':
-            callbacks.onTurnDelta?.(typedData);
-            break;
-        case 'agent_turn_complete':
-            callbacks.onTurnComplete?.(typedData);
-            break;
-        case 'agent_tool_start':
-            callbacks.onToolStart?.(typedData);
-            break;
-        case 'agent_tool_delta':
-            callbacks.onToolDelta?.(typedData);
-            break;
-        case 'agent_tool_complete':
-            callbacks.onToolComplete?.(typedData);
-            break;
-        case 'agent_iteration_complete':
-            callbacks.onIterationComplete?.(typedData);
-            break;
-        case 'agent_reflection':
-            callbacks.onReflection?.(typedData);
-            break;
-        case 'agent_complete':
-            callbacks.onAgentComplete?.(typedData);
-            break;
-        case 'agent_error':
-            callbacks.onError?.(typedData);
-            break;
-        case 'agent_await':
-            callbacks.onAgentPaused?.(typedData);
-            break;
-        case 'agent_ping':
-            callbacks.onPing?.(typedData);
-            break;
-        default:
-            callbacks.onUnknownEvent?.(event);
-    }
-    // @snake-case-ok-end
-}
-/**
- * Process agent stream with callbacks
- */
-async function processAgentStream(body, callbacks) {
-    if (!body)
-        return;
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                // Process any remaining buffer
-                if (buffer.trim()) {
-                    const { events } = parseSSEChunkWithEventType(buffer + '\n\n', '');
-                    for (const event of events) {
-                        dispatchAgentEvent(event, callbacks);
-                    }
-                }
-                break;
-            }
-            const chunk = decoder.decode(value, { stream: true });
-            const { events, remainingBuffer } = parseSSEChunkWithEventType(chunk, buffer);
-            buffer = remainingBuffer;
-            for (const event of events) {
-                dispatchAgentEvent(event, callbacks);
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-const GENERATED_RUNTIME_TOOL_PROPOSAL_SCHEMA = {
-    type: 'object',
-    properties: {
-        name: {
-            type: 'string',
-            description: 'Tool name. Use letters/numbers/underscore only.',
-        },
-        description: {
-            type: 'string',
-            description: 'Clear description of what the generated tool does.',
-        },
-        toolType: {
-            type: 'string',
-            enum: ['custom'],
-            description: 'Must be "custom" for generated code execution tools.',
-        },
-        parametersSchema: {
-            type: 'object',
-            description: 'JSON schema for tool call arguments.',
-        },
-        config: {
-            type: 'object',
-            description: 'Runtime tool config including code, sandboxProvider, language, and timeout.',
-        },
-        reason: {
-            type: 'string',
-            description: 'Why this tool is needed.',
-        },
-    },
-    required: ['name', 'description', 'toolType', 'parametersSchema', 'config'],
-};
-function appendRuntimeToolsToAgentRequest(request, runtimeTools) {
-    const existing = request.tools?.runtimeTools || [];
-    const existingNames = new Set(existing.map((tool) => tool.name));
-    const converted = runtimeTools
-        .filter((tool) => !existingNames.has(tool.name))
-        .map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        toolType: tool.toolType,
-        parametersSchema: tool.parametersSchema,
-        ...(tool.config ? { config: tool.config } : {}),
-    }));
-    return {
-        ...request,
-        tools: {
-            ...request.tools,
-            runtimeTools: [...existing, ...converted],
-        },
-    };
-}
-/**
- * Agents endpoint handlers
- */
-class AgentsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all agents for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/agents', params);
-    }
-    /**
-     * Get a specific agent by ID
-     */
-    async get(id) {
-        return this.client.get(`/agents/${id}`);
-    }
-    /**
-     * Create a new agent
-     */
-    async create(data) {
-        return this.client.post('/agents', data);
-    }
-    /**
-     * Update an existing agent
-     */
-    async update(id, data) {
-        return this.client.put(`/agents/${id}`, data);
-    }
-    /**
-     * Delete an agent
-     */
-    async delete(id) {
-        return this.client.delete(`/agents/${id}`);
-    }
-    /**
-     * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
-     * Useful for local `propose_runtime_tool` handlers before follow-up execution.
-     */
-    gateGeneratedRuntimeToolProposal(proposal, options) {
-        return (0, generated_tool_gate_1.evaluateGeneratedRuntimeToolProposal)(proposal, options);
-    }
-    /**
-     * Build standardized local-tool output for a generated tool proposal.
-     * Returns `{ approved, reason, violations, tool? }`.
-     */
-    buildGeneratedRuntimeToolGateOutput(proposal, options) {
-        return (0, generated_tool_gate_1.buildGeneratedRuntimeToolGateOutput)(proposal, options);
-    }
-    /**
-     * Create a local tool definition that validates model-proposed runtime tools.
-     * Plug this into `executeWithLocalTools()` under a name like `propose_runtime_tool`.
-     */
-    createGeneratedRuntimeToolGateLocalTool(options) {
-        const { description, ...gateOptions } = options || {};
-        return {
-            description: description ||
-                'Validate a generated runtime custom tool and return { approved, reason, violations, tool? }',
-            parametersSchema: GENERATED_RUNTIME_TOOL_PROPOSAL_SCHEMA,
-            execute: async (args) => (0, generated_tool_gate_1.buildGeneratedRuntimeToolGateOutput)(args, gateOptions),
-        };
-    }
-    /**
-     * Attach approved runtime tools to an agent execute request.
-     * Returns a new request object and does not mutate the original.
-     */
-    attachApprovedRuntimeTools(request, runtimeTools) {
-        return appendRuntimeToolsToAgentRequest(request, runtimeTools);
-    }
-    /**
-     * Validate a generated runtime tool proposal and append it to an agent execute
-     * request if approved, in one call.
-     */
-    applyGeneratedRuntimeToolProposal(request, proposal, options) {
-        const decision = (0, generated_tool_gate_1.evaluateGeneratedRuntimeToolProposal)(proposal, options);
-        if (!decision.approved || !decision.tool) {
-            return { decision, request };
-        }
-        return {
-            decision,
-            request: appendRuntimeToolsToAgentRequest(request, [decision.tool]),
-        };
-    }
-    /**
-     * Execute an agent (non-streaming)
-     */
-    async execute(id, data) {
-        return this.client.post(`/agents/${id}/execute`, {
-            ...data,
-            streamResponse: false,
-        });
-    }
-    /**
-     * 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()
-     * // ...
-     * ```
-     */
-    async executeStream(id, data) {
-        return this.client.requestStream(`/agents/${id}/execute`, {
-            method: 'POST',
-            body: JSON.stringify({
-                ...data,
-                streamResponse: true,
-            }),
-        });
-    }
-    /**
-     * 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)
-     * ```
-     */
-    async executeWithCallbacks(id, data, callbacks) {
-        const response = await this.executeStream(id, data);
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(error.error || `HTTP ${response.status}`);
-        }
-        let completeEvent = null;
-        await processAgentStream(response.body, {
-            ...callbacks,
-            onAgentComplete: (event) => {
-                completeEvent = event;
-                callbacks.onAgentComplete?.(event);
-            },
-        });
-        return completeEvent;
-    }
-    /**
-     * 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'
-     *   },
-     * })
-     * ```
-     */
-    async executeWithLocalTools(id, data, localTools, callbacks) {
-        // Build runtime tool definitions from local tool schemas and inject into request
-        const runtimeTools = Object.entries(localTools).map(([name, def]) => ({
-            name,
-            description: def.description,
-            toolType: 'local',
-            parametersSchema: def.parametersSchema,
-        }));
-        const requestData = {
-            ...data,
-            tools: {
-                ...data.tools,
-                runtimeTools: [...(data.tools?.runtimeTools || []), ...runtimeTools],
-            },
-        };
-        const response = await this.executeStream(id, requestData);
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(error.error || `HTTP ${response.status}`);
-        }
-        let currentBody = response.body;
-        while (true) {
-            let pausedEvent = null;
-            let completeEvent = null;
-            await processAgentStream(currentBody, {
-                ...callbacks,
-                onAgentPaused: (event) => {
-                    pausedEvent = event;
-                    callbacks?.onAgentPaused?.(event);
-                },
-                onAgentComplete: (event) => {
-                    completeEvent = event;
-                    callbacks?.onAgentComplete?.(event);
-                },
-            });
-            if (completeEvent)
-                return completeEvent;
-            if (pausedEvent) {
-                const { toolName, parameters, executionId } = pausedEvent;
-                const toolDef = localTools[toolName];
-                if (!toolDef) {
-                    throw new Error(`Local tool "${toolName}" required but not provided`);
-                }
-                // Recursively unwrap stringified parameters — the server pipeline may
-                // double-serialize: object → JSON string → JSON string
-                let parsedParams = {};
-                let current = parameters;
-                for (let i = 0; i < 3; i++) {
-                    if (typeof current === 'string') {
-                        try {
-                            current = JSON.parse(current);
-                        }
-                        catch {
-                            console.warn(`[local-tools] Failed to parse parameters (attempt ${i + 1}):`, typeof current, String(current).slice(0, 200));
-                            break;
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
-                if (current && typeof current === 'object' && !Array.isArray(current)) {
-                    parsedParams = current;
-                }
-                else {
-                    console.warn('[local-tools] Parameters could not be resolved to an object:', typeof current, String(current).slice(0, 200));
-                }
-                let toolResult;
-                try {
-                    toolResult = await toolDef.execute(parsedParams);
-                }
-                catch (err) {
-                    // Return the error as a tool result so the agent can recover
-                    toolResult = `Error: ${err instanceof Error ? err.message : String(err)}`;
-                }
-                // Resume via agent resume endpoint
-                const resumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        executionId,
-                        toolOutputs: { [toolName]: toolResult },
-                        streamResponse: true,
-                        debugMode: data.debugMode,
-                    }),
-                });
-                if (!resumeResponse.ok) {
-                    const error = await resumeResponse.json().catch(() => ({ error: 'Unknown error' }));
-                    throw new Error(error.error || `HTTP ${resumeResponse.status}`);
-                }
-                currentBody = resumeResponse.body;
-                continue;
-            }
-            // Stream ended without complete or paused
-            return null;
-        }
-    }
-    // ─── Long-Task Agent Execution ───────────────────────────────────────
-    /**
-     * 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`)
-     * ```
-     */
-    async runTask(id, options) {
-        const maxSessions = options.maxSessions ?? 50;
-        const maxCost = options.maxCost;
-        const useStream = options.stream ?? true;
-        // Resolve agent metadata
-        const agent = await this.get(id);
-        const taskName = typeof options.trackProgress === 'string'
-            ? options.trackProgress
-            : options.trackProgress
-                ? `${agent.name} task`
-                : '';
-        // Initialize state
-        const state = {
-            agentId: id,
-            agentName: agent.name,
-            taskName: taskName || `${agent.name} task`,
-            status: 'running',
-            sessionCount: 0,
-            totalCost: 0,
-            lastOutput: '',
-            lastStopReason: 'complete',
-            sessions: [],
-            startedAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-        // Track the record ID if we're syncing
-        let recordId;
-        // Extract local tool names for prompt injection
-        const localToolNames = options.localTools ? Object.keys(options.localTools) : undefined;
-        // Session loop
-        for (let session = 0; session < maxSessions; session++) {
-            // Build continuation context for resumed runs (first session only)
-            const continuationContext = session === 0 && options.previousMessages
-                ? {
-                    previousMessages: options.previousMessages,
-                    newUserMessage: options.continuationMessage,
-                    compact: options.compact,
-                }
-                : undefined;
-            // Store original message on first invocation (not a continuation)
-            if (session === 0 && !options.previousMessages) {
-                state.originalMessage = options.message;
-            }
-            // Build messages for this session
-            const messages = this.buildSessionMessages(options.message, state, session, maxSessions, localToolNames, continuationContext);
-            // Execute one session
-            let sessionResult;
-            const sessionData = {
-                messages,
-                debugMode: options.debugMode,
-                model: options.model,
-            };
-            if (useStream && options.localTools) {
-                // Local tools require the pause/resume streaming loop
-                const completeEvent = await this.executeWithLocalTools(id, sessionData, options.localTools, options.streamCallbacks);
-                if (!completeEvent) {
-                    throw new Error('Agent stream ended without a complete event');
-                }
-                sessionResult = {
-                    success: completeEvent.success,
-                    result: completeEvent.finalOutput || '',
-                    iterations: completeEvent.iterations,
-                    totalCost: completeEvent.totalCost || 0,
-                    stopReason: completeEvent.stopReason,
-                    error: completeEvent.error,
-                };
-            }
-            else if (useStream && options.streamCallbacks) {
-                const completeEvent = await this.executeWithCallbacks(id, sessionData, options.streamCallbacks);
-                if (!completeEvent) {
-                    throw new Error('Agent stream ended without a complete event');
-                }
-                sessionResult = {
-                    success: completeEvent.success,
-                    result: completeEvent.finalOutput || '',
-                    iterations: completeEvent.iterations,
-                    totalCost: completeEvent.totalCost || 0,
-                    stopReason: completeEvent.stopReason,
-                    error: completeEvent.error,
-                };
-            }
-            else {
-                sessionResult = await this.execute(id, sessionData);
-            }
-            // Update state
-            const sessionCost = sessionResult.totalCost;
-            state.sessionCount = session + 1;
-            state.totalCost += sessionCost;
-            state.lastOutput = sessionResult.result;
-            state.lastStopReason = sessionResult.stopReason;
-            state.updatedAt = new Date().toISOString();
-            state.sessions.push({
-                index: session + 1,
-                cost: sessionCost,
-                iterations: sessionResult.iterations,
-                stopReason: sessionResult.stopReason,
-                outputPreview: sessionResult.result.slice(0, 300),
-                completedAt: new Date().toISOString(),
-            });
-            // Track cost by model
-            const modelKey = options.model || 'default';
-            if (!state.costByModel)
-                state.costByModel = {};
-            state.costByModel[modelKey] = (state.costByModel[modelKey] || 0) + sessionCost;
-            // Accumulate messages for future continuation
-            if (!state.messages)
-                state.messages = [];
-            state.messages.push(...messages);
-            // Also store the assistant's response as a message
-            if (sessionResult.result) {
-                state.messages.push({ role: 'assistant', content: sessionResult.result });
-            }
-            // Keep session log trimmed to last 50 entries
-            if (state.sessions.length > 50) {
-                state.sessions = state.sessions.slice(-50);
-            }
-            // Check terminal conditions
-            if (sessionResult.stopReason === 'complete') {
-                state.status = 'complete';
-            }
-            else if (sessionResult.stopReason === 'error') {
-                state.status = 'complete';
-            }
-            else if (sessionResult.stopReason === 'max_cost') {
-                state.status = 'budget_exceeded';
-            }
-            else if (this.detectTaskCompletion(sessionResult.result)) {
-                // Client-side stop-phrase detection for non-loop agents returning 'end_turn'
-                state.status = 'complete';
-            }
-            else if (maxCost && state.totalCost >= maxCost) {
-                state.status = 'budget_exceeded';
-            }
-            else if (session + 1 >= maxSessions) {
-                state.status = 'max_sessions';
-            }
-            // Sync to record if enabled
-            if (options.trackProgress) {
-                recordId = await this.syncProgressRecord(state, recordId);
-            }
-            // Notify caller
-            if (options.onSession) {
-                const shouldStop = await options.onSession(state);
-                if (shouldStop === false) {
-                    state.status = 'paused';
-                }
-            }
-            // Stop if terminal
-            if (state.status !== 'running') {
-                break;
-            }
-        }
-        return {
-            status: state.status,
-            sessionCount: state.sessionCount,
-            totalCost: state.totalCost,
-            lastOutput: state.lastOutput,
-            sessions: state.sessions,
-            recordId,
-        };
-    }
-    /**
-     * Client-side fallback for detecting task completion in agent output.
-     * Mirrors the API's detectAutoComplete() for non-loop agents that return 'end_turn'.
-     */
-    detectTaskCompletion(output) {
-        const upper = output.toUpperCase();
-        return AgentsEndpoint.STOP_PHRASES.some((phrase) => upper.includes(phrase.toUpperCase()));
-    }
-    /**
-     * Generate a compact summary of prior work for continuation context.
-     * Used when compact mode is enabled to keep token usage low.
-     */
-    generateCompactSummary(state) {
-        const sessionSummaries = (state.sessions ?? [])
-            .map((s) => `- Session ${s.index}: ${s.stopReason} ($${s.cost.toFixed(4)}) -- ${s.outputPreview.slice(0, 100)}`)
-            .join('\n');
-        return [
-            `Task: ${state.taskName}`,
-            `Status: ${state.status}`,
-            `Sessions completed: ${state.sessionCount}`,
-            `Total cost: $${state.totalCost.toFixed(4)}`,
-            '',
-            'Session history:',
-            sessionSummaries,
-            '',
-            'Last output (truncated):',
-            (state.lastOutput || '').slice(0, 1500),
-        ].join('\n');
-    }
-    /**
-     * Build messages for a session, injecting progress context for continuation sessions.
-     * Optionally accepts continuation context for marathon resume scenarios.
-     */
-    buildSessionMessages(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext) {
-        // Build local tools guidance block when tools are available
-        const toolsBlock = localToolNames?.length
-            ? [
-                '',
-                '--- Local Tools ---',
-                `You have access to local filesystem tools (${localToolNames.join(', ')}) that execute directly on the user's machine.`,
-                'Use these tools to create working, runnable files — not just code in your response.',
-                'Prefer creating self-contained HTML files that the user can open in a web browser.',
-                'For example, write a single .html file with inline CSS and JavaScript that demonstrates the result.',
-                'Always use write_file to save your output so the user can run it immediately.',
-            ].join('\n')
-            : '';
-        const multiSessionInstruction = `This is a multi-session task (session ${sessionIndex + 1}/${maxSessions}). When you have fully completed the task, end your response with TASK_COMPLETE on its own line.`;
-        // Continuation resume: first session of a resumed run with prior context
-        if (continuationContext && sessionIndex === 0) {
-            const defaultContinueMessage = 'Continue the task. Review your prior work above and proceed with any remaining work. If everything is already complete, respond with TASK_COMPLETE.';
-            const userMessage = continuationContext.newUserMessage || defaultContinueMessage;
-            if (continuationContext.compact) {
-                // Compact mode: summarize prior work instead of full history
-                const summary = this.generateCompactSummary(state);
-                const messages = [
-                    {
-                        role: 'system',
-                        content: `You are continuing a previously completed task. Here is a summary of prior work:\n\n${summary}\n\nDo NOT redo any of the above work.`,
-                    },
-                    {
-                        role: 'user',
-                        content: [userMessage, toolsBlock, '', multiSessionInstruction].join('\n'),
-                    },
-                ];
-                return messages;
-            }
-            // Full history mode: replay all previous messages with do-not-redo instruction
-            const messages = [
-                ...continuationContext.previousMessages,
-                {
-                    role: 'system',
-                    content: 'IMPORTANT: You are continuing a previously completed task. The conversation above shows your prior work. Do NOT redo any of it. Build on what was already accomplished. If there is nothing new to do, respond with TASK_COMPLETE.',
-                },
-                {
-                    role: 'user',
-                    content: [userMessage, toolsBlock, '', multiSessionInstruction].join('\n'),
-                },
-            ];
-            return messages;
-        }
-        // First session (non-continuation): user message + completion signal instruction
-        if (sessionIndex === 0) {
-            const content = [originalMessage, toolsBlock, '', multiSessionInstruction].join('\n');
-            return [{ role: 'user', content }];
-        }
-        // Continuation sessions within a run: inject progress context
-        const recentSessions = state.sessions.slice(-5);
-        const progressSummary = recentSessions
-            .map((s) => `  Session ${s.index}: ${s.stopReason} ($${s.cost.toFixed(4)}) — ${s.outputPreview.slice(0, 100)}`)
-            .join('\n');
-        const content = [
-            originalMessage,
-            toolsBlock,
-            '',
-            `--- Progress (session ${sessionIndex + 1}/${maxSessions}, $${state.totalCost.toFixed(4)} spent) ---`,
-            `Previous sessions:`,
-            progressSummary,
-            '',
-            `Last output (do NOT repeat this — build on it):`,
-            state.lastOutput.slice(0, 1000),
-            '',
-            'Continue where you left off. Do not redo previous work. If the task is already complete, respond with TASK_COMPLETE.',
-        ].join('\n');
-        return [{ role: 'user', content }];
-    }
-    /**
-     * Upsert a record to sync long-task progress to the dashboard.
-     * Creates the record on first call, updates it on subsequent calls.
-     */
-    async syncProgressRecord(state, existingRecordId) {
-        const metadata = {
-            agentId: state.agentId,
-            agentName: state.agentName,
-            status: state.status,
-            sessionCount: state.sessionCount,
-            totalCost: state.totalCost,
-            lastStopReason: state.lastStopReason,
-            lastOutputPreview: state.lastOutput.slice(0, 500),
-            sessions: state.sessions.slice(-10), // Keep last 10 in the record
-            startedAt: state.startedAt,
-            updatedAt: state.updatedAt,
-        };
-        try {
-            if (existingRecordId) {
-                // Update existing record
-                const record = await this.client.put(`/records/${existingRecordId}`, {
-                    metadata,
-                });
-                return record.id;
-            }
-            else {
-                // Try to find existing record by type + name first
-                const existing = await this.client.get('/records', {
-                    type: 'agent-task',
-                    name: state.taskName,
-                    limit: 1,
-                });
-                if (existing.data.length > 0) {
-                    const record = await this.client.put(`/records/${existing.data[0].id}`, {
-                        metadata,
-                    });
-                    return record.id;
-                }
-                // Create new record
-                const record = await this.client.post('/records', {
-                    type: 'agent-task',
-                    name: state.taskName,
-                    metadata,
-                });
-                return record.id;
-            }
-        }
-        catch {
-            // Record sync is best-effort — don't fail the task
-            return existingRecordId || '';
-        }
-    }
-}
-exports.AgentsEndpoint = AgentsEndpoint;
-/** Stop phrases that indicate the agent considers its task complete. */
-AgentsEndpoint.STOP_PHRASES = [
-    'DONE:',
-    'TASK_COMPLETE',
-    'FINISHED',
-    '[COMPLETE]',
-    'STATUS: RESOLVED',
-    'STATUS: COMPLETE',
-];
-//# sourceMappingURL=endpoints.js.map