@oh-my-pi/pi-coding-agent 16.0.5 → 16.0.6

package/dist/types/edit/modes/apply-patch.d.ts

@@ -7,12 +7,11 @@
  * LSP writethrough, fs-cache invalidation, diagnostics) is shared with
  * the `patch` mode.
  */
-import { z } from "zod/v4";
 import type { PatchEditEntry } from "./patch";
-export declare const applyPatchSchema: z.ZodObject<{
-    input: z.ZodString;
-}, z.core.$strip>;
-export type ApplyPatchParams = z.infer<typeof applyPatchSchema>;
+export declare const applyPatchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    input: string;
+}, {}>;
+export type ApplyPatchParams = typeof applyPatchSchema.infer;
 export type ApplyPatchEntry = PatchEditEntry & {
     path: string;
 };

package/dist/types/edit/modes/patch.d.ts

@@ -5,7 +5,6 @@
  * for robust handling of whitespace and formatting differences.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import { type WritethroughCallback, type WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
@@ -61,29 +60,21 @@ export declare function computePatchDiff(input: PatchInput, cwd: string, options
 } | {
     error: string;
 }>;
-export declare const patchEditEntrySchema: z.ZodObject<{
-    op: z.ZodOptional<z.ZodEnum<{
-        create: "create";
-        delete: "delete";
-        update: "update";
-    }>>;
-    rename: z.ZodOptional<z.ZodString>;
-    diff: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const patchEditSchema: z.ZodObject<{
-    path: z.ZodString;
-    edits: z.ZodArray<z.ZodObject<{
-        op: z.ZodOptional<z.ZodEnum<{
-            create: "create";
-            delete: "delete";
-            update: "update";
-        }>>;
-        rename: z.ZodOptional<z.ZodString>;
-        diff: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type PatchEditEntry = z.infer<typeof patchEditEntrySchema>;
-export type PatchParams = z.infer<typeof patchEditSchema>;
+export declare const patchEditEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op?: "create" | "delete" | "update" | undefined;
+    rename?: string | undefined;
+    diff?: string | undefined;
+}, {}>;
+export type PatchEditEntry = typeof patchEditEntrySchema.infer;
+export declare const patchEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+    edits: {
+        op?: "create" | "delete" | "update" | undefined;
+        rename?: string | undefined;
+        diff?: string | undefined;
+    }[];
+}, {}>;
+export type PatchParams = typeof patchEditSchema.infer;
 export interface ExecutePatchSingleOptions {
     session: ToolSession;
     path: string;

package/dist/types/edit/modes/replace.d.ts

@@ -5,7 +5,6 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
@@ -113,21 +112,21 @@ export declare function findContextLine(lines: string[], context: string, startF
     allowFuzzy?: boolean;
     skipFunctionFallback?: boolean;
 }): ContextLineResult;
-export declare const replaceEditEntrySchema: z.ZodObject<{
-    old_text: z.ZodString;
-    new_text: z.ZodString;
-    all: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const replaceEditSchema: z.ZodObject<{
-    path: z.ZodString;
-    edits: z.ZodArray<z.ZodObject<{
-        old_text: z.ZodString;
-        new_text: z.ZodString;
-        all: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ReplaceEditEntry = z.infer<typeof replaceEditEntrySchema>;
-export type ReplaceParams = z.infer<typeof replaceEditSchema>;
+export declare const replaceEditEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    old_text: string;
+    new_text: string;
+    all?: boolean | undefined;
+}, {}>;
+export declare const replaceEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+    edits: {
+        old_text: string;
+        new_text: string;
+        all?: boolean | undefined;
+    }[];
+}, {}>;
+export type ReplaceEditEntry = typeof replaceEditEntrySchema.infer;
+export type ReplaceParams = typeof replaceEditSchema.infer;
 export interface ExecuteReplaceSingleOptions {
     session: ToolSession;
     path: string;
@@ -139,4 +138,4 @@ export interface ExecuteReplaceSingleOptions {
     writethrough: WritethroughCallback;
     beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
-export declare function executeReplaceSingle(options: ExecuteReplaceSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof replaceEditEntrySchema>>;
+export declare function executeReplaceSingle(options: ExecuteReplaceSingleOptions): Promise<AgentToolResult<EditToolDetails, ReplaceEditEntry>>;

package/dist/types/eval/js/index.d.ts

@@ -1,5 +1,6 @@
 import type { ToolSession } from "../../tools";
 import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
+export declare function namespaceSessionId(sessionId: string): string;
 declare const _default: {
     id: "js";
     label: string;

package/dist/types/extensibility/custom-commands/types.d.ts

@@ -5,7 +5,8 @@
  * Unlike markdown commands which expand to prompts, custom commands can execute
  * arbitrary logic with full access to the hook context.
  */
-import type { z } from "zod/v4";
+import type * as arktype from "arktype";
+import type * as zod from "zod/v4";
 import type { ExecOptions, ExecResult, HookCommandContext } from "../../extensibility/hooks/types";
 import type * as PiCodingAgent from "../../index";
 import type * as TypeBox from "../typebox";
@@ -21,8 +22,10 @@ export interface CustomCommandAPI {
     exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
     /** Injected zod-backed typebox shim (legacy/compat). */
     typebox: typeof TypeBox;
-    /** Injected zod module for Zod-authored custom commands. */
-    zod: typeof z;
+    /** Injected arktype module for validation in custom commands. */
+    arktype: typeof arktype;
+    /** Injected zod/v4 module for canonical command validation. */
+    zod: typeof zod;
     /** Injected pi-coding-agent exports */
     pi: typeof PiCodingAgent;
 }

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -9,7 +9,8 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { FetchImpl, Model, Static, TSchema } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
+import type { type as ArkType } from "arktype";
+import type * as zod from "zod/v4";
 import type { Rule } from "../../capability/rule";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";
@@ -50,10 +51,12 @@ export interface CustomToolAPI {
     hasUI: boolean;
     /** File logger for error/warning/debug messages */
     logger: typeof PiLogger;
-    /** Injected zod-backed typebox shim (legacy/compat — Zod-authored tools are preferred). */
+    /** Injected typebox shim (legacy/compat — arktype-authored tools are preferred). */
     typebox: typeof TypeBox;
-    /** Injected zod module for Zod-authored custom tools. */
-    zod: typeof z;
+    /** Injected arktype module for arktype-authored custom tools. */
+    arktype: typeof ArkType;
+    /** Injected zod/v4 module for canonical parameter schemas. */
+    zod: typeof zod;
     /** Injected pi-coding-agent exports */
     pi: typeof PiCodingAgent;
     /** Push a preview action that can later be resolved with the hidden resolve tool */
@@ -172,7 +175,7 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
     strict?: boolean;
     /** Description for LLM */
     description: string;
-    /** Parameter schema (Zod or TypeBox; TypeBox is auto-lifted to Zod at registration). */
+    /** Parameter schema (arktype, TypeBox, or legacy formats). */
     parameters: TParams;
     /** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
     hidden?: boolean;

package/dist/types/extensibility/extensions/types.d.ts

@@ -13,7 +13,8 @@ import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context,
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
+import type { Type as arktype } from "arktype";
+import type * as zod from "zod/v4";
 import type { KeybindingsManager } from "../../config/keybindings";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
@@ -601,8 +602,10 @@ export interface ExtensionAPI {
     logger: typeof PiLogger;
     /** Injected zod-backed typebox shim for legacy `Type.Object(...)` parameter authoring. */
     typebox: typeof TypeBox;
-    /** Injected zod module for Zod-authored extension tools (canonical going forward). */
-    zod: typeof z;
+    /** Injected arktype module for arktype-authored extension tools (canonical going forward). */
+    arktype: typeof arktype;
+    /** Injected zod/v4 module for canonical extension tool parameter schemas. */
+    zod: typeof zod;
     /** Injected pi-coding-agent exports for accessing SDK utilities */
     pi: typeof PiCodingAgent;
     on(event: "resources_discover", handler: ExtensionHandler<ResourcesDiscoverEvent, ResourcesDiscoverResult>): void;

package/dist/types/extensibility/hooks/types.d.ts

@@ -1,7 +1,8 @@
 import type { ImageContent, Message, Model, TextContent } from "@oh-my-pi/pi-ai";
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
+import type { Type } from "arktype";
+import type * as zod from "zod/v4";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
@@ -417,10 +418,12 @@ export interface HookAPI {
     exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
     /** File logger for error/warning/debug messages */
     logger: typeof PiLogger;
-    /** Injected zod-backed typebox shim (legacy/compat — prefer `zod`). */
+    /** Injected zod-backed typebox shim (legacy/compat — prefer `arktype`). */
     typebox: typeof TypeBox;
-    /** Injected zod module for Zod-authored hooks. */
-    zod: typeof z;
+    /** Injected arktype module for arktype-authored hooks. */
+    arktype: typeof Type;
+    /** Injected zod/v4 module for canonical hook validation. */
+    zod: typeof zod;
     /** Injected pi-coding-agent exports */
     pi: typeof PiCodingAgent;
 }

package/dist/types/extensibility/legacy-pi-ai-shim.d.ts

@@ -11,13 +11,21 @@
  * bare package root. Subpath imports (`@oh-my-pi/pi-ai/oauth`, etc.)
  * continue to resolve directly against the bundled pi-ai package.
  *
- * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that
- * already serves bare `@sinclair/typebox` imports for the same extension
- * class, keeping the legacy-compat surface internally consistent.
+ * The `Type` runtime and legacy `StringEnum()` helper are borrowed from the
+ * Zod-backed TypeBox shim that already serves TypeBox imports for the same
+ * extension class, keeping the legacy-compat surface internally consistent.
  *
  * Type-level `Static` and `TSchema` continue to come from pi-ai's own
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
- * only the runtime `Type` builder was removed.
+ * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
+import { type TSchema, Type } from "./typebox";
+export interface StringEnumOptions<T extends string> {
+    description?: string;
+    default?: T;
+    examples?: T[];
+    [key: string]: unknown;
+}
+export declare function StringEnum<T extends string>(values: readonly T[], options?: StringEnumOptions<T>): TSchema;
 export * from "@oh-my-pi/pi-ai";
-export { Type } from "./typebox";
+export { Type };

package/dist/types/extensibility/legacy-pi-coding-agent-shim.d.ts

@@ -11,4 +11,21 @@
  * entry, while still re-exporting the canonical surface so plugins observe
  * the same module identity as a direct `@oh-my-pi/pi-coding-agent` import.
  */
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import { Settings } from "../config/settings";
+import type { ToolDefinition } from "./extensions/types";
+import { Type } from "./typebox";
+export interface ParsedFrontmatter<T extends Record<string, unknown> = Record<string, unknown>> {
+    frontmatter: T;
+    body: string;
+}
+export declare function parseFrontmatter<T extends Record<string, unknown> = Record<string, unknown>>(content: string): ParsedFrontmatter<T>;
+export declare function stripFrontmatter(content: string): string;
+export declare function defineTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): ToolDefinition<TParams, TDetails>;
+export declare function createCodingTools(cwd: string): ToolDefinition[];
+export declare const SettingsManager: {
+    readonly create: (cwd: string, agentDir?: string) => Promise<Settings>;
+    readonly inMemory: () => Settings;
+};
 export * from "../index";
+export { Type };

package/dist/types/extensibility/typebox.d.ts

@@ -1,45 +1,67 @@
 /**
- * Minimal `@sinclair/typebox` runtime compatibility shim, backed by Zod.
+ * Minimal `@sinclair/typebox` runtime compatibility shim.
  *
  * Historically the coding agent injected the real `@sinclair/typebox` (~5MB
  * dependency) into extensions, hooks, custom tools, and custom commands so
  * they could author parameter schemas as `Type.Object({ name: Type.String() })`.
- * Internally everything already runs through Zod (`wire.ts`, `validation.ts`);
- * the only reason TypeBox remained was extension-author compat.
  *
- * This module replaces that injection with a tiny façade whose `Type` builders
- * return Zod schemas. Output is indistinguishable from hand-written Zod inside
- * the agent pipeline:
+ * This module provides the subset those integrations depend on:
  *
- *   - `isZodSchema()` keys off the Zod `_zod` marker that every schema carries.
- *   - `zodToWireSchema()` emits the same draft 2020-12 JSON Schema providers expect
- *     from TypeBox-authored tools (defaulted fields treated as optional, etc.).
+ *   - TypeBox-style `Type.*` builders.
+ *   - Runtime validation through `schema.safeParse(input)` and `schema.__validator(input)`.
+ *   - Enumerable JSON Schema keywords so `{ ...schema }`, `JSON.stringify(schema)`,
+ *     and `toolWireSchema({ parameters: schema })` all see the same schema.
  *
- * The surface intentionally covers only the common TypeBox builders. Plugins
- * that reached for niche TypeBox-only APIs (`TypeCompiler`, the global
- * `TypeRegistry`, custom `Symbol(TypeBox.Kind)` introspection) must vendor
- * `@sinclair/typebox` directly in their own package.
+ * Internal validator fields and methods are intentionally non-enumerable. The
+ * object should look like JSON Schema at every serialization/wire boundary and
+ * like a small validator at runtime.
  */
-import { type ZodArray, type ZodEnum, type ZodObject, type ZodOptional, type ZodRawShape, type ZodType, z } from "zod/v4";
-export type TSchema = ZodType;
-export type Static<T extends ZodType> = z.infer<T>;
-export type TAny = ZodType;
-export type TUnknown = ZodType;
-export type TNever = ZodType;
-export type TNull = ZodType;
-export type TString = z.ZodString;
-export type TNumber = z.ZodNumber;
-export type TInteger = z.ZodNumber;
-export type TBoolean = z.ZodBoolean;
-export type TLiteral<V extends string | number | boolean> = z.ZodLiteral<V>;
-export type TArray<E extends ZodType> = ZodArray<E>;
-export type TObject<P extends ZodRawShape = ZodRawShape> = ZodObject<P>;
-export type TOptional<E extends ZodType> = ZodOptional<E>;
-export type TUnion<_T extends readonly ZodType[] = readonly ZodType[]> = ZodType;
-export type TEnum<T extends readonly (string | number)[] = readonly (string | number)[]> = ZodEnum<{
-    [K in T[number] as `${K}`]: K;
-}>;
-export type TRecord<_K extends ZodType, _V extends ZodType> = ZodType;
+export type TSchema = ArkSchema;
+export type Static<T extends ArkSchema> = T["__infer"];
+export type TAny = ArkSchema;
+export type TUnknown = ArkSchema;
+export type TNever = ArkSchema;
+export type TNull = ArkSchema;
+export type TString = ArkSchema;
+export type TNumber = ArkSchema;
+export type TInteger = ArkSchema;
+export type TBoolean = ArkSchema;
+export type TLiteral<_V extends string | number | boolean> = ArkSchema;
+export type TArray<_E extends ArkSchema> = ArkSchema;
+export type TObject<_P extends Record<string, ArkSchema> = Record<string, ArkSchema>> = ArkSchema;
+export type TOptional<_E extends ArkSchema> = ArkSchema;
+export type TUnion<_T extends readonly ArkSchema[] = readonly ArkSchema[]> = ArkSchema;
+export type TEnum<_T extends readonly (string | number)[] = readonly (string | number)[]> = ArkSchema;
+export type TRecord<_K extends ArkSchema, _V extends ArkSchema> = ArkSchema;
+declare const VALIDATION_FAILURE: unique symbol;
+interface ValidationFailure {
+    message: string;
+    readonly [VALIDATION_FAILURE]: true;
+}
+interface SafeParseSuccess {
+    success: true;
+    data: unknown;
+}
+interface SafeParseFailure {
+    success: false;
+    error: ValidationFailure;
+}
+/**
+ * JSON-Schema-shaped object with non-enumerable runtime helpers.
+ * Validators return the validated data or a marked `{ message }` failure.
+ */
+interface ArkSchema {
+    __validator: (data: unknown) => unknown;
+    __metadata?: Record<string, unknown>;
+    __optional?: true;
+    __properties?: Record<string, ArkSchema>;
+    __additionalProperties?: boolean | ArkSchema;
+    __infer?: unknown;
+    __inner?: ArkSchema;
+    safeParse(input: unknown): SafeParseSuccess | SafeParseFailure;
+    toJSON(): Record<string, unknown>;
+    [key: string]: unknown;
+}
 interface Meta {
     title?: string;
     description?: string;
@@ -70,32 +92,32 @@ interface ObjectOpts extends Meta {
      * TypeBox default: extra keys are preserved. Set `false` to reject unknowns,
      * `true` to allow any, or a schema to validate them.
      */
-    additionalProperties?: boolean | ZodType;
+    additionalProperties?: boolean | ArkSchema;
 }
-declare function tString(opts?: StringOpts): ZodType;
-declare function tNumber(opts?: NumberOpts): ZodType;
-declare function tInteger(opts?: NumberOpts): ZodType;
-declare function tBoolean(opts?: Meta): ZodType;
-declare function tNull(opts?: Meta): ZodType;
-declare function tAny(opts?: Meta): ZodType;
-declare function tUnknown(opts?: Meta): ZodType;
-declare function tNever(opts?: Meta): ZodType;
-declare function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ZodType;
-declare function tUnion<T extends readonly ZodType[]>(schemas: T, opts?: Meta): ZodType;
-declare function tIntersect(schemas: readonly ZodType[], opts?: Meta): ZodType;
-declare function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(values: T, opts?: Meta): ZodType;
-declare function tArray<E extends ZodType>(item: E, opts?: ArrayOpts): ZodType;
-declare function tTuple(items: readonly ZodType[], opts?: Meta): ZodType;
-declare function tObject<P extends ZodRawShape>(properties: P, opts?: ObjectOpts): ZodObject<P>;
-declare function tRecord<V extends ZodType>(key: ZodType, value: V, opts?: Meta): ZodType;
-declare function tOptional<E extends ZodType>(schema: E, _opts?: Meta): ZodOptional<E>;
-declare function tNullable<E extends ZodType>(schema: E, opts?: Meta): ZodType;
-declare function tReadonly<E extends ZodType>(schema: E): E;
-declare function tPartial<P extends ZodRawShape>(obj: ZodObject<P>): ZodObject<P>;
-declare function tRequired<P extends ZodRawShape>(obj: ZodObject<P>): ZodObject<P>;
-declare function tPick<P extends ZodRawShape, K extends keyof P>(obj: ZodObject<P>, keys: readonly K[]): ZodObject<Pick<P, K>>;
-declare function tOmit<P extends ZodRawShape, K extends keyof P>(obj: ZodObject<P>, keys: readonly K[]): ZodObject<Omit<P, K>>;
-declare function tComposite(objects: readonly ZodObject<ZodRawShape>[], opts?: Meta): ZodObject<ZodRawShape>;
+declare function tString(opts?: StringOpts): ArkSchema;
+declare function tNumber(opts?: NumberOpts): ArkSchema;
+declare function tInteger(opts?: NumberOpts): ArkSchema;
+declare function tBoolean(opts?: Meta): ArkSchema;
+declare function tNull(opts?: Meta): ArkSchema;
+declare function tAny(opts?: Meta): ArkSchema;
+declare function tUnknown(opts?: Meta): ArkSchema;
+declare function tNever(opts?: Meta): ArkSchema;
+declare function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ArkSchema;
+declare function tUnion<T extends readonly ArkSchema[]>(schemas: T, opts?: Meta): ArkSchema;
+declare function tIntersect(schemas: readonly ArkSchema[], opts?: Meta): ArkSchema;
+declare function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(values: T, opts?: Meta): ArkSchema;
+declare function tArray<E extends ArkSchema>(item: E, opts?: ArrayOpts): ArkSchema;
+declare function tTuple(items: readonly ArkSchema[], opts?: Meta): ArkSchema;
+declare function tObject<P extends Record<string, ArkSchema>>(properties: P, opts?: ObjectOpts): ArkSchema;
+declare function tRecord<K extends ArkSchema, V extends ArkSchema>(key: K, value: V, opts?: Meta): ArkSchema;
+declare function tOptional<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
+declare function tNullable<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
+declare function tReadonly<E extends ArkSchema>(schema: E): ArkSchema;
+declare function tPartial<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
+declare function tRequired<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
+declare function tPick<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
+declare function tOmit<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
+declare function tComposite(objects: readonly ArkSchema[], opts?: Meta): ArkSchema;
 export declare const Type: {
     readonly String: typeof tString;
     readonly Number: typeof tNumber;

package/dist/types/goals/tools/goal-tool.d.ts

@@ -1,22 +1,15 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import type { ToolSession } from "../../tools";
 import type { Goal, GoalToolDetails } from "../state";
-declare const goalSchema: z.ZodObject<{
-    op: z.ZodEnum<{
-        complete: "complete";
-        create: "create";
-        drop: "drop";
-        get: "get";
-        resume: "resume";
-    }>;
-    objective: z.ZodOptional<z.ZodString>;
-    token_budget: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type GoalToolInput = z.infer<typeof goalSchema>;
+declare const goalSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "complete" | "create" | "drop" | "get" | "resume";
+    objective?: string | undefined;
+    token_budget?: number | undefined;
+}, {}>;
+export type GoalToolInput = typeof goalSchema.infer;
 export interface GoalToolResponse {
     goal: Goal | null;
     remainingTokens: number | null;
@@ -30,17 +23,11 @@ export declare class GoalTool implements AgentTool<typeof goalSchema, GoalToolDe
     readonly name = "goal";
     readonly label = "Goal";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodEnum<{
-            complete: "complete";
-            create: "create";
-            drop: "drop";
-            get: "get";
-            resume: "resume";
-        }>;
-        objective: z.ZodOptional<z.ZodString>;
-        token_budget: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "complete" | "create" | "drop" | "get" | "resume";
+        objective?: string | undefined;
+        token_budget?: number | undefined;
+    }, {}>;
     readonly strict = true;
     readonly intent: "omit";
     constructor(session: ToolSession);

package/dist/types/index.d.ts

@@ -1,6 +1,8 @@
 import { HookEditorComponent, HookInputComponent, HookSelectorComponent } from "./modes/components";
 export { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 export { getAgentDir, logger, VERSION } from "@oh-my-pi/pi-utils";
+export * as zod from "zod/v4";
+export { z } from "zod/v4";
 export * from "./config/keybindings";
 export * from "./config/model-registry";
 export type * from "./config/prompt-templates";

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

@@ -102,32 +102,17 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
     readonly loadMode = "discoverable";
     readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
     readonly description: string;
-    readonly parameters: import("zod/v4").ZodObject<{
-        action: import("zod/v4").ZodEnum<{
-            capabilities: "capabilities";
-            code_actions: "code_actions";
-            definition: "definition";
-            diagnostics: "diagnostics";
-            hover: "hover";
-            implementation: "implementation";
-            references: "references";
-            reload: "reload";
-            rename: "rename";
-            rename_file: "rename_file";
-            request: "request";
-            status: "status";
-            symbols: "symbols";
-            type_definition: "type_definition";
-        }>;
-        file: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        line: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        symbol: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        query: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        new_name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        apply: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
-        timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        payload: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    }, import("zod/v4/core").$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
+        file?: string | undefined;
+        line?: number | undefined;
+        symbol?: string | undefined;
+        query?: string | undefined;
+        new_name?: string | undefined;
+        apply?: boolean | undefined;
+        timeout?: number | undefined;
+        payload?: string | undefined;
+    }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
     static createIf(session: ToolSession): LspTool | null;

package/dist/types/lsp/types.d.ts

@@ -1,32 +1,16 @@
 import type { ptree } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
-export declare const lspSchema: z.ZodObject<{
-    action: z.ZodEnum<{
-        capabilities: "capabilities";
-        code_actions: "code_actions";
-        definition: "definition";
-        diagnostics: "diagnostics";
-        hover: "hover";
-        implementation: "implementation";
-        references: "references";
-        reload: "reload";
-        rename: "rename";
-        rename_file: "rename_file";
-        request: "request";
-        status: "status";
-        symbols: "symbols";
-        type_definition: "type_definition";
-    }>;
-    file: z.ZodOptional<z.ZodString>;
-    line: z.ZodOptional<z.ZodNumber>;
-    symbol: z.ZodOptional<z.ZodString>;
-    query: z.ZodOptional<z.ZodString>;
-    new_name: z.ZodOptional<z.ZodString>;
-    apply: z.ZodOptional<z.ZodBoolean>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    payload: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type LspParams = z.infer<typeof lspSchema>;
+export declare const lspSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
+    file?: string | undefined;
+    line?: number | undefined;
+    symbol?: string | undefined;
+    query?: string | undefined;
+    new_name?: string | undefined;
+    apply?: boolean | undefined;
+    timeout?: number | undefined;
+    payload?: string | undefined;
+}, {}>;
+export type LspParams = typeof lspSchema.infer;
 export interface LspToolDetails {
     serverName?: string;
     action: string;

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

@@ -35,6 +35,14 @@ export declare function listResources(connection: MCPServerConnection, options?:
 }): Promise<MCPResource[]>;
 /**
  * List resource templates from a connected server.
+ *
+ * A server MAY advertise the `resources` capability without implementing the
+ * optional `resources/templates/list` method (it is optional in the MCP spec).
+ * Such servers reject the request with JSON-RPC -32601 ("Method not found").
+ * Treat that as "no templates" and return `[]` rather than throwing — otherwise
+ * a caller that loads resources and templates together (see `MCPManager`'s
+ * `Promise.all([listResources, listResourceTemplates])`) would discard the
+ * server's concrete resources too. Any other error still propagates.
  */
 export declare function listResourceTemplates(connection: MCPServerConnection, options?: {
     signal?: AbortSignal;