@frumu/tandem-client 0.3.22

package/dist/index.d.ts

@@ -0,0 +1,1185 @@
+import { z } from 'zod';
+
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type RunStatus = "queued" | "running" | "succeeded" | "failed" | "canceled" | "unknown";
+type RoutineStatus = "enabled" | "disabled" | "paused" | "unknown";
+type ApprovalStatus = "pending" | "approved" | "rejected" | "unknown";
+type ChannelName = "telegram" | "discord" | "slack";
+interface TandemClientOptions {
+    baseUrl: string;
+    token: string;
+    timeoutMs?: number;
+}
+interface SystemHealth {
+    ready?: boolean;
+    phase?: string;
+    [key: string]: unknown;
+}
+interface CreateSessionOptions {
+    title?: string;
+    directory?: string;
+    permissions?: PermissionRule[];
+    provider?: string;
+    model?: string;
+}
+interface UpdateSessionOptions {
+    title?: string;
+    archived?: boolean;
+}
+interface SessionRecord {
+    id: string;
+    title: string;
+    createdAtMs: number;
+    directory?: string;
+    workspaceRoot?: string;
+    archived?: boolean;
+    [key: string]: unknown;
+}
+interface SessionListResponse {
+    sessions: SessionRecord[];
+    count: number;
+}
+interface ListSessionsOptions {
+    q?: string;
+    page?: number;
+    pageSize?: number;
+    archived?: boolean;
+    scope?: "workspace" | "global";
+    workspace?: string;
+}
+interface SessionRunStateResponse {
+    active?: {
+        runId?: string;
+        attachEventStream?: string;
+        [key: string]: unknown;
+    } | null;
+}
+interface PromptAsyncResult {
+    runId: string;
+}
+interface SessionDiff {
+    diff?: string;
+    files?: string[];
+    [key: string]: unknown;
+}
+interface SessionTodo {
+    id?: string;
+    content: string;
+    status?: string;
+    [key: string]: unknown;
+}
+interface MessagePart {
+    type?: string;
+    text?: string;
+}
+interface EngineMessage {
+    info?: {
+        role?: string;
+    };
+    parts?: MessagePart[];
+}
+interface PermissionRule {
+    permission: string;
+    pattern: string;
+    action: "allow" | "deny" | "ask";
+}
+interface PermissionRequestRecord {
+    id: string;
+    permission?: string;
+    pattern?: string;
+    tool?: string;
+    status?: ApprovalStatus | string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+interface PermissionRuleRecord {
+    id: string;
+    permission: string;
+    pattern: string;
+    action: string;
+    [key: string]: unknown;
+}
+interface PermissionSnapshotResponse {
+    requests?: PermissionRequestRecord[];
+    rules?: PermissionRuleRecord[];
+}
+type PermissionReply = "allow" | "always" | "deny" | "reject" | "once";
+interface QuestionRecord {
+    id: string;
+    text?: string;
+    choices?: string[];
+    status?: ApprovalStatus | string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+interface QuestionsListResponse {
+    questions: QuestionRecord[];
+    [key: string]: unknown;
+}
+interface ProviderModelEntry {
+    name?: string;
+}
+interface ProviderEntry {
+    id: string;
+    name?: string;
+    models?: Record<string, ProviderModelEntry>;
+}
+interface ProviderCatalog {
+    all: ProviderEntry[];
+    connected?: string[];
+    default?: string | null;
+}
+interface ProviderConfigEntry {
+    defaultModel?: string;
+}
+interface ProvidersConfigResponse {
+    default?: string | null;
+    providers: Record<string, ProviderConfigEntry>;
+}
+interface ChannelConfigEntry {
+    hasToken?: boolean;
+    allowedUsers?: string[];
+    mentionOnly?: boolean;
+    guildId?: string;
+    channelId?: string;
+}
+interface ChannelsConfigResponse {
+    telegram: ChannelConfigEntry;
+    discord: ChannelConfigEntry;
+    slack: ChannelConfigEntry;
+}
+interface ChannelStatusEntry {
+    enabled: boolean;
+    connected: boolean;
+    lastError?: string | null;
+    activeSessions: number;
+    meta?: JsonObject;
+}
+interface ChannelsStatusResponse {
+    telegram: ChannelStatusEntry;
+    discord: ChannelStatusEntry;
+    slack: ChannelStatusEntry;
+}
+interface AddMcpServerOptions {
+    name: string;
+    transport: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+interface MemoryItem {
+    id?: string;
+    text: string;
+    tags?: string[];
+    source?: string;
+    sessionId?: string;
+    runId?: string;
+    [key: string]: unknown;
+}
+interface MemoryPutOptions {
+    text: string;
+    tags?: string[];
+    source?: string;
+    sessionId?: string;
+    runId?: string;
+    capability?: string;
+}
+interface MemoryPutResponse {
+    id: string;
+    ok: boolean;
+    [key: string]: unknown;
+}
+interface MemorySearchOptions {
+    query: string;
+    limit?: number;
+    tags?: string[];
+    sessionId?: string;
+    capability?: string;
+}
+interface MemorySearchResult {
+    id: string;
+    text: string;
+    score?: number;
+    tags?: string[];
+    [key: string]: unknown;
+}
+interface MemorySearchResponse {
+    results: MemorySearchResult[];
+    count: number;
+}
+interface MemoryListResponse {
+    items: MemoryItem[];
+    count: number;
+}
+interface MemoryPromoteOptions {
+    id: string;
+    capability?: string;
+}
+interface MemoryPromoteResponse {
+    ok: boolean;
+    id: string;
+    [key: string]: unknown;
+}
+interface MemoryAuditEntry {
+    id?: string;
+    tsMs?: number;
+    action?: string;
+    runId?: string;
+    [key: string]: unknown;
+}
+interface MemoryAuditResponse {
+    entries: MemoryAuditEntry[];
+    count: number;
+}
+type SkillLocation = "user" | "workspace" | "builtin";
+interface SkillRecord {
+    name: string;
+    location?: SkillLocation;
+    description?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+interface SkillsListResponse {
+    skills: SkillRecord[];
+    count: number;
+}
+interface SkillImportOptions {
+    content?: string;
+    fileOrPath?: string;
+    location: SkillLocation;
+    namespace?: string;
+    conflictPolicy?: "skip" | "overwrite" | "error";
+}
+interface SkillImportResponse {
+    ok: boolean;
+    imported?: number;
+    [key: string]: unknown;
+}
+interface SkillTemplate {
+    name: string;
+    description?: string;
+    [key: string]: unknown;
+}
+interface SkillTemplatesResponse {
+    templates: SkillTemplate[];
+    count: number;
+}
+interface ResourceRecord {
+    key: string;
+    value: unknown;
+    rev?: number;
+    updatedAtMs?: number;
+    updatedBy?: string;
+    [key: string]: unknown;
+}
+interface ResourceListResponse {
+    items: ResourceRecord[];
+    count: number;
+}
+interface ResourceWriteOptions {
+    key: string;
+    value: unknown;
+    ifMatchRev?: number;
+    updatedBy?: string;
+    ttlMs?: number;
+}
+interface ResourceWriteResponse {
+    ok: boolean;
+    rev?: number;
+    [key: string]: unknown;
+}
+type RoutineFamily = "routines" | "automations";
+type RoutineSchedule = {
+    type: "cron";
+    cron: string;
+} | {
+    type: "interval";
+    intervalMs: number;
+} | {
+    type: "manual";
+} | string;
+interface RoutineRecord {
+    id: string;
+    name?: string;
+    schedule?: RoutineSchedule;
+    entrypoint?: string;
+    prompt?: string;
+    status?: RoutineStatus | string;
+    lastRun?: string;
+    lastRunAt?: string;
+    requiresApproval?: boolean;
+    externalIntegrationsAllowed?: boolean;
+    [key: string]: unknown;
+}
+interface DefinitionListResponse {
+    routines?: RoutineRecord[];
+    automations?: RoutineRecord[];
+    count: number;
+}
+interface DefinitionCreateResponse {
+    routine?: RoutineRecord;
+    automation?: RoutineRecord;
+}
+interface CreateRoutineOptions {
+    name: string;
+    schedule?: RoutineSchedule;
+    timezone?: string;
+    misfirePolicy?: "skip" | "run_late" | "run_now";
+    entrypoint?: string;
+    args?: JsonObject;
+    allowedTools?: string[];
+    outputTargets?: string[];
+    requiresApproval?: boolean;
+    externalIntegrationsAllowed?: boolean;
+    nextFireAtMs?: number;
+    [key: string]: unknown;
+}
+interface PatchRoutineOptions {
+    name?: string;
+    status?: RoutineStatus | string;
+    schedule?: RoutineSchedule;
+    timezone?: string;
+    misfirePolicy?: string;
+    entrypoint?: string;
+    args?: JsonObject;
+    allowedTools?: string[];
+    outputTargets?: string[];
+    requiresApproval?: boolean;
+    externalIntegrationsAllowed?: boolean;
+    nextFireAtMs?: number;
+}
+interface AutomationMissionOptions {
+    objective: string;
+    successCriteria?: string[];
+    briefing?: string;
+}
+interface CreateAutomationOptions {
+    name: string;
+    schedule: RoutineSchedule;
+    timezone?: string;
+    misfirePolicy?: string;
+    mission: AutomationMissionOptions;
+    mode?: string;
+    policy?: {
+        tool?: {
+            runAllowlist?: string[];
+            externalIntegrationsAllowed?: boolean;
+        };
+        approval?: {
+            requiresApproval?: boolean;
+        };
+    };
+    outputTargets?: string[];
+    modelPolicy?: JsonObject;
+    nextFireAtMs?: number;
+}
+interface PatchAutomationOptions {
+    name?: string;
+    status?: RoutineStatus | string;
+    schedule?: RoutineSchedule;
+    mission?: Partial<AutomationMissionOptions>;
+    mode?: string;
+    policy?: JsonObject;
+    outputTargets?: string[];
+    modelPolicy?: JsonObject;
+    nextFireAtMs?: number;
+}
+interface RunNowResponse {
+    ok?: boolean;
+    runId?: string;
+    status?: RunStatus | string;
+}
+interface RunsListResponse {
+    runs: RunRecord[];
+    count: number;
+}
+interface RunRecord {
+    id?: string;
+    runId?: string;
+    routineId?: string;
+    automationId?: string;
+    status?: RunStatus | string;
+    startedAtMs?: number;
+    finishedAtMs?: number;
+    [key: string]: unknown;
+}
+interface ArtifactRecord {
+    artifactId?: string;
+    uri: string;
+    kind: string;
+    label?: string;
+    metadata?: JsonObject;
+    createdAtMs?: number;
+}
+interface RunArtifactsResponse {
+    runId?: string;
+    artifacts: ArtifactRecord[];
+    count: number;
+}
+interface RoutineHistoryEntry {
+    event?: string;
+    tsMs?: number;
+    status?: RoutineStatus | string;
+    [key: string]: unknown;
+}
+interface RoutineHistoryResponse {
+    history: RoutineHistoryEntry[];
+    count: number;
+}
+interface AgentTeamSpawnInput {
+    missionId?: string;
+    parentInstanceId?: string;
+    templateId?: string;
+    role: string;
+    source?: string;
+    justification: string;
+    budgetOverride?: JsonObject;
+}
+interface AgentTeamSpawnResponse {
+    ok?: boolean;
+    missionId?: string;
+    instanceId?: string;
+    sessionId?: string;
+    runId?: string | null;
+    status?: string;
+    code?: string;
+    error?: string;
+}
+interface AgentTeamTemplate {
+    id: string;
+    name?: string;
+    role?: string;
+    [key: string]: unknown;
+}
+interface AgentTeamTemplatesResponse {
+    templates: AgentTeamTemplate[];
+    count: number;
+}
+interface AgentTeamInstance {
+    instanceId?: string;
+    missionId?: string;
+    role?: string;
+    status?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+interface AgentTeamInstancesResponse {
+    instances: AgentTeamInstance[];
+    count: number;
+}
+interface AgentTeamMissionsResponse {
+    missions: JsonObject[];
+    count: number;
+}
+interface AgentTeamSpawnApproval {
+    approvalId?: string;
+    status?: ApprovalStatus | string;
+    [key: string]: unknown;
+}
+interface AgentTeamApprovalsResponse {
+    spawnApprovals: AgentTeamSpawnApproval[];
+    toolApprovals: JsonObject[];
+    count: number;
+}
+interface MissionWorkItem {
+    title: string;
+    detail?: string;
+    assignedAgent?: string;
+}
+interface MissionCreateInput {
+    title: string;
+    goal: string;
+    workItems: MissionWorkItem[];
+}
+interface MissionRecord {
+    id?: string;
+    title?: string;
+    goal?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+interface MissionCreateResponse {
+    mission?: MissionRecord;
+}
+interface MissionListResponse {
+    missions: MissionRecord[];
+    count: number;
+}
+interface MissionGetResponse {
+    mission: MissionRecord;
+}
+interface MissionEventResponse {
+    mission?: MissionRecord;
+    commands?: unknown[];
+    [key: string]: unknown;
+}
+interface ToolSchema {
+    name: string;
+    description?: string;
+    inputSchema?: JsonObject;
+    [key: string]: unknown;
+}
+interface ToolExecuteResult {
+    output?: string;
+    metadata?: JsonObject;
+    [key: string]: unknown;
+}
+interface EngineEventBase {
+    type: string;
+    properties: Record<string, unknown>;
+    sessionId?: string;
+    runId?: string;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+interface RunStartedEvent extends EngineEventBase {
+    type: "run.started";
+}
+interface RunProgressEvent extends EngineEventBase {
+    type: "run.progress";
+}
+interface RunCompletedEvent extends EngineEventBase {
+    type: "run.completed";
+}
+interface RunFailedEvent extends EngineEventBase {
+    type: "run.failed";
+}
+interface ToolCalledEvent extends EngineEventBase {
+    type: "tool.called";
+}
+interface ToolResultEvent extends EngineEventBase {
+    type: "tool.result";
+}
+interface ApprovalRequestedEvent extends EngineEventBase {
+    type: "approval.requested";
+}
+interface ApprovalResolvedEvent extends EngineEventBase {
+    type: "approval.resolved";
+}
+interface RoutineTriggeredEvent extends EngineEventBase {
+    type: "routine.triggered";
+}
+interface RoutineCompletedEvent extends EngineEventBase {
+    type: "routine.completed";
+}
+interface SessionResponseEvent extends EngineEventBase {
+    type: "session.response";
+}
+interface UnknownEvent extends EngineEventBase {
+    type: string;
+}
+type KnownEventType = "run.started" | "run.progress" | "run.completed" | "run.failed" | "tool.called" | "tool.result" | "approval.requested" | "approval.resolved" | "routine.triggered" | "routine.completed" | "session.response";
+type EngineEvent = RunStartedEvent | RunProgressEvent | RunCompletedEvent | RunFailedEvent | ToolCalledEvent | ToolResultEvent | ApprovalRequestedEvent | ApprovalResolvedEvent | RoutineTriggeredEvent | RoutineCompletedEvent | SessionResponseEvent | UnknownEvent;
+
+/**
+ * HTTP client for the Tandem autonomous agent engine.
+ *
+ * Provides full coverage of the Tandem engine HTTP + SSE API.
+ *
+ * @example
+ * ```typescript
+ * import { TandemClient } from "@frumu/tandem-client";
+ *
+ * const client = new TandemClient({
+ *   baseUrl: "http://localhost:39731",
+ *   token: "your-token",
+ * });
+ *
+ * const sessionId = await client.sessions.create({ title: "My agent" });
+ * const { runId } = await client.sessions.promptAsync(sessionId, "Summarize README.md");
+ *
+ * for await (const event of client.stream(sessionId, runId)) {
+ *   if (event.type === "session.response") {
+ *     process.stdout.write(String(event.properties.delta ?? ""));
+ *   }
+ *   if (event.type === "run.complete" || event.type === "run.failed") break;
+ * }
+ * ```
+ */
+declare class TandemClient {
+    private baseUrl;
+    private token;
+    private timeoutMs;
+    /** Session management */
+    readonly sessions: Sessions;
+    /** Permission approval flow */
+    readonly permissions: Permissions;
+    /** AI-generated question approval */
+    readonly questions: Questions;
+    /** Provider catalog and configuration */
+    readonly providers: Providers;
+    /** Messaging platform channel integrations */
+    readonly channels: Channels;
+    /** MCP (Model Context Protocol) server management */
+    readonly mcp: Mcp;
+    /** Scheduled routines */
+    readonly routines: Routines;
+    /** Mission-scoped automations */
+    readonly automations: Automations;
+    /** Semantic memory / vector store */
+    readonly memory: Memory;
+    /** Agent skill packs */
+    readonly skills: Skills;
+    /** Key-value resource store */
+    readonly resources: Resources;
+    /** Agent team orchestration */
+    readonly agentTeams: AgentTeams;
+    /** Multi-agent mission management */
+    readonly missions: Missions;
+    constructor(options: TandemClientOptions);
+    /** Check engine health. Returns `{ ready: true }` when the engine is ready. */
+    health(): Promise<SystemHealth>;
+    /** List all tool IDs registered in the engine. */
+    listToolIds(): Promise<string[]>;
+    /** List all tools with their schemas. */
+    listTools(): Promise<ToolSchema[]>;
+    /**
+     * Execute a built-in tool directly (without a session).
+     *
+     * @example
+     * ```typescript
+     * const result = await client.executeTool("workspace_list_files", { path: "." });
+     * console.log(result.output);
+     * ```
+     */
+    executeTool(tool: string, args?: JsonObject): Promise<ToolExecuteResult>;
+    /**
+     * Stream events from an active run as an async generator.
+     *
+     * @example
+     * ```typescript
+     * for await (const event of client.stream(sessionId, runId)) {
+     *   if (event.type === "session.response") {
+     *     process.stdout.write(String(event.properties.delta ?? ""));
+     *   }
+     *   if (event.type === "run.complete" || event.type === "run.failed") break;
+     * }
+     * ```
+     */
+    stream(sessionId: string, runId?: string, options?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<EngineEvent>;
+    /**
+     * Stream the global event feed (all sessions).
+     */
+    globalStream(options?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<EngineEvent>;
+    /**
+     * Pull stored events for a specific run (paginated, not SSE).
+     */
+    runEvents(runId: string, options?: {
+        sinceSeq?: number;
+        tail?: number;
+    }): Promise<EngineEvent[]>;
+    _request<T>(path: string, init?: RequestInit): Promise<T>;
+}
+declare class Sessions {
+    private baseUrl;
+    private token;
+    private timeoutMs;
+    private req;
+    constructor(baseUrl: string, token: string, timeoutMs: number, req: TandemClient["_request"]);
+    /** Create a new session. Returns the session ID. */
+    create(options?: CreateSessionOptions): Promise<string>;
+    /** List sessions with optional filtering. */
+    list(options?: ListSessionsOptions): Promise<SessionListResponse>;
+    /** Get a session by ID. */
+    get(sessionId: string): Promise<SessionRecord>;
+    /** Update session metadata (title, archive status). */
+    update(sessionId: string, options: UpdateSessionOptions): Promise<SessionRecord>;
+    /** Archive a session (shorthand for `update(id, { archived: true })`). */
+    archive(sessionId: string): Promise<SessionRecord>;
+    /** Delete a session permanently. */
+    delete(sessionId: string): Promise<void>;
+    /** Get all messages in a session. */
+    messages(sessionId: string): Promise<EngineMessage[]>;
+    /** Get pending TODOs associated with a session. */
+    todos(sessionId: string): Promise<SessionTodo[]>;
+    /** Get the currently active run for a session (if any). */
+    activeRun(sessionId: string): Promise<SessionRunStateResponse>;
+    /**
+     * Start an async run and return the run ID.
+     * Use `client.stream(sessionId, runId)` to receive events.
+     *
+     * Handles 409 SESSION_RUN_CONFLICT by returning the existing run ID.
+     */
+    promptAsync(sessionId: string, prompt: string): Promise<PromptAsyncResult>;
+    /**
+     * Run a prompt synchronously and return the text reply (blocking).
+     * For long tasks prefer `promptAsync` + `stream()`.
+     */
+    promptSync(sessionId: string, prompt: string): Promise<string>;
+    /**
+     * Abort the active run for a session.
+     */
+    abort(sessionId: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Cancel the session's active run (alias of abort on some engine versions).
+     */
+    cancel(sessionId: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Cancel a specific run within a session.
+     */
+    cancelRun(sessionId: string, runId: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Fork a session into a child session (divergent conversation branch).
+     */
+    fork(sessionId: string): Promise<SessionRecord>;
+    /**
+     * Get the workspace diff produced by the session's last run.
+     */
+    diff(sessionId: string): Promise<SessionDiff>;
+    /**
+     * Revert uncommitted workspace changes made by the session.
+     */
+    revert(sessionId: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Undo a previous revert (restore session changes).
+     */
+    unrevert(sessionId: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Get child sessions forked from this session.
+     */
+    children(sessionId: string): Promise<SessionRecord[]>;
+    /**
+     * Trigger an engine-side summarization of the session's conversation history.
+     */
+    summarize(sessionId: string): Promise<{
+        ok: boolean;
+        summary?: string;
+    }>;
+    /**
+     * Attach a session to a different workspace directory.
+     */
+    attach(sessionId: string, targetWorkspace: string): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Permissions {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List all pending permission requests and existing rules. */
+    list(): Promise<PermissionSnapshotResponse>;
+    /** Reply to a permission request. Use "always" to auto-approve future requests. */
+    reply(requestId: string, reply: PermissionReply): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Questions {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List pending AI-generated questions awaiting user confirmation. */
+    list(): Promise<QuestionsListResponse>;
+    /** Answer a pending question. */
+    reply(questionId: string, answer: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Reject/dismiss a pending question. */
+    reject(questionId: string): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Providers {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List all available providers and their models. */
+    catalog(): Promise<ProviderCatalog>;
+    /** Get the current provider/model configuration. */
+    config(): Promise<ProvidersConfigResponse>;
+    /** Set the default provider and model. */
+    setDefaults(providerId: string, modelId: string): Promise<void>;
+    /** Store an API key for a provider. */
+    setApiKey(providerId: string, apiKey: string): Promise<void>;
+    /** Get authentication status for a provider. */
+    authStatus(): Promise<JsonObject>;
+}
+declare class Channels {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** Get channel configuration (Telegram / Discord / Slack). */
+    config(): Promise<ChannelsConfigResponse>;
+    /** Get live channel connection status. */
+    status(): Promise<ChannelsStatusResponse>;
+    /** Configure a channel (bot token, allowed users, etc.). */
+    put(channel: ChannelName, payload: JsonObject): Promise<{
+        ok: boolean;
+    }>;
+    /** Remove a channel configuration. */
+    delete(channel: ChannelName): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Mcp {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List registered MCP servers. */
+    list(): Promise<Record<string, unknown>>;
+    /** List all discovered MCP tools. */
+    listTools(): Promise<unknown[]>;
+    /** List all discovered MCP resources. */
+    listResources(): Promise<unknown[]>;
+    /**
+     * Register a new MCP server.
+     *
+     * @example
+     * ```typescript
+     * await client.mcp.add({ name: "arcade", transport: "https://mcp.arcade.ai/mcp" });
+     * await client.mcp.connect("arcade");
+     * ```
+     */
+    add(options: AddMcpServerOptions): Promise<{
+        ok: boolean;
+    }>;
+    /** Connect to an MCP server and discover its tools. */
+    connect(name: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Disconnect from an MCP server. */
+    disconnect(name: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Re-discover tools from a connected MCP server. */
+    refresh(name: string): Promise<{
+        ok: boolean;
+        count?: number;
+    }>;
+    /** Enable or disable an MCP server. */
+    setEnabled(name: string, enabled: boolean): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Memory {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /**
+     * Store a memory item.
+     *
+     * @example
+     * ```typescript
+     * await client.memory.put({
+     *   text: "The team uses Rust for backend services.",
+     *   tags: ["team", "architecture"],
+     * });
+     * ```
+     */
+    put(options: MemoryPutOptions): Promise<MemoryPutResponse>;
+    /**
+     * Semantic search over stored memories.
+     *
+     * @example
+     * ```typescript
+     * const { results } = await client.memory.search({
+     *   query: "backend technology choices",
+     *   limit: 5,
+     * });
+     * ```
+     */
+    search(options: MemorySearchOptions): Promise<MemorySearchResponse>;
+    /** List stored memory items with optional text filter. */
+    list(options?: {
+        q?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<MemoryListResponse>;
+    /** Delete a memory item by ID. */
+    delete(memoryId: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Promote a transient memory item to persistent storage. */
+    promote(options: MemoryPromoteOptions): Promise<MemoryPromoteResponse>;
+    /** Retrieve the memory audit log for a run. */
+    audit(options?: {
+        run_id?: string;
+        limit?: number;
+    }): Promise<MemoryAuditResponse>;
+}
+declare class Skills {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List installed agent skills. */
+    list(location?: SkillLocation): Promise<SkillsListResponse>;
+    /** Get details of a specific skill by name. */
+    get(name: string): Promise<SkillRecord>;
+    /** Import a skill from YAML content or a file path. */
+    import(options: SkillImportOptions): Promise<SkillImportResponse>;
+    /** Preview a skill import (dry run). */
+    preview(options: SkillImportOptions): Promise<SkillImportResponse>;
+    /** List available skill templates shipped with the engine. */
+    templates(): Promise<SkillTemplatesResponse>;
+}
+declare class Resources {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List stored resource records. */
+    list(options?: {
+        prefix?: string;
+        limit?: number;
+    }): Promise<ResourceListResponse>;
+    /**
+     * Write a resource key-value entry.
+     *
+     * @example
+     * ```typescript
+     * await client.resources.write({
+     *   key: "agent-config/alert-threshold",
+     *   value: { threshold: 0.95 },
+     * });
+     * ```
+     */
+    write(options: ResourceWriteOptions): Promise<ResourceWriteResponse>;
+    /** Delete a resource entry. */
+    delete(key: string, options?: {
+        if_match_rev?: number;
+    }): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Routines {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List all scheduled routines. */
+    list(): Promise<DefinitionListResponse>;
+    /**
+     * Create a scheduled routine.
+     *
+     * @example
+     * ```typescript
+     * await client.routines.create({
+     *   name: "Daily digest",
+     *   schedule: "0 8 * * *",
+     *   entrypoint: "Summarize activity from the last 24 hours",
+     * });
+     * ```
+     */
+    create(options: CreateRoutineOptions): Promise<DefinitionCreateResponse>;
+    /** Update a routine (partial patch). */
+    update(id: string, patch: PatchRoutineOptions): Promise<RoutineRecord>;
+    /** Delete a routine by ID. */
+    delete(id: string): Promise<void>;
+    /** Trigger a routine immediately (run now). */
+    runNow(id: string): Promise<RunNowResponse>;
+    /** List recent runs across all routines. */
+    listRuns(options?: {
+        routine_id?: string;
+        limit?: number;
+    }): Promise<RunsListResponse>;
+    /** List runs for a specific routine. */
+    getRunsForRoutine(id: string, limit?: number): Promise<RunsListResponse>;
+    /** Get a specific run record. */
+    getRun(runId: string): Promise<RunRecord>;
+    /** List artifacts produced by a run. */
+    listArtifacts(runId: string): Promise<RunArtifactsResponse>;
+    /** Approve a run that requires human approval. */
+    approveRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Deny a run that requires human approval. */
+    denyRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Pause an active run. */
+    pauseRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Resume a paused run. */
+    resumeRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Get execution history for a routine. */
+    history(id: string, limit?: number): Promise<RoutineHistoryResponse>;
+}
+declare class Automations {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List all automations. */
+    list(): Promise<DefinitionListResponse>;
+    /**
+     * Create a mission-scoped automation.
+     *
+     * @example
+     * ```typescript
+     * await client.automations.create({
+     *   name: "Weekly security scan",
+     *   schedule: "0 9 * * 1",  // every Monday 9am
+     *   mission: {
+     *     objective: "Run a security audit of the API surface",
+     *     success_criteria: ["No critical vulnerabilities", "Report written to reports/security.md"],
+     *   },
+     *   policy: {
+     *     tool: { external_integrations_allowed: false },
+     *     approval: { requires_approval: true },
+     *   },
+     * });
+     * ```
+     */
+    create(options: CreateAutomationOptions): Promise<DefinitionCreateResponse>;
+    /** Update an automation (partial patch). */
+    update(id: string, patch: PatchAutomationOptions): Promise<JsonObject>;
+    /** Delete an automation. */
+    delete(id: string): Promise<void>;
+    /** Trigger an automation immediately. */
+    runNow(id: string): Promise<RunNowResponse>;
+    /** List recent runs across all automations. */
+    listRuns(options?: {
+        automation_id?: string;
+        limit?: number;
+    }): Promise<RunsListResponse>;
+    /** List runs for a specific automation. */
+    getRunsForAutomation(id: string, limit?: number): Promise<RunsListResponse>;
+    /** Get a specific automation run record. */
+    getRun(runId: string): Promise<RunRecord>;
+    /** List artifacts from an automation run. */
+    listArtifacts(runId: string): Promise<RunArtifactsResponse>;
+    /** Approve an automation run pending human review. */
+    approveRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Deny an automation run pending human review. */
+    denyRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Pause an active automation run. */
+    pauseRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Resume a paused automation run. */
+    resumeRun(runId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Get execution history for an automation. */
+    history(id: string, limit?: number): Promise<RoutineHistoryResponse>;
+}
+declare class AgentTeams {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List available agent team templates. */
+    listTemplates(): Promise<AgentTeamTemplatesResponse>;
+    /** List agent team instances. */
+    listInstances(options?: {
+        missionID?: string;
+        parentInstanceID?: string;
+        status?: string;
+    }): Promise<AgentTeamInstancesResponse>;
+    /** List missions managed by the agent team orchestrator. */
+    listMissions(): Promise<AgentTeamMissionsResponse>;
+    /** List pending spawn and tool approvals. */
+    listApprovals(): Promise<AgentTeamApprovalsResponse>;
+    /**
+     * Spawn a new agent team instance.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.agentTeams.spawn({
+     *   missionID: "mission-123",
+     *   role: "builder",
+     *   justification: "Implementing feature X as planned",
+     * });
+     * ```
+     */
+    spawn(input: AgentTeamSpawnInput): Promise<AgentTeamSpawnResponse>;
+    /** Approve a pending agent team spawn request. */
+    approveSpawn(approvalId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Deny a pending agent team spawn request. */
+    denySpawn(approvalId: string, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class Missions {
+    private req;
+    constructor(req: TandemClient["_request"]);
+    /** List all missions. */
+    list(): Promise<MissionListResponse>;
+    /**
+     * Create a new mission with work items.
+     *
+     * @example
+     * ```typescript
+     * const { mission } = await client.missions.create({
+     *   title: "Q1 Security Hardening",
+     *   goal: "Audit and fix security issues in the API surface",
+     *   work_items: [
+     *     { title: "Audit auth middleware", assigned_agent: "security-auditor" },
+     *     { title: "Review input validation", assigned_agent: "security-auditor" },
+     *   ],
+     * });
+     * ```
+     */
+    create(input: MissionCreateInput): Promise<MissionCreateResponse>;
+    /** Get a mission by ID. */
+    get(missionId: string): Promise<MissionGetResponse>;
+    /** Apply a state event to a mission. */
+    applyEvent(missionId: string, event: JsonObject): Promise<MissionEventResponse>;
+}
+
+/**
+ * Filter an async stream to only yield events of a specific type.
+ *
+ * @example
+ * ```typescript
+ * for await (const event of filterByType(client.stream(s, r), "session.response")) {
+ *   console.log(event.properties.delta);
+ * }
+ * ```
+ */
+declare function filterByType<T extends KnownEventType>(stream: AsyncIterable<EngineEvent>, type: T): AsyncGenerator<Extract<EngineEvent, {
+    type: T;
+}>>;
+/**
+ * Consume a stream in the background and trigger a callback for a specific event type.
+ *
+ * @example
+ * ```typescript
+ * on(client.stream(s, r), "run.completed", (event) => console.log(event.runId));
+ * ```
+ */
+declare function on<T extends KnownEventType>(stream: AsyncIterable<EngineEvent>, type: T, callback: (event: Extract<EngineEvent, {
+    type: T;
+}>) => void | Promise<void>): Promise<void>;
+/**
+ * Streams Server-Sent Events from a Tandem engine SSE endpoint.
+ *
+ * Uses Node's built-in fetch + ReadableStream — no browser globals required.
+ *
+ * @example
+ * ```typescript
+ * for await (const event of streamSse(url, token)) {
+ *   if (event.type === "session.response") {
+ *     process.stdout.write(String(event.properties.delta ?? ""));
+ *   }
+ *   if (event.type === "run.complete") break;
+ * }
+ * ```
+ */
+declare function streamSse(url: string, token: string, options?: {
+    /** Signal to abort the stream */
+    signal?: AbortSignal;
+    /** Max time to wait for the first byte (ms, default 30000) */
+    connectTimeoutMs?: number;
+}): AsyncGenerator<EngineEvent>;
+
+declare class TandemValidationError extends Error {
+    readonly endpoint: string;
+    readonly status: number;
+    readonly issues: z.ZodIssue[];
+    readonly rawSnippet: string;
+    constructor(endpoint: string, status: number, issues: z.ZodIssue[], rawSnippet: string);
+}
+
+export { type AddMcpServerOptions, type AgentTeamApprovalsResponse, type AgentTeamInstance, type AgentTeamInstancesResponse, type AgentTeamMissionsResponse, type AgentTeamSpawnApproval, type AgentTeamSpawnInput, type AgentTeamSpawnResponse, type AgentTeamTemplate, type AgentTeamTemplatesResponse, type ApprovalRequestedEvent, type ApprovalResolvedEvent, type ApprovalStatus, type ArtifactRecord, type AutomationMissionOptions, type ChannelConfigEntry, type ChannelName, type ChannelStatusEntry, type ChannelsConfigResponse, type ChannelsStatusResponse, type CreateAutomationOptions, type CreateRoutineOptions, type CreateSessionOptions, type DefinitionCreateResponse, type DefinitionListResponse, type EngineEvent, type EngineEventBase, type EngineMessage, type JsonObject, type JsonValue, type KnownEventType, type ListSessionsOptions, type MemoryAuditEntry, type MemoryAuditResponse, type MemoryItem, type MemoryListResponse, type MemoryPromoteOptions, type MemoryPromoteResponse, type MemoryPutOptions, type MemoryPutResponse, type MemorySearchOptions, type MemorySearchResponse, type MemorySearchResult, type MessagePart, type MissionCreateInput, type MissionCreateResponse, type MissionEventResponse, type MissionGetResponse, type MissionListResponse, type MissionRecord, type MissionWorkItem, type PatchAutomationOptions, type PatchRoutineOptions, type PermissionReply, type PermissionRequestRecord, type PermissionRule, type PermissionRuleRecord, type PermissionSnapshotResponse, type PromptAsyncResult, type ProviderCatalog, type ProviderConfigEntry, type ProviderEntry, type ProviderModelEntry, type ProvidersConfigResponse, type QuestionRecord, type QuestionsListResponse, type ResourceListResponse, type ResourceRecord, type ResourceWriteOptions, type ResourceWriteResponse, type RoutineCompletedEvent, type RoutineFamily, type RoutineHistoryEntry, type RoutineHistoryResponse, type RoutineRecord, type RoutineSchedule, type RoutineStatus, type RoutineTriggeredEvent, type RunArtifactsResponse, type RunCompletedEvent, type RunFailedEvent, type RunNowResponse, type RunProgressEvent, type RunRecord, type RunStartedEvent, type RunStatus, type RunsListResponse, type SessionDiff, type SessionListResponse, type SessionRecord, type SessionResponseEvent, type SessionRunStateResponse, type SessionTodo, type SkillImportOptions, type SkillImportResponse, type SkillLocation, type SkillRecord, type SkillTemplate, type SkillTemplatesResponse, type SkillsListResponse, type SystemHealth, TandemClient, type TandemClientOptions, TandemValidationError, type ToolCalledEvent, type ToolExecuteResult, type ToolResultEvent, type ToolSchema, type UnknownEvent, type UpdateSessionOptions, filterByType, on, streamSse };