@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/plan-mode/approved-plan.d.ts

@@ -0,0 +1,29 @@
+/** Shape forwarded from the plan-mode resolve handler to InteractiveMode's
+ *  approval popup. Populated by the standing handler that the resolve tool
+ *  dispatches to when the agent submits `resolve { action: "apply" }`. */
+export interface PlanApprovalDetails {
+    planFilePath: string;
+    finalPlanFilePath: string;
+    title: string;
+    planExists: boolean;
+}
+/** Validate the agent-supplied plan title and derive the destination filename.
+ *  Filename uses the title with a `.md` suffix; characters are restricted to
+ *  letters, numbers, underscores, and hyphens so the value is safe to splice
+ *  into a `local://` URL without escaping. */
+export declare function normalizePlanTitle(title: string): {
+    title: string;
+    fileName: string;
+};
+/** Humanize a normalized plan title for use as a session display name.
+ *  Replaces `-`/`_` separators with spaces and capitalizes the first letter.
+ *  Returns an empty string when the input collapses to whitespace. */
+export declare function humanizePlanTitle(title: string): string;
+interface RenameApprovedPlanFileOptions {
+    planFilePath: string;
+    finalPlanFilePath: string;
+    getArtifactsDir: () => string | null;
+    getSessionId: () => string | null;
+}
+export declare function renameApprovedPlanFile(options: RenameApprovedPlanFileOptions): Promise<void>;
+export {};

package/dist/types/plan-mode/state.d.ts

@@ -0,0 +1,6 @@
+export interface PlanModeState {
+    enabled: boolean;
+    planFilePath: string;
+    workflow?: "parallel" | "iterative";
+    reentry?: boolean;
+}

package/dist/types/registry/agent-registry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * AgentRegistry - Process-global registry of live AgentSession instances.
+ *
+ * Tracks every alive agent (the main session plus every subagent) so the
+ * `irc` tool can address peers by id. Sessions are registered explicitly at
+ * creation and removed when the owner releases them.
+ */
+import type { AgentSession } from "../session/agent-session";
+export declare const MAIN_AGENT_ID = "0-Main";
+export type AgentStatus = "running" | "idle" | "completed" | "aborted";
+export type AgentKind = "main" | "sub";
+export interface AgentRef {
+    id: string;
+    displayName: string;
+    kind: AgentKind;
+    parentId?: string;
+    status: AgentStatus;
+    session: AgentSession | null;
+    sessionFile: string | null;
+    createdAt: number;
+    lastActivity: number;
+}
+export type RegistryEvent = {
+    type: "registered";
+    ref: AgentRef;
+} | {
+    type: "status_changed";
+    ref: AgentRef;
+} | {
+    type: "removed";
+    ref: AgentRef;
+};
+type RegistryListener = (event: RegistryEvent) => void;
+export interface RegisterInput {
+    id: string;
+    displayName: string;
+    kind: AgentKind;
+    parentId?: string;
+    session: AgentSession | null;
+    sessionFile?: string | null;
+    status?: AgentStatus;
+}
+export declare class AgentRegistry {
+    #private;
+    static global(): AgentRegistry;
+    /** Reset the global registry. Test-only. */
+    static resetGlobalForTests(): void;
+    register(input: RegisterInput): AgentRef;
+    setStatus(id: string, status: AgentStatus): void;
+    attachSession(id: string, session: AgentSession, sessionFile?: string | null): void;
+    detachSession(id: string): void;
+    unregister(id: string): void;
+    get(id: string): AgentRef | undefined;
+    list(): AgentRef[];
+    /**
+     * Returns every alive agent (running | idle) except the caller.
+     * Flat namespace: every agent can see every other agent.
+     */
+    listVisibleTo(id: string): AgentRef[];
+    onChange(listener: RegistryListener): () => void;
+}
+export {};

package/dist/types/sdk.d.ts

@@ -0,0 +1,253 @@
+import { type AgentTelemetryConfig, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { type Model } from "@oh-my-pi/pi-ai";
+import { type Rule } from "./capability/rule";
+import { ModelRegistry } from "./config/model-registry";
+import { type PromptTemplate } from "./config/prompt-templates";
+import { Settings, type SkillsSettings } from "./config/settings";
+import "./discovery";
+import { type CustomCommandsLoadResult } from "./extensibility/custom-commands";
+import type { CustomTool } from "./extensibility/custom-tools/types";
+import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "./extensibility/extensions";
+import { type Skill, type SkillWarning } from "./extensibility/skills";
+import { type FileSlashCommand } from "./extensibility/slash-commands";
+import type { HindsightSessionState } from "./hindsight/state";
+import { type LocalProtocolOptions } from "./internal-urls";
+import { MCPManager, type MCPToolsLoadResult } from "./mcp";
+import { AgentRegistry } from "./registry/agent-registry";
+import { AgentSession } from "./session/agent-session";
+import { AuthStorage } from "./session/auth-storage";
+import { SessionManager } from "./session/session-manager";
+import { type BuildSystemPromptResult } from "./system-prompt";
+import { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, type LspStartupServerInfo, loadSshTool, ReadTool, ResolveTool, SearchTool, type Tool, type ToolSession, WebSearchTool, WriteTool } from "./tools";
+import { EventBus } from "./utils/event-bus";
+import { type WorkspaceTree } from "./workspace-tree";
+export interface CreateAgentSessionOptions {
+    /** Working directory for project-local discovery. Default: getProjectDir() */
+    cwd?: string;
+    /** Global config directory. Default: ~/.omp/agent */
+    agentDir?: string;
+    /** Spawns to allow. Default: "*" */
+    spawns?: string;
+    /** Auth storage for credentials. Default: discoverAuthStorage(agentDir) */
+    authStorage?: AuthStorage;
+    /** Model registry. Default: discoverModels(authStorage, agentDir) */
+    modelRegistry?: ModelRegistry;
+    /** Model to use. Default: from settings, else first available */
+    model?: Model;
+    /** Raw model pattern string (e.g. from --model CLI flag) to resolve after extensions load.
+     * Used when model lookup is deferred because extension-provided models aren't registered yet. */
+    modelPattern?: string;
+    /** Thinking selector. Default: from settings, else unset */
+    thinkingLevel?: ThinkingLevel;
+    /** Models available for cycling (Ctrl+P in interactive mode) */
+    scopedModels?: Array<{
+        model: Model;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */
+    systemPrompt?: string[] | ((defaultPrompt: string[]) => string[]);
+    /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
+     * Keeps persisted session files isolated while reusing provider-side caches. */
+    providerSessionId?: string;
+    /** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
+    customTools?: (CustomTool | ToolDefinition)[];
+    /** Inline extensions (merged with discovery). */
+    extensions?: ExtensionFactory[];
+    /** Additional extension paths to load (merged with discovery). */
+    additionalExtensionPaths?: string[];
+    /** Disable extension discovery (explicit paths still load). */
+    disableExtensionDiscovery?: boolean;
+    /**
+     * Pre-loaded extensions (skips file discovery).
+     * @internal Used by CLI when extensions are loaded early to parse custom flags.
+     */
+    preloadedExtensions?: LoadExtensionsResult;
+    /** Shared event bus for tool/extension communication. Default: creates new bus. */
+    eventBus?: EventBus;
+    /** Skills. Default: discovered from multiple locations */
+    skills?: Skill[];
+    /** Rules. Default: discovered from multiple locations */
+    rules?: Rule[];
+    /** Context files (AGENTS.md content). Default: discovered walking up from cwd */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+    /** Pre-built workspace tree (skips re-scanning; passed by parents to subagents). */
+    workspaceTree?: WorkspaceTree;
+    /** Prompt templates. Default: discovered from cwd/.omp/prompts/ + agentDir/prompts/ */
+    promptTemplates?: PromptTemplate[];
+    /** File-based slash commands. Default: discovered from commands/ directories */
+    slashCommands?: FileSlashCommand[];
+    /** Enable MCP server discovery from .mcp.json files. Default: true */
+    enableMCP?: boolean;
+    /** Existing MCP manager to reuse (skips discovery, propagates to toolSession). */
+    mcpManager?: MCPManager;
+    /** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
+    enableLsp?: boolean;
+    /** Skip Python kernel availability check and prelude warmup */
+    skipPythonPreflight?: boolean;
+    /** Tool names explicitly requested (enables disabled-by-default tools) */
+    toolNames?: string[];
+    /** Output schema for structured completion (subagents) */
+    outputSchema?: unknown;
+    /** Whether to include the yield tool by default */
+    requireYieldTool?: boolean;
+    /** Task recursion depth (for subagent sessions). Default: 0 */
+    taskDepth?: number;
+    /** Parent Hindsight state to alias for subagent memory tools. */
+    parentHindsightSessionState?: HindsightSessionState;
+    /** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
+    agentId?: string;
+    /** Display name for the agent in IRC. Default: "main" or "sub". */
+    agentDisplayName?: string;
+    /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
+    agentRegistry?: AgentRegistry;
+    /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */
+    parentTaskPrefix?: string;
+    /** Session manager. Default: session stored under the configured agentDir sessions root */
+    sessionManager?: SessionManager;
+    /** Override local:// protocol options for subagent local:// sharing. Default: uses the session's own artifacts dir and session ID. */
+    localProtocolOptions?: LocalProtocolOptions;
+    /** Settings instance. Default: Settings.init({ cwd, agentDir }) */
+    settings?: Settings;
+    /** Whether UI is available (enables interactive tools like ask). Default: false */
+    hasUI?: boolean;
+    /**
+     * Opt-in OpenTelemetry instrumentation forwarded to the underlying Agent.
+     * Passing `{}` enables the loop's GenAI-semantic-convention spans. See
+     * {@link AgentTelemetryConfig} for the full surface (hooks, content capture,
+     * cost estimator, agent identity).
+     *
+     * Safe to enable without an OTEL SDK registered in the host: the
+     * `@opentelemetry/api` package returns a no-op tracer in that case.
+     */
+    telemetry?: AgentTelemetryConfig;
+}
+/** Result from createAgentSession */
+export interface CreateAgentSessionResult {
+    /** The created session */
+    session: AgentSession;
+    /** Extensions result (loaded extensions + runtime) */
+    extensionsResult: LoadExtensionsResult;
+    /** Update tool UI context (interactive mode) */
+    setToolUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
+    /** MCP manager for server lifecycle management (undefined if MCP disabled) */
+    mcpManager?: MCPManager;
+    /** Warning if session was restored with a different model than saved */
+    modelFallbackMessage?: string;
+    /** LSP servers detected for startup; warmup may continue in the background */
+    lspServers?: LspStartupServerInfo[];
+    /** Shared event bus for tool/extension communication */
+    eventBus: EventBus;
+}
+export type { PromptTemplate } from "./config/prompt-templates";
+export { Settings, type SkillsSettings } from "./config/settings";
+export type { CustomCommand, CustomCommandFactory } from "./extensibility/custom-commands/types";
+export type { CustomTool, CustomToolFactory } from "./extensibility/custom-tools/types";
+export type * from "./extensibility/extensions";
+export type { Skill } from "./extensibility/skills";
+export type { FileSlashCommand } from "./extensibility/slash-commands";
+export type { MCPManager, MCPServerConfig, MCPServerConnection, MCPToolsLoadResult } from "./mcp";
+export type { Tool } from "./tools";
+export { buildDirectoryTree, buildWorkspaceTree, type DirectoryTree, type WorkspaceTree } from "./workspace-tree";
+export { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, loadSshTool, ReadTool, ResolveTool, SearchTool, type ToolSession, WebSearchTool, WriteTool, };
+/**
+ * Create an AuthStorage instance.
+ *
+ * Default: local SQLite store at `<agentDir>/agent.db`.
+ *
+ * Broker mode: when `OMP_AUTH_BROKER_URL` is set, credentials are pulled from
+ * a remote auth-broker over the wire. Refresh tokens never leave the broker;
+ * the client receives access tokens with `refresh = "__remote__"` and calls
+ * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
+ * override to re-mint access tokens when needed.
+ */
+export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
+/**
+ * Discover extensions from cwd.
+ */
+export declare function discoverExtensions(cwd?: string): Promise<LoadExtensionsResult>;
+/**
+ * Discover skills from cwd and agentDir.
+ */
+export declare function discoverSkills(cwd?: string, _agentDir?: string, settings?: SkillsSettings): Promise<{
+    skills: Skill[];
+    warnings: SkillWarning[];
+}>;
+/**
+ * Discover context files (AGENTS.md) walking up from cwd.
+ * Returns files sorted by depth (farther from cwd first, so closer files appear last/more prominent).
+ */
+export declare function discoverContextFiles(cwd?: string, _agentDir?: string): Promise<Array<{
+    path: string;
+    content: string;
+    depth?: number;
+}>>;
+/**
+ * Discover prompt templates from cwd and agentDir.
+ */
+export declare function discoverPromptTemplates(cwd?: string, agentDir?: string): Promise<PromptTemplate[]>;
+/**
+ * Discover file-based slash commands from commands/ directories.
+ */
+export declare function discoverSlashCommands(cwd?: string): Promise<FileSlashCommand[]>;
+/**
+ * Discover custom commands (TypeScript slash commands) from cwd and agentDir.
+ */
+export declare function discoverCustomTSCommands(cwd?: string, agentDir?: string): Promise<CustomCommandsLoadResult>;
+/**
+ * Discover MCP servers from .mcp.json files.
+ * Returns the manager and loaded tools.
+ */
+export declare function discoverMCPServers(cwd?: string): Promise<MCPToolsLoadResult>;
+export interface BuildSystemPromptOptions {
+    tools?: Tool[];
+    skills?: Skill[];
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+    cwd?: string;
+    appendPrompt?: string;
+    repeatToolDescriptions?: boolean;
+}
+/**
+ * Build the default provider-facing system prompt blocks.
+ *
+ * The returned `systemPrompt` preserves the stable harness prompt and dynamic project context
+ * as separate entries so providers can cache prompt prefixes without concatenating blocks.
+ */
+export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+/**
+ * Create an AgentSession with the specified options.
+ *
+ * @example
+ * ```typescript
+ * // Minimal - uses defaults
+ * const { session } = await createAgentSession();
+ *
+ * // With explicit model
+ * import { getModel } from '@oh-my-pi/pi-ai';
+ * const { session } = await createAgentSession({
+ *   model: getModel('anthropic', 'claude-opus-4-5'),
+ *   thinkingLevel: 'high',
+ * });
+ *
+ * // Continue previous session
+ * const { session, modelFallbackMessage } = await createAgentSession({
+ *   continueSession: true,
+ * });
+ *
+ * // Full control
+ * const { session } = await createAgentSession({
+ *   model: myModel,
+ *   getApiKey: async () => Bun.env.MY_KEY,
+ *   systemPrompt: ['You are helpful.'],
+ *   tools: codingTools({ cwd: getProjectDir() }),
+ *   skills: [],
+ *   sessionManager: SessionManager.inMemory(),
+ * });
+ * ```
+ */
+export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

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

@@ -0,0 +1,9 @@
+import type { SecretEntry } from "./obfuscator";
+export { deobfuscateSessionContext, obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
+/**
+ * Load secrets from project-local and global secrets.yml files.
+ * Project-local entries override global entries with matching content.
+ */
+export declare function loadSecrets(cwd: string, agentDir: string): Promise<SecretEntry[]>;
+/** Collect environment variable values that look like secrets. */
+export declare function collectEnvSecrets(): SecretEntry[];

package/dist/types/secrets/obfuscator.d.ts

@@ -0,0 +1,23 @@
+import type { Message } from "@oh-my-pi/pi-ai";
+import type { SessionContext } from "../session/session-manager";
+export interface SecretEntry {
+    type: "plain" | "regex";
+    content: string;
+    mode?: "obfuscate" | "replace";
+    replacement?: string;
+    flags?: string;
+}
+export declare class SecretObfuscator {
+    #private;
+    constructor(entries: SecretEntry[]);
+    hasSecrets(): boolean;
+    /** Obfuscate all secrets in text. Bidirectional placeholders for obfuscate mode, one-way for replace. */
+    obfuscate(text: string): string;
+    /** Deobfuscate obfuscate-mode placeholders back to original secrets. Replace-mode is NOT reversed. */
+    deobfuscate(text: string): string;
+    /** Deep-walk an object, deobfuscating all string values. */
+    deobfuscateObject<T>(obj: T): T;
+}
+export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
+/** Obfuscate all text content in LLM messages (for outbound interception). */
+export declare function obfuscateMessages(obfuscator: SecretObfuscator, messages: Message[]): Message[];

package/dist/types/secrets/regex.d.ts

@@ -0,0 +1,2 @@
+/** Compile a secret regex entry with global scanning enabled by default. */
+export declare function compileSecretRegex(pattern: string, flags?: string): RegExp;