@cortask/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1193 @@
+import { z } from 'zod';
+import OpenAI from 'openai';
+
+interface Message {
+    role: "user" | "assistant" | "system";
+    content: string | ContentPart[];
+}
+interface ContentPart {
+    type: "text" | "image" | "tool_use" | "tool_result" | "thinking";
+    text?: string;
+    imageUrl?: string;
+    imageBase64?: string;
+    mimeType?: string;
+    toolCallId?: string;
+    toolName?: string;
+    toolArguments?: Record<string, unknown>;
+    isError?: boolean;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+interface ToolResult {
+    toolCallId: string;
+    content: string;
+    isError?: boolean;
+    artifactType?: string;
+    artifactId?: string;
+    artifacts?: Array<{
+        id: string;
+        type: string;
+        meta?: Record<string, unknown>;
+    }>;
+}
+interface GenerateTextParams {
+    model: string;
+    messages: Message[];
+    systemPrompt?: string;
+    tools?: ToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+}
+interface GenerateTextResult {
+    content: string;
+    thinking?: string;
+    toolCalls: ToolCall[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    stopReason: "end" | "tool_use" | "max_tokens";
+}
+interface StreamChunk {
+    type: "text" | "thinking" | "tool_call_start" | "tool_call_delta" | "tool_call_end" | "message_end";
+    text?: string;
+    toolCall?: Partial<ToolCall>;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+interface EmbedParams {
+    model: string;
+    inputs: string[];
+}
+interface EmbedResult {
+    embeddings: number[][];
+    usage: {
+        totalTokens: number;
+    };
+}
+interface ModelInfo {
+    id: string;
+    name: string;
+    contextWindow?: number;
+    inputPricePer1m?: number;
+    outputPricePer1m?: number;
+}
+interface LLMProvider {
+    readonly id: string;
+    generateText(params: GenerateTextParams): Promise<GenerateTextResult>;
+    generateStream(params: GenerateTextParams): AsyncIterable<StreamChunk>;
+    embed(params: EmbedParams): Promise<EmbedResult>;
+    listModels(): Promise<ModelInfo[]>;
+}
+
+declare class OpenAICompatibleProvider implements LLMProvider {
+    readonly id: string;
+    protected client: OpenAI;
+    constructor(id: string, apiKey: string, baseURL?: string);
+    generateText(params: GenerateTextParams): Promise<GenerateTextResult>;
+    generateStream(params: GenerateTextParams): AsyncIterable<StreamChunk>;
+    embed(params: EmbedParams): Promise<EmbedResult>;
+    listModels(): Promise<ModelInfo[]>;
+}
+
+declare class AnthropicProvider implements LLMProvider {
+    readonly id = "anthropic";
+    private client;
+    constructor(apiKey: string);
+    generateText(params: GenerateTextParams): Promise<GenerateTextResult>;
+    generateStream(params: GenerateTextParams): AsyncIterable<StreamChunk>;
+    embed(_params: EmbedParams): Promise<EmbedResult>;
+    listModels(): Promise<ModelInfo[]>;
+}
+
+declare class OpenAIProvider extends OpenAICompatibleProvider {
+    constructor(apiKey: string);
+}
+
+declare class GoogleProvider implements LLMProvider {
+    readonly id = "google";
+    private client;
+    constructor(apiKey: string);
+    generateText(params: GenerateTextParams): Promise<GenerateTextResult>;
+    generateStream(params: GenerateTextParams): AsyncIterable<StreamChunk>;
+    embed(params: EmbedParams): Promise<EmbedResult>;
+    listModels(): Promise<ModelInfo[]>;
+}
+
+declare class MoonshotProvider extends OpenAICompatibleProvider {
+    constructor(apiKey: string);
+}
+
+declare class GrokProvider extends OpenAICompatibleProvider {
+    constructor(apiKey: string);
+}
+
+declare class OpenRouterProvider extends OpenAICompatibleProvider {
+    private apiKeyValue;
+    constructor(apiKey: string);
+    listModels(): Promise<ModelInfo[]>;
+}
+
+declare class MiniMaxProvider extends OpenAICompatibleProvider {
+    constructor(apiKey: string);
+}
+
+declare class OllamaProvider implements LLMProvider {
+    readonly id = "ollama";
+    private host;
+    constructor(host: string);
+    generateText(params: GenerateTextParams): Promise<GenerateTextResult>;
+    generateStream(params: GenerateTextParams): AsyncIterable<StreamChunk>;
+    embed(params: EmbedParams): Promise<EmbedResult>;
+    listModels(): Promise<ModelInfo[]>;
+}
+
+type ProviderId = "anthropic" | "openai" | "google" | "moonshot" | "grok" | "openrouter" | "minimax" | "ollama";
+interface ProviderInfo {
+    id: ProviderId;
+    name: string;
+    requiresApiKey: boolean;
+}
+declare const AVAILABLE_PROVIDERS: ProviderInfo[];
+declare function getProviderInfo(id: ProviderId): ProviderInfo | undefined;
+declare function createProvider(id: ProviderId, apiKey: string): LLMProvider;
+
+interface Attachment {
+    mimeType: string;
+    base64: string;
+    name?: string;
+}
+interface AgentRunParams {
+    prompt: string;
+    attachments?: Attachment[];
+    sessionId?: string;
+    workspaceId?: string;
+    signal?: AbortSignal;
+}
+interface AgentRunResult {
+    runId: string;
+    response: string;
+    toolCalls: ToolCall[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+interface PermissionRequest {
+    id: string;
+    type: "file_write" | "file_delete" | "bash" | "other";
+    description: string;
+    details?: string;
+}
+interface QuestionnaireQuestion {
+    id: string;
+    question: string;
+    type: "single" | "multiple" | "text" | "textarea";
+    options?: Array<{
+        value: string;
+        label: string;
+        description?: string;
+    }>;
+    required?: boolean;
+    placeholder?: string;
+    allowOther?: boolean;
+}
+interface QuestionnaireRequest {
+    id: string;
+    title?: string;
+    description?: string;
+    questions: QuestionnaireQuestion[];
+}
+interface QuestionnaireResponse {
+    [questionId: string]: string | string[];
+}
+interface AgentStreamEvent {
+    type: "thinking_delta" | "text_delta" | "tool_call_start" | "tool_call_delta" | "tool_call_end" | "tool_result" | "permission_request" | "questionnaire_request" | "done" | "error";
+    text?: string;
+    toolName?: string;
+    toolCallId?: string;
+    toolArgs?: Record<string, unknown>;
+    toolResult?: ToolResult;
+    permissionRequest?: PermissionRequest;
+    questionnaireRequest?: QuestionnaireRequest;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        costUsd?: number;
+    };
+    error?: string;
+}
+interface ToolHandler {
+    definition: ToolDefinition;
+    execute: (args: Record<string, unknown>, context: ToolExecutionContext) => Promise<ToolResult>;
+}
+interface ToolExecutionContext {
+    workspacePath: string;
+    dataDir: string;
+    sessionId: string;
+    runId: string;
+    requestPermission: (req: PermissionRequest) => Promise<boolean>;
+    requestQuestionnaire: (req: QuestionnaireRequest) => Promise<QuestionnaireResponse>;
+}
+
+interface AgentRunnerConfig {
+    provider: LLMProvider;
+    model: string;
+    maxTurns: number;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface AgentRunnerDeps {
+    config: AgentRunnerConfig;
+    tools: ToolHandler[];
+    getWorkspacePath: () => string;
+    getDataDir: () => string;
+    getMemoryContent: () => Promise<string | undefined>;
+    getGlobalMemoryContent: () => Promise<string | undefined>;
+    getSkillPrompts: () => string[];
+    getSessionMessages: (sessionId: string) => Promise<Message[]>;
+    saveSessionMessages: (sessionId: string, messages: Message[]) => Promise<void>;
+    channel?: {
+        type: string;
+        chatId: string;
+    };
+    onPermissionRequest?: (req: PermissionRequest) => Promise<boolean>;
+    onQuestionnaireRequest?: (req: QuestionnaireRequest) => Promise<QuestionnaireResponse>;
+}
+declare class AgentRunner {
+    private deps;
+    constructor(deps: AgentRunnerDeps);
+    private buildToolDefinitions;
+    private getToolHandler;
+    private buildSystemPromptText;
+    private createToolContext;
+    run(params: AgentRunParams): Promise<AgentRunResult>;
+    runStream(params: AgentRunParams): AsyncIterable<AgentStreamEvent>;
+}
+
+interface CronScheduleAt {
+    type: "at";
+    datetime: string;
+}
+interface CronScheduleEvery {
+    type: "every";
+    intervalMs: number;
+}
+interface CronScheduleCron {
+    type: "cron";
+    expression: string;
+    timezone?: string;
+}
+type CronSchedule = CronScheduleAt | CronScheduleEvery | CronScheduleCron;
+interface CronDelivery {
+    channel?: string;
+    target?: string;
+    sessionKey?: string;
+}
+interface CronJob {
+    id: string;
+    name: string;
+    enabled: boolean;
+    schedule: CronSchedule;
+    prompt: string;
+    delivery: CronDelivery;
+    workspaceId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CronJobState {
+    jobId: string;
+    nextRunAtMs: number | null;
+    lastRunAtMs: number | null;
+    lastStatus: "success" | "error" | null;
+    lastError: string | null;
+    consecutiveErrors: number;
+}
+interface CronJobCreate {
+    name: string;
+    schedule: CronSchedule;
+    prompt: string;
+    delivery?: CronDelivery;
+    workspaceId?: string;
+    enabled?: boolean;
+}
+interface CronEvent {
+    type: "added" | "removed" | "started" | "finished" | "error";
+    jobId: string;
+    jobName: string;
+    result?: string;
+    error?: string;
+}
+
+type EventHandler = (event: CronEvent) => void;
+type JobExecutor = (job: CronJob) => Promise<string>;
+declare class CronService {
+    private db;
+    private timer;
+    private running;
+    private executor;
+    private eventHandlers;
+    constructor(dbPath: string);
+    private initSchema;
+    setExecutor(executor: JobExecutor): void;
+    onEvent(handler: EventHandler): void;
+    private emit;
+    start(): void;
+    stop(): void;
+    private scheduleNext;
+    private tick;
+    private executeJob;
+    add(input: CronJobCreate): CronJob;
+    update(id: string, updates: Partial<Pick<CronJob, "name" | "enabled" | "schedule" | "prompt" | "delivery">>): CronJob | null;
+    remove(id: string): boolean;
+    getJob(id: string): CronJob | null;
+    list(workspaceId?: string): CronJob[];
+    getState(jobId: string): CronJobState | null;
+    runNow(id: string): Promise<void>;
+    private upsertState;
+    close(): void;
+}
+
+/**
+ * Creates a cron tool handler bound to a CronService instance.
+ * This is a factory because the cron service is initialized at runtime.
+ */
+declare function createCronTool(cronService: CronService): ToolHandler;
+
+interface Artifact {
+    id: string;
+    type: "html" | "csv" | "image" | "json" | "text" | "svg";
+    title: string;
+    content: string;
+    mimeType: string;
+    createdAt: number;
+}
+declare class ArtifactStore {
+    private store;
+    create(type: Artifact["type"], title: string, content: string): Artifact;
+    get(id: string): Artifact | undefined;
+    list(): Artifact[];
+    delete(id: string): boolean;
+    private pruneExpired;
+}
+
+/**
+ * Creates an artifact tool handler bound to an ArtifactStore instance.
+ */
+declare function createArtifactTool(artifactStore: ArtifactStore): ToolHandler;
+
+declare function createBrowserTool(artifactStore: ArtifactStore): ToolHandler;
+
+/**
+ * Set the AgentRunner reference for subagent spawning.
+ * Must be called after AgentRunner instantiation.
+ */
+declare function setSubagentRunner(runner: AgentRunner): void;
+/**
+ * Create the subagent tool handler.
+ * Factory pattern to allow runtime injection of dependencies.
+ */
+declare function createSubagentTool(): ToolHandler;
+
+interface Workspace {
+    id: string;
+    name: string;
+    rootPath: string;
+    lastAccessedAt: string;
+    provider?: string;
+    model?: string;
+    skills?: string[];
+}
+declare class WorkspaceManager {
+    private db;
+    private dataDir;
+    private activeWorkspaceId;
+    constructor(dbPath: string);
+    private initSchema;
+    list(): Promise<Workspace[]>;
+    get(id: string): Promise<Workspace | null>;
+    create(name: string, rootPath?: string): Promise<Workspace>;
+    update(id: string, updates: Partial<Pick<Workspace, "name" | "provider" | "model" | "skills">>): Promise<void>;
+    reorder(orderedIds: string[]): Promise<void>;
+    delete(id: string): Promise<void>;
+    open(id: string): Promise<Workspace | null>;
+    getActiveWorkspaceId(): string | null;
+    getActiveWorkspace(): Promise<Workspace | null>;
+    readMemory(workspacePath: string): Promise<string | undefined>;
+    writeMemory(workspacePath: string, content: string): Promise<void>;
+    readGlobalMemory(dataDir: string): Promise<string | undefined>;
+    writeGlobalMemory(dataDir: string, content: string): Promise<void>;
+    getSessionDbPath(workspacePath: string): string;
+    getChannelWorkspace(chatKey: string): string | null;
+    setChannelWorkspace(chatKey: string, workspaceId: string): void;
+    close(): void;
+}
+
+/**
+ * Creates a switch_workspace tool for channel-based runners.
+ * Allows the user to list workspaces or switch to a different one.
+ * Switching updates the workspace mapping so the next message uses the new workspace.
+ */
+declare function createSwitchWorkspaceTool(workspaceManager: WorkspaceManager, chatKey: string): ToolHandler;
+
+declare const builtinTools: ToolHandler[];
+
+interface SystemPromptContext {
+    workspacePath: string;
+    globalMemoryContent?: string;
+    memoryContent?: string;
+    skillPrompts?: string[];
+    toolNames: string[];
+    channel?: {
+        type: string;
+        chatId: string;
+    };
+}
+declare function buildSystemPrompt(ctx: SystemPromptContext): string;
+
+interface SubagentRunRecord {
+    runId: string;
+    childSessionId: string;
+    parentSessionId: string;
+    parentRunId: string;
+    task: string;
+    depth: number;
+    status: "running" | "done" | "error" | "timeout" | "cancelled";
+    result?: string;
+    error?: string;
+    createdAt: number;
+    endedAt?: number;
+    abortController?: AbortController;
+}
+declare const SUBAGENT_DEFAULTS: {
+    readonly maxDepth: 1;
+    readonly maxChildrenPerAgent: 5;
+    readonly timeoutMs: 120000;
+};
+
+/**
+ * Register a new subagent run in the registry.
+ */
+declare function registerSubagentRun(record: SubagentRunRecord): void;
+/**
+ * Retrieve a subagent run by its ID.
+ */
+declare function getSubagentRun(runId: string): SubagentRunRecord | undefined;
+/**
+ * Mark a subagent run as complete with result or error.
+ */
+declare function completeSubagentRun(runId: string, status: "done" | "error" | "timeout" | "cancelled", result?: string, error?: string): void;
+/**
+ * Cancel a subagent run and all its children.
+ */
+declare function cancelSubagentRun(runId: string): boolean;
+/**
+ * Cancel all children of a parent session.
+ */
+declare function cancelChildrenOfSession(parentSessionId: string): number;
+/**
+ * Count how many active (running) children belong to a parent session.
+ */
+declare function countActiveChildren(parentSessionId: string): number;
+/**
+ * Get the depth of a session (0 for root, 1+ for subagents).
+ */
+declare function getDepthForSession(sessionId: string): number;
+/**
+ * Cleanup old completed subagent records.
+ * @param maxAgeMs Maximum age in milliseconds (default: 30 minutes)
+ */
+declare function cleanupSubagentRecords(maxAgeMs?: number): void;
+
+interface CredentialStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    list(): Promise<string[]>;
+}
+declare class EncryptedCredentialStore implements CredentialStore {
+    private filePath;
+    private secret;
+    private store;
+    constructor(filePath: string, secret: string);
+    private load;
+    private save;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    list(): Promise<string[]>;
+}
+declare function getOrCreateSecret(dataDir: string): Promise<string>;
+declare function credentialKey(category: string, ...parts: string[]): string;
+
+declare const cortaskConfigSchema: z.ZodObject<{
+    onboarded: z.ZodDefault<z.ZodBoolean>;
+    workspace: z.ZodDefault<z.ZodObject<{
+        defaultDir: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        defaultDir?: string | undefined;
+    }, {
+        defaultDir?: string | undefined;
+    }>>;
+    providers: z.ZodDefault<z.ZodObject<{
+        default: z.ZodDefault<z.ZodString>;
+        anthropic: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        openai: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        google: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        moonshot: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        grok: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        openrouter: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        minimax: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+        ollama: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+        }, {
+            model?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        anthropic: {
+            model?: string | undefined;
+        };
+        openai: {
+            model?: string | undefined;
+        };
+        google: {
+            model?: string | undefined;
+        };
+        moonshot: {
+            model?: string | undefined;
+        };
+        grok: {
+            model?: string | undefined;
+        };
+        openrouter: {
+            model?: string | undefined;
+        };
+        minimax: {
+            model?: string | undefined;
+        };
+        default: string;
+        ollama: {
+            model?: string | undefined;
+        };
+    }, {
+        anthropic?: {
+            model?: string | undefined;
+        } | undefined;
+        openai?: {
+            model?: string | undefined;
+        } | undefined;
+        google?: {
+            model?: string | undefined;
+        } | undefined;
+        moonshot?: {
+            model?: string | undefined;
+        } | undefined;
+        grok?: {
+            model?: string | undefined;
+        } | undefined;
+        openrouter?: {
+            model?: string | undefined;
+        } | undefined;
+        minimax?: {
+            model?: string | undefined;
+        } | undefined;
+        default?: string | undefined;
+        ollama?: {
+            model?: string | undefined;
+        } | undefined;
+    }>>;
+    agent: z.ZodDefault<z.ZodObject<{
+        maxTurns: z.ZodDefault<z.ZodNumber>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        temperature: number;
+        maxTurns: number;
+        maxTokens?: number | undefined;
+    }, {
+        temperature?: number | undefined;
+        maxTurns?: number | undefined;
+        maxTokens?: number | undefined;
+    }>>;
+    spending: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        maxCostUsd: z.ZodOptional<z.ZodNumber>;
+        period: z.ZodDefault<z.ZodEnum<["daily", "weekly", "monthly"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        period: "daily" | "weekly" | "monthly";
+        maxTokens?: number | undefined;
+        maxCostUsd?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        maxTokens?: number | undefined;
+        maxCostUsd?: number | undefined;
+        period?: "daily" | "weekly" | "monthly" | undefined;
+    }>>;
+    channels: z.ZodDefault<z.ZodObject<{
+        telegram: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            allowedUsers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            allowedUsers: string[];
+        }, {
+            enabled?: boolean | undefined;
+            allowedUsers?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        telegram: {
+            enabled: boolean;
+            allowedUsers: string[];
+        };
+    }, {
+        telegram?: {
+            enabled?: boolean | undefined;
+            allowedUsers?: string[] | undefined;
+        } | undefined;
+    }>>;
+    skills: z.ZodDefault<z.ZodObject<{
+        dirs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        dirs: string[];
+    }, {
+        dirs?: string[] | undefined;
+    }>>;
+    server: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        host: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        host: string;
+    }, {
+        port?: number | undefined;
+        host?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    agent: {
+        temperature: number;
+        maxTurns: number;
+        maxTokens?: number | undefined;
+    };
+    skills: {
+        dirs: string[];
+    };
+    onboarded: boolean;
+    workspace: {
+        defaultDir?: string | undefined;
+    };
+    providers: {
+        anthropic: {
+            model?: string | undefined;
+        };
+        openai: {
+            model?: string | undefined;
+        };
+        google: {
+            model?: string | undefined;
+        };
+        moonshot: {
+            model?: string | undefined;
+        };
+        grok: {
+            model?: string | undefined;
+        };
+        openrouter: {
+            model?: string | undefined;
+        };
+        minimax: {
+            model?: string | undefined;
+        };
+        default: string;
+        ollama: {
+            model?: string | undefined;
+        };
+    };
+    spending: {
+        enabled: boolean;
+        period: "daily" | "weekly" | "monthly";
+        maxTokens?: number | undefined;
+        maxCostUsd?: number | undefined;
+    };
+    channels: {
+        telegram: {
+            enabled: boolean;
+            allowedUsers: string[];
+        };
+    };
+    server: {
+        port: number;
+        host: string;
+    };
+}, {
+    agent?: {
+        temperature?: number | undefined;
+        maxTurns?: number | undefined;
+        maxTokens?: number | undefined;
+    } | undefined;
+    skills?: {
+        dirs?: string[] | undefined;
+    } | undefined;
+    onboarded?: boolean | undefined;
+    workspace?: {
+        defaultDir?: string | undefined;
+    } | undefined;
+    providers?: {
+        anthropic?: {
+            model?: string | undefined;
+        } | undefined;
+        openai?: {
+            model?: string | undefined;
+        } | undefined;
+        google?: {
+            model?: string | undefined;
+        } | undefined;
+        moonshot?: {
+            model?: string | undefined;
+        } | undefined;
+        grok?: {
+            model?: string | undefined;
+        } | undefined;
+        openrouter?: {
+            model?: string | undefined;
+        } | undefined;
+        minimax?: {
+            model?: string | undefined;
+        } | undefined;
+        default?: string | undefined;
+        ollama?: {
+            model?: string | undefined;
+        } | undefined;
+    } | undefined;
+    spending?: {
+        enabled?: boolean | undefined;
+        maxTokens?: number | undefined;
+        maxCostUsd?: number | undefined;
+        period?: "daily" | "weekly" | "monthly" | undefined;
+    } | undefined;
+    channels?: {
+        telegram?: {
+            enabled?: boolean | undefined;
+            allowedUsers?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    server?: {
+        port?: number | undefined;
+        host?: string | undefined;
+    } | undefined;
+}>;
+type CortaskConfig = z.infer<typeof cortaskConfigSchema>;
+declare function loadConfig(configPath: string): Promise<CortaskConfig>;
+declare function saveConfig(configPath: string, config: CortaskConfig): Promise<void>;
+declare function getDataDir(): string;
+
+interface OnboardingData {
+    provider: {
+        type: ProviderId;
+        apiKey: string;
+    };
+    workspace: {
+        defaultDir: string;
+    };
+}
+interface OnboardingStatus {
+    completed: boolean;
+    hasProvider: boolean;
+    hasWorkspace: boolean;
+}
+interface ProviderValidationResult {
+    valid: boolean;
+    error?: string;
+    model?: string;
+}
+
+declare function validateProvider(type: ProviderId, apiKey: string): Promise<ProviderValidationResult>;
+
+type ChannelType = "whatsapp" | "telegram" | "discord";
+interface Session {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    parentSessionId?: string;
+    depth?: number;
+    channel?: ChannelType;
+}
+interface SessionWithMessages extends Session {
+    messages: Message[];
+}
+declare class SessionStore {
+    private db;
+    constructor(dbPath: string);
+    private initSchema;
+    listSessions(): Session[];
+    getSession(id: string): SessionWithMessages | null;
+    createSession(id: string, title?: string, parentSessionId?: string, depth?: number, channel?: ChannelType): Session;
+    saveMessages(sessionId: string, messages: Message[], channel?: ChannelType): void;
+    getMessages(sessionId: string): Message[];
+    deleteSession(id: string): void;
+    updateTitle(id: string, title: string): void;
+    close(): void;
+}
+
+/**
+ * Run database migrations on a session database.
+ * This is separate from SessionStore to allow running migrations at startup
+ * before any SessionStore instances are cached.
+ */
+declare function migrateSessionDatabase(dbPath: string): void;
+/**
+ * Migrate all workspace session databases.
+ * @param workspaces Array of workspace objects with rootPath property
+ */
+declare function migrateAllWorkspaces(workspaces: Array<{
+    rootPath: string;
+}>): void;
+
+interface SkillToolInput {
+    type: string;
+    description?: string;
+    enum?: string[];
+    required?: boolean;
+}
+interface SkillToolTemplate {
+    name: string;
+    description: string;
+    input: Record<string, SkillToolInput>;
+    request: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+    };
+}
+type SkillInstallKind = "brew" | "npm" | "go" | "uv" | "download" | "winget" | "scoop" | "choco";
+interface SkillInstallSpec {
+    id?: string;
+    kind: SkillInstallKind;
+    label?: string;
+    bins?: string[];
+    os?: string[];
+    formula?: string;
+    package?: string;
+    module?: string;
+    url?: string;
+    archive?: string;
+    extract?: boolean;
+    targetDir?: string;
+}
+interface SkillInstallOption {
+    id: string;
+    kind: SkillInstallKind;
+    label: string;
+}
+interface SkillManifest {
+    name: string;
+    description: string;
+    requires?: {
+        env?: string[];
+        bins?: string[];
+        config?: string[];
+    };
+    install?: SkillInstallSpec[];
+    tools?: SkillToolTemplate[];
+    compatibility?: {
+        os?: string[];
+    };
+    always?: boolean;
+    metadata?: {
+        homepage?: string;
+        tags?: string[];
+        author?: string;
+        gitUrl?: string;
+        [key: string]: unknown;
+    };
+}
+type SkillSource = "bundled" | "user" | "config-dir" | "git";
+interface SkillEntry {
+    manifest: SkillManifest;
+    content: string;
+    path: string;
+    eligible: boolean;
+    ineligibleReason?: string;
+    source: SkillSource;
+    editable: boolean;
+    hasCodeTools?: boolean;
+    installOptions?: SkillInstallOption[];
+    credentialSchema?: CredentialSchema;
+    credentialStatus?: Record<string, boolean>;
+}
+interface SkillCodeTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    execute: (args: Record<string, unknown>, context: {
+        credentialStore: unknown;
+        skillName: string;
+    }) => Promise<{
+        content: string;
+        isError?: boolean;
+    }>;
+}
+type CredentialAuthType = "api-key" | "basic-auth" | "bearer-token" | "oauth2" | "custom";
+type CredentialFieldType = "text" | "secret" | "url" | "email" | "model-select";
+interface CredentialField {
+    key: string;
+    label: string;
+    type: CredentialFieldType;
+    required?: boolean;
+    description?: string;
+    placeholder?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+}
+interface OAuth2Config {
+    authorizationUrl: string;
+    tokenUrl: string;
+    scopes?: string[];
+    pkce?: boolean;
+    refreshable?: boolean;
+}
+interface CredentialDefinition {
+    id: string;
+    type: CredentialAuthType;
+    name: string;
+    description?: string;
+    fields?: CredentialField[];
+    oauth?: OAuth2Config;
+    storeAs?: string;
+    multiple?: boolean;
+}
+interface CredentialSchema {
+    credentials: CredentialDefinition[];
+}
+
+declare function clearSkillCache(): void;
+/**
+ * Load all skills from bundled, user, and config directories.
+ */
+declare function loadSkills(bundledDir: string | null, userDir: string | null, configDirs: string[], credentialStore: CredentialStore | null): Promise<SkillEntry[]>;
+/**
+ * Get only eligible skills.
+ */
+declare function getEligibleSkills(skills: SkillEntry[]): SkillEntry[];
+
+interface SkillToolRegistry {
+    toolDefs: ToolDefinition[];
+    toolNames: Set<string>;
+    handlers: Map<string, (args: Record<string, unknown>) => Promise<ToolResult>>;
+}
+/**
+ * Build tool definitions and handlers from eligible skills.
+ */
+declare function buildSkillTools(skills: SkillEntry[], credentialStore: CredentialStore | null): Promise<SkillToolRegistry>;
+
+/**
+ * Install a skill from a git URL into the user skills directory.
+ */
+declare function installSkillFromGit(gitUrl: string, skillsDir: string): Promise<{
+    name: string;
+    path: string;
+}>;
+/**
+ * Remove an installed skill.
+ */
+declare function removeSkill(skillName: string, skillsDir: string): Promise<void>;
+
+/**
+ * Get the credential store key for a skill credential field.
+ * Format: skill.{skillName}.{credentialId}.{fieldKey}
+ */
+declare function getCredentialStorageKey(skillName: string, credentialId: string, fieldKey: string, storeAs?: string): string;
+/**
+ * Get OAuth2 storage keys for a skill credential.
+ */
+declare function getOAuth2StorageKeys(skillName: string, credentialId: string): {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: string;
+};
+
+/**
+ * Build the OAuth2 authorization URL for a skill.
+ */
+declare function buildSkillOAuth2AuthUrl(skillName: string, oauth: OAuth2Config, clientId: string, redirectUri: string, state: string): string;
+/**
+ * Exchange an OAuth2 authorization code for tokens and store them.
+ */
+declare function exchangeSkillOAuth2Code(skillName: string, credentialId: string, oauth: OAuth2Config, clientId: string, clientSecret: string, code: string, redirectUri: string, credentialStore: EncryptedCredentialStore): Promise<void>;
+/**
+ * Revoke OAuth2 tokens for a skill by removing them from the credential store.
+ */
+declare function revokeSkillOAuth2(skillName: string, credentialId: string, credentialStore: EncryptedCredentialStore): Promise<void>;
+
+/**
+ * Compute the next run time in milliseconds for a given schedule.
+ * Returns null if the schedule has no future run (e.g. one-shot in the past).
+ */
+declare function computeNextRunAtMs(schedule: CronSchedule, now?: number): number | null;
+/**
+ * Validate a cron expression. Returns null if valid, error message if not.
+ */
+declare function validateCronExpr(expression: string): string | null;
+
+interface EnabledModel {
+    id: string;
+    provider: string;
+    modelId: string;
+    label: string;
+    inputPricePer1m: number;
+    outputPricePer1m: number;
+    enabledAt: string;
+}
+declare class ModelStore {
+    private db;
+    constructor(dbPath: string);
+    private initSchema;
+    list(provider?: string): EnabledModel[];
+    enable(provider: string, modelId: string, label: string, inputPricePer1m: number, outputPricePer1m: number): EnabledModel;
+    disable(provider: string, modelId: string): void;
+    updatePricing(provider: string, modelId: string, inputPricePer1m: number, outputPricePer1m: number): void;
+    getPricing(provider: string, modelId: string): {
+        input: number;
+        output: number;
+    } | null;
+}
+
+interface UsageRecord {
+    id: number;
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    createdAt: string;
+}
+interface UsageSummary {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCostUsd: number;
+    recordCount: number;
+}
+declare function estimateCost(inputTokens: number, outputTokens: number, pricing: {
+    input: number;
+    output: number;
+}): number;
+declare class UsageStore {
+    private db;
+    private modelStore;
+    constructor(dbPath: string, modelStore: ModelStore);
+    private initSchema;
+    record(provider: string, model: string, inputTokens: number, outputTokens: number): void;
+    getSummary(period: "daily" | "weekly" | "monthly"): UsageSummary;
+    getHistory(days?: number): Array<{
+        date: string;
+        tokens: number;
+        costUsd: number;
+    }>;
+    private periodStart;
+}
+
+/**
+ * Hardcoded model definitions with pricing (per 1M tokens in USD).
+ * OpenRouter is excluded — it fetches models from its API.
+ */
+declare const MODEL_DEFINITIONS: Record<string, ModelInfo[]>;
+declare function getModelDefinitions(providerId: string): ModelInfo[];
+
+interface PromptTemplate {
+    id: string;
+    name: string;
+    content: string;
+    category: string;
+    createdAt: string;
+    updatedAt: string;
+}
+declare class TemplateStore {
+    private db;
+    constructor(dbPath: string);
+    private initSchema;
+    list(): PromptTemplate[];
+    get(id: string): PromptTemplate | null;
+    create(name: string, content: string, category?: string): PromptTemplate;
+    update(id: string, data: Partial<Pick<PromptTemplate, "name" | "content" | "category">>): PromptTemplate | null;
+    delete(id: string): void;
+}
+
+type LogLevel = "info" | "warn" | "error" | "debug";
+declare class Logger {
+    private logDir;
+    private stream;
+    private currentDate;
+    init(logDir: string): void;
+    private ensureStream;
+    private write;
+    info(message: string, subsystem?: string): void;
+    warn(message: string, subsystem?: string): void;
+    error(message: string, subsystem?: string): void;
+    debug(message: string, subsystem?: string): void;
+    private pruneOldLogs;
+    close(): void;
+}
+declare const logger: Logger;
+
+export { AVAILABLE_PROVIDERS, type AgentRunParams, type AgentRunResult, AgentRunner, type AgentRunnerConfig, type AgentRunnerDeps, type AgentStreamEvent, AnthropicProvider, type Artifact, ArtifactStore, type Attachment, type ChannelType, type ContentPart, type CortaskConfig, type CredentialDefinition, type CredentialSchema, type CredentialStore, type CronDelivery, type CronEvent, type CronJob, type CronJobCreate, type CronJobState, type CronSchedule, CronService, type EmbedParams, type EmbedResult, type EnabledModel, EncryptedCredentialStore, type GenerateTextParams, type GenerateTextResult, GoogleProvider, GrokProvider, type LLMProvider, type LogLevel, MODEL_DEFINITIONS, type Message, MiniMaxProvider, type ModelInfo, ModelStore, MoonshotProvider, OllamaProvider, type OnboardingData, type OnboardingStatus, OpenAICompatibleProvider, OpenAIProvider, OpenRouterProvider, type PermissionRequest, type PromptTemplate, type ProviderId, type ProviderInfo, type ProviderValidationResult, type QuestionnaireQuestion, type QuestionnaireRequest, type QuestionnaireResponse, SUBAGENT_DEFAULTS, type Session, SessionStore, type SessionWithMessages, type SkillCodeTool, type SkillEntry, type SkillManifest, type SkillSource, type SkillToolTemplate, type StreamChunk, type SubagentRunRecord, TemplateStore, type ToolCall, type ToolDefinition, type ToolExecutionContext, type ToolHandler, type ToolResult, type UsageRecord, UsageStore, type UsageSummary, type Workspace, WorkspaceManager, buildSkillOAuth2AuthUrl, buildSkillTools, buildSystemPrompt, builtinTools, cancelChildrenOfSession, cancelSubagentRun, cleanupSubagentRecords, clearSkillCache, completeSubagentRun, computeNextRunAtMs, cortaskConfigSchema, countActiveChildren, createArtifactTool, createBrowserTool, createCronTool, createProvider, createSubagentTool, createSwitchWorkspaceTool, credentialKey, estimateCost, exchangeSkillOAuth2Code, getCredentialStorageKey, getDataDir, getDepthForSession, getEligibleSkills, getModelDefinitions, getOAuth2StorageKeys, getOrCreateSecret, getProviderInfo, getSubagentRun, installSkillFromGit, loadConfig, loadSkills, logger, migrateAllWorkspaces, migrateSessionDatabase, registerSubagentRun, removeSkill, revokeSkillOAuth2, saveConfig, setSubagentRunner, validateCronExpr, validateProvider };