@mu-agent/mu 0.0.1

package/dist/types/profile-coding/index.d.ts

@@ -0,0 +1,35 @@
+import { ProcessManager, type Profile } from "../core/index.js";
+import { InstructionLoader, type InstructionSettings } from "./context.js";
+import { FileState } from "./state.js";
+import { bashTool } from "./tools/bash.js";
+import { TodoStore } from "./tools/todo.js";
+export interface CodingProfileOptions {
+    root?: string;
+    spawn?: Parameters<typeof bashTool>[0]["spawn"];
+    spawner?: ConstructorParameters<typeof ProcessManager>[0];
+    processEvents?: ConstructorParameters<typeof ProcessManager>[1];
+    home?: string;
+    instructions?: InstructionSettings;
+    managedInstructionPaths?: string[];
+}
+export interface CodingProfile extends Profile {
+    fileState: FileState;
+    todos: TodoStore;
+    processes: ProcessManager;
+    instructions: InstructionLoader;
+}
+export declare function codingProfile(options?: CodingProfileOptions): Promise<CodingProfile>;
+export type { GitRunner, ShadowCheckpointOptions } from "./checkpoint.js";
+export { gitConfigNullDevice, ShadowCheckpointProvider } from "./checkpoint.js";
+export { codingEnvironment, contextMessages, DEFAULT_INSTRUCTION_FALLBACKS, DEFAULT_INSTRUCTION_MAX_BYTES, DEFAULT_PROJECT_ROOT_MARKERS, discoverContextFiles, environmentMessage, type InstructionDiagnostic, InstructionLoader, type InstructionLoaderOptions, type InstructionSettings, type InstructionSnapshot, type InstructionSource, } from "./context.js";
+export { CODING_PERMISSION_DEFAULTS, CODING_PERMISSION_MODES, layerPermissions, loadProjectConfig, rememberAllow, } from "./permissions.js";
+export { codingPrompt } from "./prompts.js";
+export { shellCommand, terminateProcessTree, windowsTaskkillCommand } from "./shell.js";
+export { FileState } from "./state.js";
+export { bashTool } from "./tools/bash.js";
+export { editTool, lsTool, readTool, resolveInRoot, writeTool } from "./tools/files.js";
+export { globTool, globToRegExp, grepTool, type RipgrepRunner, resolveNpmRipgrepExecutable, resolveRipgrepExecutable, type SearchToolOptions, } from "./tools/search.js";
+export { shellSpawner, taskTools } from "./tools/tasks.js";
+export type { TodoItem } from "./tools/todo.js";
+export { renderTodos, TodoStore, todoTool } from "./tools/todo.js";
+export { MAX_OUTPUT_CHARS, truncateOutput, withNotice } from "./truncate.js";

package/dist/types/profile-coding/permissions.d.ts

@@ -0,0 +1,13 @@
+import type { PermissionMode, PermissionRule } from "../core/index.js";
+import type { InstructionSettings } from "./context.js";
+export declare const CODING_PERMISSION_DEFAULTS: PermissionRule[];
+export declare const CODING_PERMISSION_MODES: PermissionMode[];
+export interface ProjectConfig {
+    permissions?: PermissionRule[];
+    model?: string;
+    instructions?: InstructionSettings;
+}
+export declare function configPath(root: string): string;
+export declare function loadProjectConfig(root: string): Promise<ProjectConfig>;
+export declare function layerPermissions(...layers: (PermissionRule[] | undefined)[]): PermissionRule[];
+export declare function rememberAllow(root: string, permission: string, pattern: string): Promise<void>;

package/dist/types/profile-coding/prompts.d.ts

@@ -0,0 +1,2 @@
+import type { PromptSection } from "../ai/index.js";
+export declare function codingPrompt(modelRef: string): PromptSection[];

package/dist/types/profile-coding/shell.d.ts

@@ -0,0 +1,12 @@
+export interface ShellCommandOptions {
+    platform?: NodeJS.Platform;
+    interactive?: boolean;
+}
+export interface ProcessTreeTarget {
+    pid: number;
+    exitCode: number | null;
+    kill(signal?: NodeJS.Signals | number): void;
+}
+export declare function shellCommand(command: string, options?: ShellCommandOptions): string[];
+export declare function windowsTaskkillCommand(pid: number): string[];
+export declare function terminateProcessTree(process: ProcessTreeTarget, signal: NodeJS.Signals, platform?: NodeJS.Platform): void;

package/dist/types/profile-coding/state.d.ts

@@ -0,0 +1,10 @@
+export declare class FileState {
+    private reads;
+    private modified;
+    markRead(path: string): void;
+    markWritten(path: string): void;
+    hasRead(path: string): boolean;
+    isStale(path: string): boolean;
+    readFiles(): string[];
+    modifiedFiles(): string[];
+}

package/dist/types/profile-coding/tools/bash.d.ts

@@ -0,0 +1,21 @@
+import { type ProcessManager } from "../../core/index.js";
+type OutputStream = "stdout" | "stderr";
+type OutputChunk = (text: string, stream: OutputStream) => void;
+interface SpawnResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    timedOut: boolean;
+}
+export interface BashDeps {
+    root: string;
+    processes?: ProcessManager;
+    spawn?: (command: string, cwd: string, signal: AbortSignal, timeoutMs: number, onOutput?: OutputChunk) => Promise<SpawnResult>;
+}
+export declare function bashTool(deps: BashDeps): import("../../sdk/index.js").Tool<{
+    command: string;
+    description?: string | undefined;
+    timeoutMs?: number | undefined;
+    run_in_background?: boolean | undefined;
+}>;
+export {};

package/dist/types/profile-coding/tools/files.d.ts

@@ -0,0 +1,32 @@
+import { type CheckpointDiffFile } from "../../core/index.js";
+import type { FileState } from "../state.js";
+export interface ToolDeps {
+    root: string;
+    state: FileState;
+    instructions?: {
+        instructionsForPath: (path: string) => Promise<{
+            text: string;
+            sources: string[];
+        }>;
+    };
+}
+export declare function resolveInRoot(root: string, path: string): string;
+export declare function filePermissionDiff(path: string, before: string | undefined, after: string): CheckpointDiffFile;
+export declare function readTool(deps: ToolDeps): import("../../sdk/index.js").Tool<{
+    path: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}>;
+export declare function writeTool(deps: ToolDeps): import("../../sdk/index.js").Tool<{
+    path: string;
+    content: string;
+}>;
+export declare function editTool(deps: ToolDeps): import("../../sdk/index.js").Tool<{
+    path: string;
+    oldString: string;
+    newString: string;
+    replaceAll?: boolean | undefined;
+}>;
+export declare function lsTool(deps: ToolDeps): import("../../sdk/index.js").Tool<{
+    path?: string | undefined;
+}>;

package/dist/types/profile-coding/tools/search.d.ts

@@ -0,0 +1,23 @@
+import { type ToolDeps } from "./files.js";
+export interface RipgrepRunResult {
+    exitCode: number;
+    stderr: string;
+    stopped: boolean;
+}
+export type RipgrepRunner = (args: string[], cwd: string, signal: AbortSignal, onLine: (line: string) => boolean) => Promise<RipgrepRunResult | undefined>;
+export interface SearchToolOptions {
+    ripgrep?: RipgrepRunner | false;
+}
+export declare function resolveNpmRipgrepExecutable(platform?: NodeJS.Platform, architecture?: NodeJS.Architecture, from?: string, resolvePackage?: (specifier: string, from: string) => string): string | undefined;
+export declare function resolveRipgrepExecutable(execPath?: string, platform?: NodeJS.Platform, which?: (command: string) => string | null, resolveNpm?: () => string | undefined): string | undefined;
+export declare function globToRegExp(pattern: string): RegExp;
+export declare function globTool(deps: ToolDeps, options?: SearchToolOptions): import("../../sdk/index.js").Tool<{
+    pattern: string;
+    path?: string | undefined;
+}>;
+export declare function grepTool(deps: ToolDeps, options?: SearchToolOptions): import("../../sdk/index.js").Tool<{
+    pattern: string;
+    path?: string | undefined;
+    include?: string | undefined;
+    ignoreCase?: boolean | undefined;
+}>;

package/dist/types/profile-coding/tools/tasks.d.ts

@@ -0,0 +1,9 @@
+import { type ProcessManager, type Spawner } from "../../core/index.js";
+export declare function shellSpawner(root: string): Spawner;
+export declare function taskTools(manager: ProcessManager): (import("../../sdk/index.js").Tool<{
+    taskId: string;
+    full?: boolean | undefined;
+}> | import("../../sdk/index.js").Tool<{
+    taskId: string;
+    data: string;
+}> | import("../../sdk/index.js").Tool<Record<string, never>>)[];

package/dist/types/profile-coding/tools/todo.d.ts

@@ -0,0 +1,16 @@
+export interface TodoItem {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+}
+export declare class TodoStore {
+    private items;
+    replace(items: TodoItem[]): void;
+    all(): TodoItem[];
+}
+export declare function renderTodos(items: TodoItem[]): string;
+export declare function todoTool(store: TodoStore): import("../../sdk/index.js").Tool<{
+    items: {
+        content: string;
+        status: "completed" | "pending" | "in_progress";
+    }[];
+}>;

package/dist/types/profile-coding/truncate.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_OUTPUT_CHARS = 30000;
+export declare const MAX_OUTPUT_LINES = 1000;
+export interface TruncationResult {
+    text: string;
+    truncated: boolean;
+}
+export declare function truncateOutput(text: string, maxChars?: number, maxLines?: number): TruncationResult;
+export declare function withNotice(result: TruncationResult, what: string): string;

package/dist/types/sdk/agent.d.ts

@@ -0,0 +1,144 @@
+import { type Credential, type ModelInfo, type PromptSection, type Provider, type ThinkingLevel, type Usage } from "../ai/index.js";
+import { type AgentEvent, type AgentMessage, type AnyTool, type CheckpointDiffFile, CheckpointHistory, type CheckpointProvider, type EventSink, type ExtensionHost, type PermissionRequest, type PermissionRule, type ProfileRuntime, type SessionStore, SessionTree, type UserContent } from "../core/index.js";
+import type { z } from "zod";
+import { type Budget } from "./budget.js";
+export type HaltReason = "done" | "aborted" | "error" | "maxTurns" | "maxCostUsd" | "maxTokens";
+export interface AgentOptions {
+    model?: string | ModelInfo;
+    provider?: Provider;
+    systemPrompt?: string | PromptSection[];
+    tools?: AnyTool[];
+    permissions?: PermissionRule[];
+    onPermission?: (request: PermissionRequest) => Promise<"allow" | "deny">;
+    budget?: Budget;
+    session?: SessionStore;
+    sessionId?: string;
+    thinkingLevel?: ThinkingLevel;
+    apiKey?: string;
+    getCredentials?: (provider: string) => Promise<Credential | undefined>;
+    initialMessages?: AgentMessage[];
+    refreshContext?: (messages: AgentMessage[], context: {
+        sessionId: string;
+    }) => Promise<AgentMessage[]> | AgentMessage[];
+    carryoverExtractor?: (messages: AgentMessage[]) => unknown;
+    autoCompact?: boolean;
+    compactThreshold?: number;
+    checkpointProvider?: CheckpointProvider;
+    runtime?: ProfileRuntime;
+    extensions?: ExtensionHost;
+}
+export interface RunResult {
+    text: string;
+    messages: AgentMessage[];
+    usage: Usage;
+    reason: HaltReason;
+    sessionId: string;
+}
+export interface CheckpointActionData {
+    kind: "checkpoint";
+    action: "undo" | "redo";
+    files: CheckpointDiffFile[];
+    messageCount: number;
+    prompt?: string;
+}
+export interface CheckpointActionResult {
+    ok: boolean;
+    message: string;
+    data?: CheckpointActionData;
+}
+export interface AgentRunOptions<T = unknown> {
+    output?: z.ZodType<T>;
+    model?: string | ModelInfo;
+    allowedTools?: string[];
+}
+export declare class Agent {
+    private readonly options;
+    private model;
+    private provider;
+    private readonly store;
+    private tree;
+    private _sessionId;
+    private controller;
+    private steering;
+    private followUps;
+    private totals;
+    private compactRequested;
+    private lastContextPercent;
+    private lastContextUsage;
+    private readonly checkpoints;
+    private recoveryAttempted;
+    private reactiveRecoveryPending;
+    private pendingCheckpoint;
+    private currentThinking;
+    private running;
+    private stopping;
+    private activeEmit;
+    private activeExecution;
+    private autonomousScheduled;
+    private readonly subscribers;
+    private readonly idleWaiters;
+    private shutdownPromise;
+    private sessionStarted;
+    private permissionRules;
+    constructor(options?: AgentOptions);
+    get sessionId(): string;
+    get usage(): Usage;
+    get session(): SessionTree;
+    get sessionStore(): SessionStore;
+    get modelRef(): string;
+    get contextWindow(): number;
+    get thinking(): ThinkingLevel;
+    get isRunning(): boolean;
+    get permissions(): PermissionRule[];
+    setPermissions(rules: PermissionRule[]): void;
+    addPermissionRule(rule: PermissionRule): void;
+    setModel(ref: string | ModelInfo): void;
+    setThinking(level: ThinkingLevel): void;
+    resume(tree: SessionTree): void;
+    newSession(sessionId?: string): void;
+    send(message: string): void;
+    followUp(message: string): void;
+    removeQueuedMessage(kind: "steer" | "follow-up", text: string): boolean;
+    emitTaskEvent(event: AgentEvent): void;
+    subscribe(listener: EventSink): () => void;
+    resize(cols: number, rows: number): void;
+    waitForIdle(): Promise<void>;
+    stop(): void;
+    shutdown(): Promise<void>;
+    abort(): void;
+    requestCompaction(): void;
+    get checkpointHistory(): CheckpointHistory;
+    undo(): Promise<CheckpointActionResult>;
+    redo(): Promise<CheckpointActionResult>;
+    sessionDiff(): Promise<Awaited<ReturnType<CheckpointProvider["diff"]>>>;
+    forkPoints(): {
+        id: string;
+        description: string;
+    }[];
+    fork(entryId: string): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    get contextPercent(): number;
+    run<T>(prompt: string | UserContent[], opts: AgentRunOptions<T> & {
+        output: z.ZodType<T>;
+    }): Promise<RunResult & {
+        output: T;
+    }>;
+    run(prompt: string | UserContent[], opts?: AgentRunOptions): Promise<RunResult>;
+    stream(prompt: string | UserContent[], opts?: AgentRunOptions): AsyncIterable<AgentEvent> & {
+        result(): Promise<RunResult>;
+    };
+    private beginCheckpoint;
+    private finishCheckpoint;
+    private appendCheckpointCursor;
+    private restoreCheckpointResources;
+    private checkpointDetails;
+    private rebuildCheckpointHistory;
+    private execute;
+    private executeRun;
+    private providerFor;
+    private publishToSubscribers;
+    private scheduleAutonomousRun;
+    private resolveIdleIfDone;
+}

package/dist/types/sdk/auth-page.d.ts

@@ -0,0 +1,9 @@
+export interface AuthPageOptions {
+    provider: string;
+    status: "success" | "error";
+    heading: string;
+    detail: string;
+}
+export declare function renderAuthPage(options: AuthPageOptions): string;
+export declare function authSuccessPage(provider: string): string;
+export declare function authErrorPage(provider: string, detail: string): string;

package/dist/types/sdk/auth.d.ts

@@ -0,0 +1,78 @@
+import type { Credential } from "../ai/index.js";
+export interface StoredApiKey {
+    type: "apiKey";
+    apiKey: string;
+}
+export interface StoredOpenAiOAuth {
+    type: "oauth";
+    accessToken: string;
+    refreshToken: string;
+    idToken?: string;
+    expiresAt: number;
+    accountId: string;
+}
+export interface StoredPlanOAuth {
+    type: "oauth";
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    accountId?: string;
+    idToken?: string;
+    baseUrl?: string;
+    availableModelIds?: string[];
+}
+export type StoredCredential = StoredApiKey | StoredPlanOAuth;
+export interface AuthFile {
+    version: 1;
+    activeProvider?: string;
+    providers: Record<string, StoredCredential>;
+}
+export interface AuthStoreOptions {
+    authFile?: string;
+    fetch?: typeof fetch;
+    now?: () => number;
+    openAiIssuer?: string;
+    openAiClientId?: string;
+}
+export interface OpenAiLoginOptions extends AuthStoreOptions {
+    port?: number;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    onAuthUrl?: (url: string) => void | Promise<void>;
+    callbackServer?: (state: string, signal: AbortSignal) => Promise<OpenAiCallbackServer>;
+}
+export interface OpenAiLoginResult {
+    provider: "openai-codex";
+    accountId: string;
+}
+export interface PlanLoginOptions extends AuthStoreOptions {
+    signal?: AbortSignal;
+    onAuthUrl?: (url: string) => void | Promise<void>;
+    onDeviceCode?: (url: string, code: string) => void | Promise<void>;
+    callbackServer?: (provider: string, signal?: AbortSignal) => Promise<PlanLoginCallbackServer>;
+}
+export interface PlanLoginResult {
+    provider: "github-copilot" | "kimi-coding" | "openrouter" | "xai";
+}
+export interface PlanLoginCallbackServer {
+    callbackUrl: string;
+    code: Promise<string>;
+    close: () => void;
+}
+export interface OpenAiCallbackServer {
+    redirectUri: string;
+    callback: Promise<string>;
+    close: () => void;
+}
+export declare function defaultAuthFile(): string;
+export declare function readAuthFile(options?: AuthStoreOptions): Promise<AuthFile>;
+export declare function saveApiKey(provider: string, apiKey: string, options?: AuthStoreOptions): Promise<void>;
+export declare function removeStoredCredential(provider: string, options?: AuthStoreOptions): Promise<boolean>;
+export declare function storedAuthProviders(options?: AuthStoreOptions): Promise<string[]>;
+export declare function preferredAuthProvider(options?: AuthStoreOptions): Promise<string | undefined>;
+export declare function createCredentialResolver(options?: AuthStoreOptions): (provider: string) => Promise<Credential | undefined>;
+export declare function loginOpenAI(options?: OpenAiLoginOptions): Promise<OpenAiLoginResult>;
+export declare function loginKimiCoding(options?: PlanLoginOptions): Promise<PlanLoginResult>;
+export declare function loginXai(options?: PlanLoginOptions): Promise<PlanLoginResult>;
+export declare function loginGitHubCopilot(options?: PlanLoginOptions): Promise<PlanLoginResult>;
+export declare function loginOpenRouter(options?: PlanLoginOptions): Promise<PlanLoginResult>;

package/dist/types/sdk/budget.d.ts

@@ -0,0 +1,9 @@
+import type { Usage } from "../ai/index.js";
+export interface Budget {
+    maxTurns?: number;
+    maxCostUsd?: number;
+    maxTokens?: number;
+}
+export type BudgetBreach = "maxCostUsd" | "maxTokens";
+export declare function totalTokens(usage: Usage): number;
+export declare function checkBudget(budget: Budget | undefined, usage: Usage): BudgetBreach | undefined;

package/dist/types/sdk/commands.d.ts

@@ -0,0 +1,30 @@
+import { type Usage } from "../ai/index.js";
+import { type CheckpointDiffFile, type Command, CommandRegistry } from "../core/index.js";
+import type { CheckpointActionResult } from "./agent.js";
+export interface ForkPoint {
+    id: string;
+    description: string;
+}
+export interface DiffCommandData {
+    kind: "diff";
+    files: CheckpointDiffFile[];
+}
+export interface CoreCommandHooks {
+    requestCompaction?: () => void;
+    usage?: () => Usage & {
+        contextPercent: number;
+    };
+    undo?: () => Promise<CheckpointActionResult>;
+    redo?: () => Promise<CheckpointActionResult>;
+    fork?: (entryId: string) => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    forkPoints?: () => ForkPoint[];
+    diff?: () => Promise<CheckpointDiffFile[]>;
+}
+export declare function formatUsageBreakdown(usage: Usage & {
+    contextPercent: number;
+}): string;
+export declare function coreCommands(hooks?: CoreCommandHooks): Command[];
+export declare function registryWithCoreCommands(hooks?: CoreCommandHooks): CommandRegistry;

package/dist/types/sdk/extension-loader.d.ts

@@ -0,0 +1,15 @@
+import type { ExtensionHost } from "../core/index.js";
+export interface LoadOptions {
+    paths?: string[];
+    userDir?: boolean;
+    projectDir?: string;
+}
+export declare function resolveExtensionFiles(options?: LoadOptions): Promise<string[]>;
+export interface LoadReport {
+    loaded: string[];
+    failed: {
+        file: string;
+        error: string;
+    }[];
+}
+export declare function loadExtensions(host: ExtensionHost, options?: LoadOptions): Promise<LoadReport>;

package/dist/types/sdk/file-store.d.ts

@@ -0,0 +1,13 @@
+import { type SessionStore, SessionTree } from "../core/index.js";
+export interface FileSessionStoreOptions {
+    root?: string;
+    scope?: string;
+}
+export declare class FileSessionStore implements SessionStore {
+    private readonly dir;
+    constructor(options?: FileSessionStoreOptions);
+    private path;
+    load(sessionId: string): Promise<SessionTree | undefined>;
+    save(sessionId: string, tree: SessionTree): Promise<void>;
+    list(): Promise<string[]>;
+}

package/dist/types/sdk/index.d.ts

@@ -0,0 +1,31 @@
+export type { Credential, ModelDiscoveryOptions, ModelInfo, Provider, ProviderModelDiscoveryOptions, ThinkingLevel, Usage, } from "../ai/index.js";
+export { builtinProviderConfigs, defaultModelRef, discoverModels, findModel, listModels, providerHasCredentials, refreshModels, registerModels, registerProvider, } from "../ai/index.js";
+export type { AgentEvent, AgentMessage, AnyTool, Command, CommandContext, CommandResult, CustomMessage, Extension, ExtensionAPI, ExtensionEvent, ExtensionEventFor, ExtensionEventType, LifecycleEvent, LifecycleNotification, PermissionMode, PermissionRequest, PermissionRule, ProfileRuntime, ProfileRuntimeHost, SessionStore, StreamDelta, Tool, ToolRenderer, UserContent, } from "../core/index.js";
+export { CommandRegistry, customMessage, ExtensionHost, errorResult, MemorySessionStore, SessionTree, textResult, userMessage, } from "../core/index.js";
+export type { AgentOptions, AgentRunOptions, CheckpointActionData, CheckpointActionResult, HaltReason, RunResult, } from "./agent.js";
+export { Agent } from "./agent.js";
+export type { AuthFile, AuthStoreOptions, OpenAiCallbackServer, OpenAiLoginOptions, OpenAiLoginResult, PlanLoginCallbackServer, PlanLoginOptions, PlanLoginResult, StoredApiKey, StoredCredential, StoredOpenAiOAuth, StoredPlanOAuth, } from "./auth.js";
+export { createCredentialResolver, defaultAuthFile, loginGitHubCopilot, loginKimiCoding, loginOpenAI, loginOpenRouter, loginXai, preferredAuthProvider, readAuthFile, removeStoredCredential, saveApiKey, storedAuthProviders, } from "./auth.js";
+export type { AuthPageOptions } from "./auth-page.js";
+export { authErrorPage, authSuccessPage, renderAuthPage } from "./auth-page.js";
+export type { Budget, BudgetBreach } from "./budget.js";
+export { checkBudget, totalTokens } from "./budget.js";
+export type { DiffCommandData, ForkPoint } from "./commands.js";
+export { coreCommands, registryWithCoreCommands } from "./commands.js";
+export type { LoadOptions, LoadReport } from "./extension-loader.js";
+export { loadExtensions, resolveExtensionFiles } from "./extension-loader.js";
+export type { FileSessionStoreOptions } from "./file-store.js";
+export { FileSessionStore } from "./file-store.js";
+export type { MarkdownCommand, MarkdownCommandOptions, MarkdownCommandRun, } from "./markdown-commands.js";
+export { loadMarkdownCommands, parseFrontmatter, parseMarkdownCommand, substituteArguments, toCommand, } from "./markdown-commands.js";
+export type { LoadMcpConfigOptions, McpConfigReport, McpStdioServerConfig, } from "./mcp.js";
+export { loadMcpConfig, mcpExtension } from "./mcp.js";
+export type { Profile, ProfileImporter } from "./profile.js";
+export { loadProfile, optionsFromProfile } from "./profile.js";
+export type { HookEvent, HookRunner, HookSpec } from "./shell-hooks.js";
+export { shellHooksExtension } from "./shell-hooks.js";
+export type { Skill } from "./skills.js";
+export { defaultSkillRoots, discoverSkills, loadSkill, skillListing, skillsExtension, } from "./skills.js";
+export { STRUCTURED_OUTPUT_TOOL, structuredOutputPrompt, structuredOutputTool, } from "./structured-output.js";
+export type { ToolDefinition, ToolResult } from "./tool.js";
+export { tool } from "./tool.js";

package/dist/types/sdk/markdown-commands.d.ts

@@ -0,0 +1,29 @@
+import type { Command } from "../core/index.js";
+export interface MarkdownCommand {
+    name: string;
+    description: string;
+    body: string;
+    model?: string;
+    allowedTools?: string[];
+}
+export interface MarkdownCommandRun {
+    kind: "markdown-command";
+    prompt: string;
+    model?: string;
+    allowedTools?: string[];
+}
+export declare function parseFrontmatter(source: string): {
+    meta: Record<string, string | string[]>;
+    body: string;
+};
+export declare function substituteArguments(body: string, args: string): string;
+export declare function parseMarkdownCommand(name: string, source: string): MarkdownCommand;
+export interface MarkdownCommandOptions {
+    userDir?: string;
+    projectDir?: string;
+}
+export declare function loadMarkdownCommands(options?: MarkdownCommandOptions): Promise<MarkdownCommand[]>;
+export declare function toCommand(markdown: MarkdownCommand, submit?: (prompt: string, options: {
+    model?: string;
+    allowedTools?: string[];
+}) => unknown | Promise<unknown>): Command;

package/dist/types/sdk/mcp.d.ts

@@ -0,0 +1,22 @@
+import { type Extension } from "../core/index.js";
+export interface McpStdioServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    startupTimeoutMs?: number;
+    toolTimeoutMs?: number;
+}
+export interface McpConfigReport {
+    servers: Record<string, McpStdioServerConfig>;
+    errors: {
+        file: string;
+        message: string;
+    }[];
+}
+export interface LoadMcpConfigOptions {
+    projectDir?: string;
+    userFile?: string;
+}
+export declare function loadMcpConfig(options?: LoadMcpConfigOptions): Promise<McpConfigReport>;
+export declare function mcpExtension(servers: Record<string, McpStdioServerConfig>): Extension;

package/dist/types/sdk/profile.d.ts

@@ -0,0 +1,6 @@
+import type { Profile } from "../core/index.js";
+import type { AgentOptions } from "./agent.js";
+export type { Profile };
+export declare function optionsFromProfile(profile: Profile, modelRef: string, overrides?: AgentOptions): Promise<AgentOptions>;
+export type ProfileImporter = (specifier: string) => Promise<Record<string, unknown>>;
+export declare function loadProfile(name: string, options?: Record<string, unknown>, importer?: ProfileImporter): Promise<Profile>;

package/dist/types/sdk/shell-hooks.d.ts

@@ -0,0 +1,14 @@
+import type { Extension } from "../core/index.js";
+export type HookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "SessionStart" | "Stop";
+export interface HookSpec {
+    event: HookEvent;
+    command: string;
+    matcher?: string;
+    timeoutMs?: number;
+}
+export type HookRunner = (command: string, input: string, timeoutMs: number) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function shellHooksExtension(hooks: HookSpec[], runner?: HookRunner): Extension;

package/dist/types/sdk/skills.d.ts

@@ -0,0 +1,12 @@
+import type { Extension } from "../core/index.js";
+export interface Skill {
+    name: string;
+    description: string;
+    body: string;
+    directory: string;
+}
+export declare function loadSkill(directory: string): Promise<Skill | undefined>;
+export declare function discoverSkills(roots: string[]): Promise<Skill[]>;
+export declare function defaultSkillRoots(projectDir?: string): string[];
+export declare function skillListing(skills: Skill[]): string;
+export declare function skillsExtension(skills: Skill[]): Extension;

package/dist/types/sdk/structured-output.d.ts

@@ -0,0 +1,5 @@
+import type { AnyTool } from "../core/index.js";
+import { z } from "zod";
+export declare const STRUCTURED_OUTPUT_TOOL = "structured_output";
+export declare function structuredOutputTool<Schema extends z.ZodType>(schema: Schema, capture: (value: z.infer<Schema>) => void): AnyTool;
+export declare function structuredOutputPrompt(): string;

package/dist/types/sdk/testing/mcp-fixture-server.d.ts

@@ -0,0 +1 @@
+export {};