@mu-agent/mu 0.2.3 → 0.3.0

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

@@ -1,4 +1,4 @@
-import type { Command } from "../core/index.js";
+import { type Command, type CustomMessage } from "../core/index.js";
 export interface MarkdownCommand {
     name: string;
     description: string;
@@ -11,6 +11,7 @@ export interface MarkdownCommandRun {
     prompt: string;
     model?: string;
     allowedTools?: string[];
+    context?: CustomMessage[];
 }
 export declare function parseFrontmatter(source: string): {
     meta: Record<string, string | string[]>;
@@ -26,4 +27,5 @@ export declare function loadMarkdownCommands(options?: MarkdownCommandOptions):
 export declare function toCommand(markdown: MarkdownCommand, submit?: (prompt: string, options: {
     model?: string;
     allowedTools?: string[];
+    context?: CustomMessage[];
 }) => unknown | Promise<unknown>): Command;

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

@@ -0,0 +1,36 @@
+export interface CatalogTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        [key: string]: unknown;
+    };
+}
+export interface ServerCatalog {
+    serverInfo?: {
+        name?: string;
+        title?: string;
+        version?: string;
+    };
+    instructions?: string;
+    tools: CatalogTool[];
+    resources: boolean;
+    fetchedAt: number;
+}
+type Schema = Record<string, any>;
+export declare const LARGE_SERVER_TOKENS = 1000;
+export declare function estimateTokens(text: string): number;
+export declare function firstSentence(text: string | undefined, max: number): string;
+export declare function signature(tool: CatalogTool): string;
+export declare function isLargeServer(catalog: ServerCatalog): boolean;
+export declare function openText(server: string, catalog: ServerCatalog): string;
+export declare function describeText(server: string, catalog: ServerCatalog, names: string[]): string;
+export declare function validateArgs(value: unknown, schema: Schema | undefined, path?: string): string[];
+export declare function listingLine(server: string, options: {
+    description?: string;
+    catalog?: ServerCatalog;
+    note?: string;
+}): string;
+export {};

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

@@ -0,0 +1,61 @@
+export type McpTransport = {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+} | {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+};
+export type McpSource = "mu" | "claude" | "codex" | "cursor" | "opencode" | "gemini" | "vscode";
+export type McpScope = "user" | "project";
+export type McpExposure = "open" | "direct";
+export interface McpServerSpec {
+    name: string;
+    transport: McpTransport;
+    source: McpSource;
+    scope: McpScope;
+    file: string;
+    enabled: boolean;
+    exposure: McpExposure;
+    description?: string;
+    includeTools?: string[];
+    excludeTools?: string[];
+    startupTimeoutMs?: number;
+    toolTimeoutMs?: number;
+}
+export interface McpConfigReport {
+    servers: McpServerSpec[];
+    shadowed: McpServerSpec[];
+    errors: {
+        file: string;
+        message: string;
+    }[];
+}
+export interface LoadMcpConfigOptions {
+    projectDir?: string;
+    home?: string;
+    userFile?: string;
+    foreign?: boolean;
+}
+type Raw = Record<string, unknown>;
+export declare function parseJsonc(text: string): unknown;
+export declare function transportFingerprint(transport: McpTransport): string;
+export declare function loadMcpConfig(options?: LoadMcpConfigOptions): Promise<McpConfigReport>;
+export declare function expandVariables(value: string, env: Record<string, string | undefined>, extra?: Record<string, string>): {
+    value: string;
+    missing: string[];
+};
+export declare function expandTransport(transport: McpTransport, env: Record<string, string | undefined>, extra?: Record<string, string>): {
+    transport: McpTransport;
+    missing: string[];
+};
+export interface McpApprovals {
+    isApproved(projectDir: string, spec: McpServerSpec): boolean;
+    approve(projectDir: string, spec: McpServerSpec): Promise<void>;
+}
+export declare function loadMcpApprovals(file: string): Promise<McpApprovals>;
+export declare function updateUserServerEntry(file: string, name: string, patch: Raw): Promise<void>;
+export {};

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

@@ -1,22 +1,16 @@
 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 {
+import { type McpApprovals, type McpConfigReport, type McpServerSpec } from "./mcp-config.js";
+export declare const MCP_CONTEXT_TYPE = "mcp_servers";
+export interface McpExtensionOptions {
+    servers: McpServerSpec[];
+    shadowed?: McpServerSpec[];
+    errors?: McpConfigReport["errors"];
     projectDir?: string;
+    approvals?: McpApprovals;
+    cacheDir?: string | false;
     userFile?: string;
+    env?: Record<string, string | undefined>;
+    home?: string;
+    warm?: boolean;
 }
-export declare function loadMcpConfig(options?: LoadMcpConfigOptions): Promise<McpConfigReport>;
-export declare function mcpExtension(servers: Record<string, McpStdioServerConfig>): Extension;
+export declare function mcpExtension(options: McpExtensionOptions): Extension;

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

@@ -1,12 +1,46 @@
-import type { Extension } from "../core/index.js";
+import { type AgentMessage, type CustomMessage, type Extension } from "../core/index.js";
+export type SkillSource = "mu" | "agents" | "claude" | "codex" | "opencode";
+export type SkillScope = "project" | "user";
+export interface SkillRoot {
+    directory: string;
+    scope: SkillScope;
+    source: SkillSource;
+}
 export interface Skill {
     name: string;
     description: string;
     body: string;
     directory: string;
+    scope: SkillScope;
+    source: SkillSource;
+    disableModelInvocation: boolean;
+    userInvocable: boolean;
+    allowedTools?: string[];
+}
+export interface SkillCatalog {
+    skills: Skill[];
+    shadowed: Skill[];
+    warnings: 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 interface SkillRootOptions {
+    home?: string;
+    projectDirs?: string[];
+}
+export declare function skillRoots(options?: SkillRootOptions): SkillRoot[];
+export declare function loadSkill(directory: string, root?: Pick<SkillRoot, "scope" | "source">): Promise<Skill | string>;
+export declare function discoverSkills(roots: SkillRoot[]): Promise<SkillCatalog>;
+export declare const SKILLS_CONTEXT_TYPE = "skills";
 export declare function skillListing(skills: Skill[]): string;
-export declare function skillsExtension(skills: Skill[]): Extension;
+export declare function snapshotMessage(type: string, text: string): CustomMessage;
+export declare function refreshedSnapshot(messages: AgentMessage[], type: string, text: string): AgentMessage[];
+export declare function skillContent(skill: Skill, files: string[]): string;
+export declare function describeSkillCatalog(catalog: SkillCatalog): string;
+export interface SkillsExtensionOptions {
+    roots: SkillRoot[];
+    catalog?: SkillCatalog;
+}
+export declare function skillsExtension(options: SkillsExtensionOptions): Extension;
+export declare function projectDirectories(cwd: string, options?: {
+    home?: string;
+    markers?: string[];
+}): Promise<string[]>;

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

@@ -1,5 +1,12 @@
-import type { AnyTool } from "../core/index.js";
+import { type AnyTool, type CustomMessage } from "../core/index.js";
 import { z } from "zod";
+import type { RunResult } from "./agent.js";
 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;
+export declare const STRUCTURED_OUTPUT_REMINDERS = 2;
+export declare function structuredOutputReminder(): CustomMessage;
+export declare class StructuredOutputError extends Error {
+    readonly result: RunResult;
+    constructor(message: string, result: RunResult);
+}

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

@@ -1,13 +1,14 @@
-import { type ModelInfo, type ThinkingLevel, type Usage } from "../ai/index.js";
-import type { AgentMessage, Extension, PermissionRule, ProfileSubagents } from "../core/index.js";
+import { type ModelInfo, type TextContent, type ThinkingLevel, type Usage } from "../ai/index.js";
+import { type AgentMessage, type Extension, type PermissionRule, type ProfileSubagents } from "../core/index.js";
 import type { Agent, HaltReason } from "./agent.js";
-export type SubagentKind = "task" | "search" | "counsel" | "recall";
+export type SubagentKind = "task" | "counsel" | "recall";
 export interface SubagentDetails {
     type: "subagent";
     kind: SubagentKind;
     description: string;
     model: string;
     thinkingLevel: ThinkingLevel;
+    ownModel?: boolean;
     durationMs: number;
     messages: AgentMessage[];
     usage: Usage;
@@ -19,6 +20,7 @@ export interface SubagentProgressUpdate {
     description: string;
     model: string;
     thinkingLevel: ThinkingLevel;
+    ownModel?: boolean;
     event: {
         type: "assistant_start";
     } | {
@@ -29,12 +31,46 @@ export interface SubagentProgressUpdate {
         message: AgentMessage;
     };
 }
+export interface SubagentRouteOverride {
+    model?: ModelInfo;
+    thinkingLevel?: ThinkingLevel;
+    unavailable?: string;
+}
+export interface SubagentCallChoice {
+    model?: ModelInfo;
+    thinkingLevel?: ThinkingLevel;
+}
+export interface SubagentRoute {
+    kind: SubagentKind;
+    model: string;
+    thinkingLevel?: ThinkingLevel;
+    pinned?: boolean;
+    unavailable?: string;
+}
+export interface SubagentsCommandData {
+    kind: "subagents";
+    routes: SubagentRoute[];
+}
+export interface BackgroundSubagentDetails {
+    type: "subagent-background";
+    subagentId: string;
+    kind: SubagentKind;
+    description: string;
+}
+export interface BackgroundSubagentResultDetails {
+    type: "subagent-background-result";
+    subagentId: string;
+    toolCallId: string;
+    status: "done" | "error" | "stopped";
+    content: TextContent[];
+    result?: SubagentDetails;
+}
 interface SubagentExtensionBaseOptions {
     parent: () => Agent;
     taskSession?: ProfileSubagents["taskSession"];
     excludeTools?: readonly string[];
-    searchModel?: (parent: Agent) => ModelInfo | undefined;
-    counselModel?: (parent: Agent) => ModelInfo | undefined;
+    modelChoices?: (parent: Agent) => ModelInfo[] | Promise<ModelInfo[]>;
+    routeOverride?: (kind: SubagentKind, parent: Agent) => SubagentRouteOverride | undefined | Promise<SubagentRouteOverride | undefined>;
 }
 export type SubagentExtensionOptions = SubagentExtensionBaseOptions & ({
     coding: ProfileSubagents;
@@ -43,5 +79,17 @@ export type SubagentExtensionOptions = SubagentExtensionBaseOptions & ({
     coding?: undefined;
     inspectionPermissions?: PermissionRule[];
 });
+export declare function subagentThinking(kind: SubagentKind, model: ModelInfo, parentThinking: ThinkingLevel): ThinkingLevel;
+export declare function matchModel(query: string, models: readonly ModelInfo[]): {
+    model: ModelInfo;
+} | {
+    matches: ModelInfo[];
+};
+export declare function similarModels(query: string, models: readonly ModelInfo[]): ModelInfo[];
+export interface SubagentRoutesStyle {
+    name?: (kind: SubagentKind, text: string) => string;
+    route?: (text: string) => string;
+}
+export declare function formatSubagentRoutes(routes: readonly SubagentRoute[], style?: SubagentRoutesStyle): string[];
 export declare function subagentsExtension(options: SubagentExtensionOptions): Extension;
 export {};

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

@@ -1,4 +1,4 @@
-import type { AnyTool, Tool, ToolPermissionDetails, ToolResult } from "../core/index.js";
+import type { AnyTool, PermissionTarget, Tool, ToolPermissionDetails, ToolResult } from "../core/index.js";
 import { z } from "zod";
 export type { ToolResult };
 export interface ToolDefinition<Schema extends z.ZodType> {
@@ -9,13 +9,17 @@ export interface ToolDefinition<Schema extends z.ZodType> {
     isConcurrencySafe?: (args: z.infer<Schema>) => boolean;
     executionMode?: "sequential";
     changesState?: boolean | ((args: z.infer<Schema>) => boolean);
+    changedResources?: (args: z.infer<Schema>) => string[];
     permissionScope?: (args: z.infer<Schema>) => string;
     permissionPattern?: (args: z.infer<Schema>) => string;
+    permissionTargets?: (args: z.infer<Schema>) => PermissionTarget[];
     permissionDetails?: (args: z.infer<Schema>) => ToolPermissionDetails | undefined | Promise<ToolPermissionDetails | undefined>;
+    canBackground?: (args: z.infer<Schema>) => boolean;
     execute: (args: z.infer<Schema>, ctx: {
         toolCallId: string;
         signal: AbortSignal;
         update: (text: string, details?: unknown) => void;
+        background: AbortSignal;
     }) => Promise<ToolResult | string> | ToolResult | string;
 }
 export declare function tool<Schema extends z.ZodType>(definition: ToolDefinition<Schema>): Tool<z.infer<Schema>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mu-agent/mu",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Mu, a general-purpose extensible AI agent platform for the terminal and TypeScript",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -1,16 +0,0 @@
-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("../core/index.js").Tool<{
-    items: {
-        content: string;
-        status: "completed" | "pending" | "in_progress";
-    }[];
-}>;