swarmlord 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,615 @@
+interface ClientOptions {
+    apiKey: string;
+    baseUrl: string;
+}
+type AgentName = "build" | "plan" | "explore" | "general" | (string & {});
+interface AgentConfig {
+    name?: AgentName;
+    model?: string;
+    instructions?: string[];
+    permission?: PermissionConfig;
+    temperature?: number;
+    config?: Config;
+}
+type PermissionConfig = string | Record<string, string | Record<string, string>>;
+interface Config {
+    model?: string;
+    small_model?: string;
+    default_agent?: string;
+    instructions?: string[];
+    permission?: PermissionConfig;
+    command?: Record<string, {
+        template: string;
+        description?: string;
+        agent?: string;
+        model?: string;
+        subtask?: boolean;
+    }>;
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+        reserved?: number;
+    };
+    [key: string]: unknown;
+}
+interface Tokens {
+    input: number;
+    output: number;
+    reasoning: number;
+    total?: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+type SessionStatus = "idle" | "busy" | "compacting" | "error";
+interface SessionInfo {
+    id: string;
+    title: string;
+    status: SessionStatus;
+    parentId?: string;
+    config?: string;
+    permission?: string;
+    timeCreated: number;
+    timeUpdated: number;
+    timeCompacting?: number;
+}
+interface SessionMetrics {
+    sessionId: string;
+    messages: number;
+    steps: number;
+    toolCalls: number;
+    toolUsage: Record<string, number>;
+    tokens: Tokens;
+    cost: number;
+}
+interface TodoItem {
+    sessionId: string;
+    content: string;
+    status: string;
+    priority: string;
+    position: number;
+}
+interface PartBase {
+    id: string;
+    sessionID: string;
+    messageID: string;
+}
+interface TextPart extends PartBase {
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+    ignored?: boolean;
+    time?: {
+        start: number;
+        end?: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface ReasoningPart extends PartBase {
+    type: "reasoning";
+    text: string;
+    time: {
+        start: number;
+        end?: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface FilePart extends PartBase {
+    type: "file";
+    mime: string;
+    filename?: string;
+    url: string;
+}
+interface AgentPart extends PartBase {
+    type: "agent";
+    name: string;
+}
+interface CompactionPart extends PartBase {
+    type: "compaction";
+    auto: boolean;
+}
+interface SubtaskPart extends PartBase {
+    type: "subtask";
+    prompt: string;
+    description: string;
+    agent: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    command?: string;
+}
+interface RetryPart extends PartBase {
+    type: "retry";
+    attempt: number;
+    error: {
+        name: string;
+        data: Record<string, unknown>;
+    };
+    time: {
+        created: number;
+    };
+}
+interface StepStartPart extends PartBase {
+    type: "step-start";
+}
+interface StepFinishPart extends PartBase {
+    type: "step-finish";
+    reason: string;
+    cost: number;
+    tokens: Tokens;
+}
+interface ToolStatePending {
+    status: "pending";
+    input: Record<string, unknown>;
+    raw: string;
+}
+interface ToolStateRunning {
+    status: "running";
+    input: Record<string, unknown>;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    time: {
+        start: number;
+    };
+}
+interface ToolStateCompleted {
+    status: "completed";
+    input: Record<string, unknown>;
+    output: string;
+    title: string;
+    metadata: Record<string, unknown>;
+    time: {
+        start: number;
+        end: number;
+        compacted?: number;
+    };
+    attachments?: FilePart[];
+}
+interface ToolStateError {
+    status: "error";
+    input: Record<string, unknown>;
+    error: string;
+    metadata?: Record<string, unknown>;
+    time: {
+        start: number;
+        end: number;
+    };
+}
+type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError;
+interface ToolPart extends PartBase {
+    type: "tool";
+    callID: string;
+    tool: string;
+    state: ToolState;
+    metadata?: Record<string, unknown>;
+}
+type Part = TextPart | ReasoningPart | FilePart | AgentPart | CompactionPart | SubtaskPart | RetryPart | StepStartPart | StepFinishPart | ToolPart;
+interface UserMessageInfo {
+    id: string;
+    sessionID: string;
+    role: "user";
+    time: {
+        created: number;
+    };
+    agent: string;
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    variant?: string;
+}
+interface AssistantMessageInfo {
+    id: string;
+    sessionID: string;
+    role: "assistant";
+    time: {
+        created: number;
+        completed?: number;
+    };
+    parentID: string;
+    modelID: string;
+    providerID: string;
+    agent: string;
+    path: {
+        cwd: string;
+        root: string;
+    };
+    cost: number;
+    tokens: Tokens;
+    error?: {
+        name: string;
+        data: Record<string, unknown>;
+    };
+    summary?: boolean;
+    variant?: string;
+    finish?: string;
+}
+type MessageInfo = UserMessageInfo | AssistantMessageInfo;
+interface WithParts {
+    info: MessageInfo;
+    parts: Part[];
+}
+/**
+ * @deprecated Use `Part` instead. Kept for backward compatibility.
+ */
+interface MessagePart {
+    id: string;
+    type: string;
+    [key: string]: unknown;
+}
+type TextInput = {
+    type: "text";
+    text: string;
+};
+type FileInput = {
+    type: "file";
+    url: string;
+    mime: string;
+    filename?: string;
+};
+type MessageInput = {
+    parts: Array<TextInput | FileInput>;
+    agent?: string;
+    model?: string;
+    config?: Config;
+};
+interface SendResult {
+    messageId: string;
+    text: string;
+    parts: Part[];
+    tokens?: Tokens;
+    cost?: number;
+    error?: {
+        name: string;
+        data: Record<string, unknown>;
+    };
+}
+interface StreamCallbacks {
+    /** Fires the instant the SSE stream is established — before the first token or tool call. */
+    onConnect?: () => void;
+    onText?: (delta: string) => void;
+    onReasoning?: (delta: string) => void;
+    onToolStart?: (part: ToolPart) => void;
+    onToolComplete?: (part: ToolPart) => void;
+    onToolError?: (part: ToolPart, error: string) => void;
+    onStepFinish?: (tokens: Tokens, cost: number) => void;
+    onAttachment?: (file: FilePart) => void;
+    onPermission?: (req: PermissionRequest) => Promise<PermissionReply>;
+    onStatus?: (status: SessionStatus) => void;
+    onError?: (err: Error) => void;
+}
+interface PermissionRequest {
+    id: string;
+    sessionID: string;
+    permission: string;
+    patterns: string[];
+    metadata: Record<string, unknown>;
+    always: string[];
+    tool?: {
+        messageID: string;
+        callID: string;
+    };
+}
+type PermissionReply = "once" | "always" | "reject";
+type AgentEvent = {
+    type: "connect";
+} | {
+    type: "text-delta";
+    delta: string;
+} | {
+    type: "reasoning-delta";
+    delta: string;
+} | {
+    type: "tool-start";
+    part: ToolPart;
+} | {
+    type: "tool-complete";
+    part: ToolPart;
+} | {
+    type: "tool-error";
+    part: ToolPart;
+    error: string;
+} | {
+    type: "step-finish";
+    tokens: Tokens;
+    cost: number;
+    reason: string;
+} | {
+    type: "attachment";
+    file: FilePart;
+} | {
+    type: "permission-asked";
+    request: PermissionRequest;
+} | {
+    type: "status-change";
+    status: SessionStatus;
+} | {
+    type: "session-idle";
+    sessionId: string;
+} | {
+    type: "error";
+    error: string;
+} | {
+    type: "message-updated";
+    info: MessageInfo;
+};
+interface ProviderModel {
+    id: string;
+    providerID: string;
+    api: {
+        id: string;
+        url: string;
+        npm: string;
+    };
+    name: string;
+    family?: string;
+    capabilities: {
+        temperature: boolean;
+        reasoning: boolean;
+        attachment: boolean;
+        toolcall: boolean;
+        input: {
+            text: boolean;
+            audio: boolean;
+            image: boolean;
+            video: boolean;
+            pdf: boolean;
+        };
+        output: {
+            text: boolean;
+            audio: boolean;
+            image: boolean;
+            video: boolean;
+            pdf: boolean;
+        };
+    };
+    cost: {
+        input: number;
+        output: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    };
+    limit: {
+        context: number;
+        input?: number;
+        output: number;
+    };
+    status: "alpha" | "beta" | "deprecated" | "active";
+}
+type TaskStatus = "accepted" | "busy" | "compacting" | "idle" | "error";
+interface TaskResult {
+    sessionId: string;
+    status: "completed" | "error";
+    text: string;
+    messages: WithParts[];
+    tokens?: Tokens;
+    cost?: number;
+}
+interface ScheduleInfo {
+    id: string;
+    cron: string;
+    prompt: string;
+    model: string;
+    config: string | null;
+    enabled: number;
+    timeCreated: number;
+}
+interface CreateScheduleOpts {
+    cron: string;
+    prompt: string;
+    model?: string;
+}
+interface UpdateScheduleOpts {
+    cron?: string;
+    prompt?: string;
+    model?: string;
+    enabled?: boolean;
+    config?: Config;
+}
+type TriggerProviderName = "github" | "slack" | "linear" | "generic" | (string & {});
+interface TriggerInfo {
+    id: string;
+    provider: string;
+    events: string | null;
+    agentName: string | null;
+    model: string | null;
+    promptTemplate: string;
+    providerConfig: string | null;
+    agentConfig: string | null;
+    webhookSecret: string;
+    webhookUrl: string;
+    enabled: number;
+    timeCreated: number;
+}
+interface OutputConfig {
+    provider: string;
+    action: string;
+    config: Record<string, string>;
+    template?: string;
+}
+interface CreateTriggerOpts {
+    provider: TriggerProviderName;
+    events?: string[];
+    promptTemplate: string;
+    model?: string;
+    providerConfig?: Record<string, unknown>;
+    outputs?: OutputConfig[];
+}
+interface UpdateTriggerOpts {
+    events?: string[];
+    promptTemplate?: string;
+    model?: string;
+    agent?: string;
+    providerConfig?: Record<string, unknown>;
+    agentConfig?: Record<string, unknown>;
+    outputs?: OutputConfig[];
+    enabled?: boolean;
+}
+interface ShellResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+
+interface SessionHandle {
+    readonly id: string;
+    /** Send a message and stream the response via callbacks. Resolves when the agent goes idle. */
+    send(input: string | MessageInput, callbacks?: StreamCallbacks): Promise<SendResult>;
+    /** Send a message and get back a typed async iterator of events. */
+    stream(input: string | MessageInput): AsyncIterable<AgentEvent>;
+    abort(): Promise<void>;
+    summarize(): Promise<void>;
+    revert(messageId: string): Promise<void>;
+    shell(command: string, opts?: {
+        timeout?: number;
+        cwd?: string;
+    }): Promise<ShellResult>;
+    getInfo(): Promise<SessionInfo>;
+    getMessages(): Promise<WithParts[]>;
+    getMetrics(): Promise<SessionMetrics>;
+    getTodos(): Promise<TodoItem[]>;
+    getFile(path: string): Promise<string>;
+    /** Get a file as raw bytes (for binary files like images). */
+    getFileBuffer(path: string): Promise<ArrayBuffer>;
+    getArtifact(key: string): Promise<string>;
+    /** Get an artifact as raw bytes. */
+    getArtifactBuffer(key: string): Promise<ArrayBuffer>;
+    update(opts: {
+        title?: string;
+        archived?: boolean;
+    }): Promise<void>;
+    delete(): Promise<void>;
+    runCommand(name: string, args?: Record<string, string>): Promise<string>;
+    replyToPermission(requestId: string, reply: "once" | "always" | "reject", message?: string): Promise<void>;
+    events(lastEventId?: number): Promise<ReadableStream<Uint8Array>>;
+}
+
+interface TaskHandle {
+    /** The underlying session ID for this task */
+    readonly id: string;
+    /** Poll the task status once. */
+    poll(): Promise<TaskStatus>;
+    /** Block until the task completes or errors. Returns the final text output. */
+    result(opts?: {
+        timeoutMs?: number;
+    }): Promise<TaskResult>;
+    /** Cancel the running task. */
+    cancel(): Promise<void>;
+}
+
+interface ScheduleHandle {
+    /** The schedule ID */
+    readonly id: string;
+    /** Trigger the schedule immediately, returning a Task handle for the resulting run. */
+    trigger(): Promise<TaskHandle>;
+    /** Pause the schedule (disable cron). */
+    pause(): Promise<void>;
+    /** Resume the schedule (enable cron). */
+    resume(): Promise<void>;
+    /** Update the schedule configuration. */
+    update(opts: UpdateScheduleOpts): Promise<void>;
+    /** Delete the schedule permanently. */
+    delete(): Promise<void>;
+}
+
+interface TriggerHandle {
+    /** The trigger ID */
+    readonly id: string;
+    /** The webhook URL to configure in the external service */
+    readonly webhookUrl: string;
+    /** The HMAC secret for signature validation (store this securely) */
+    readonly webhookSecret: string;
+    /** Pause the trigger (disable). */
+    pause(): Promise<void>;
+    /** Resume the trigger (enable). */
+    resume(): Promise<void>;
+    /** Update the trigger configuration. */
+    update(opts: UpdateTriggerOpts): Promise<void>;
+    /** Delete the trigger permanently. */
+    delete(): Promise<void>;
+    /** Get the latest trigger info from the server. */
+    getInfo(): Promise<TriggerInfo>;
+}
+
+interface AgentHandle {
+    /** The agent configuration */
+    readonly config: AgentConfig;
+    /** Create a new interactive session with this agent. */
+    createSession(opts?: {
+        title?: string;
+        webhook?: string;
+    }): Promise<SessionHandle>;
+    /** Resume an existing session with this agent's config applied. */
+    session(id: string): SessionHandle;
+    /** Fork an existing session into a new one. */
+    forkSession(id: string): Promise<SessionHandle>;
+    /**
+     * Run a one-shot task. Fire-and-forget — returns a TaskHandle immediately.
+     * Use `await task.result()` to block until completion, or set a webhook.
+     */
+    run(prompt: string, opts?: {
+        title?: string;
+        webhook?: string;
+    }): Promise<TaskHandle>;
+    /**
+     * Create a recurring schedule that runs this agent on a cron.
+     * Returns a ScheduleHandle for management and manual triggering.
+     */
+    schedule(opts: CreateScheduleOpts): Promise<ScheduleHandle>;
+    /**
+     * Create an event-driven trigger from an external service (GitHub, Slack, Linear, etc.).
+     * Returns a TriggerHandle with the webhook URL to configure in the external service.
+     */
+    trigger(opts: CreateTriggerOpts): Promise<TriggerHandle>;
+}
+
+interface SwarmlordClient {
+    /**
+     * Create an agent handle. Everything flows from agents.
+     *
+     * @example
+     * const build = client.agent("build")
+     * const reviewer = client.agent({
+     *   name: "build",
+     *   model: "anthropic/claude-sonnet-4-20250514",
+     *   instructions: ["Focus on security"],
+     * })
+     */
+    agent(nameOrConfig: AgentName | AgentConfig): AgentHandle;
+    /** Resume an existing session by ID (without agent config). */
+    session(id: string): SessionHandle;
+    /** Resume a task handle by session ID. */
+    task(sessionId: string): TaskHandle;
+    /** Resume a schedule handle by ID. */
+    schedule(id: string): ScheduleHandle;
+    /** Resume a trigger handle by ID. */
+    trigger(id: string): TriggerHandle;
+    /** List all sessions for the authenticated user. */
+    listSessions(opts?: {
+        limit?: number;
+        archived?: boolean;
+    }): Promise<SessionInfo[]>;
+    /** List all schedules for the authenticated user. */
+    listSchedules(): Promise<ScheduleInfo[]>;
+    /** List all triggers for the authenticated user. */
+    listTriggers(): Promise<TriggerInfo[]>;
+    /** Get user-level config. */
+    getConfig(): Promise<Config>;
+    /** Merge-update user-level config. */
+    updateConfig(config: Partial<Config>): Promise<void>;
+    /** List available provider models (proxied from OpenRouter). */
+    listModels(): Promise<{
+        data: ProviderModel[];
+    }>;
+}
+type CreateClientOptions = Omit<ClientOptions, "baseUrl"> & {
+    baseUrl?: string;
+};
+declare function createClient(opts: CreateClientOptions): SwarmlordClient;
+
+export { createClient };
+export type { AgentConfig, AgentEvent, AgentHandle, AgentName, AgentPart, AssistantMessageInfo, ClientOptions, CompactionPart, Config, CreateClientOptions, CreateScheduleOpts, CreateTriggerOpts, FileInput, FilePart, MessageInfo, MessageInput, MessagePart, OutputConfig, Part, PermissionConfig, PermissionReply, PermissionRequest, ProviderModel, ReasoningPart, RetryPart, ScheduleHandle, ScheduleInfo, SendResult, SessionHandle, SessionInfo, SessionMetrics, SessionStatus, ShellResult, StepFinishPart, StepStartPart, StreamCallbacks, SubtaskPart, SwarmlordClient, TaskHandle, TaskResult, TaskStatus, TextInput, TextPart, TodoItem, Tokens, ToolPart, ToolState, ToolStateCompleted, ToolStateError, ToolStatePending, ToolStateRunning, TriggerHandle, TriggerInfo, TriggerProviderName, UpdateScheduleOpts, UpdateTriggerOpts, UserMessageInfo, WithParts };