@botconnector/bccli 0.4.0 → 0.4.2

package/dist/{serve-JG7RLIUD.js → serve-4J7HA4JO.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   createRuntime
-} from "./chunk-TVALKHFB.js";
-import "./chunk-QZKLZELZ.js";
-import "./chunk-M7CALSP3.js";
-import "./chunk-45SDLMTV.js";
+} from "./chunk-R72OV7RF.js";
+import "./chunk-OK2USAXX.js";
+import "./chunk-ZEPTUKNW.js";
+import "./chunk-JXM6REER.js";
 import "./chunk-PSO7R5AD.js";
 import {
   VERSION
-} from "./chunk-6M5X2KZE.js";
+} from "./chunk-266SY3MC.js";
 import {
   LOOPBACK_BIND,
   MAX_FRAME_BYTES,
@@ -17,25 +17,25 @@ import {
   parseClientFrame,
   randomToken,
   trustFence
-} from "./chunk-KEMYIGCP.js";
-import "./chunk-O7M3TGIW.js";
-import "./chunk-JL5ZCSP2.js";
+} from "./chunk-6UO5GX55.js";
+import "./chunk-WFZKJY3R.js";
+import "./chunk-H7XJDKJY.js";
 import {
   listAllModels
-} from "./chunk-XBO5GACQ.js";
-import "./chunk-SPRNLS7K.js";
-import "./chunk-7F3IWBPQ.js";
+} from "./chunk-IYR5PYA3.js";
+import "./chunk-HQW4BROS.js";
+import "./chunk-3I5BW3ZT.js";
 import {
   Session
-} from "./chunk-QDQU6VY2.js";
-import "./chunk-PUN4HMAG.js";
-import "./chunk-BLOYFIAD.js";
-import "./chunk-L7QI6JN2.js";
+} from "./chunk-SVD4LHJC.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
+import "./chunk-6M55UPES.js";
 import {
   bccliHome,
   loadConfig
-} from "./chunk-LACUWBWS.js";
-import "./chunk-UZWJQF67.js";
+} from "./chunk-RX4UQX43.js";
+import "./chunk-3WHI4LN3.js";
 
 // src/serve.ts
 import { randomBytes } from "crypto";
@@ -101,6 +101,11 @@ function readBody(req) {
 function sendFrame(ws, frame) {
   if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(frame));
 }
+function serveBanner(handle, opts = {}) {
+  const supplied = opts.token !== void 0 || (opts.env ?? process.env).BCCLI_SERVE_TOKEN !== void 0;
+  return `bccli serve ${handle.url}${supplied ? "" : ` \u2014 Authorization: Bearer ${handle.token}`}
+`;
+}
 async function startServe(opts = {}) {
   const env = opts.env ?? process.env;
   const cwd = opts.cwd ?? process.cwd();
@@ -454,7 +459,7 @@ Connection: close\r
   function attachSession(id, forCwd) {
     const found = findSessionFile(id, forCwd);
     if (!found) return void 0;
-    const rt = buildRuntime(found.cwd, "ask");
+    const rt = buildRuntime(found.cwd, "ask", found.session.lastModel());
     rt.resume(found.session);
     return registerSession(rt, found.cwd, "ask", id);
   }
@@ -511,5 +516,6 @@ Connection: close\r
   };
 }
 export {
+  serveBanner,
   startServe
 };

package/dist/{serve-6QLBJUYW.js → serve-K5AH4MGO.js}

@@ -3,15 +3,15 @@ import {
   createFetchTool,
   createWebSearchTool,
   isPrivateHost
-} from "./chunk-45SDLMTV.js";
+} from "./chunk-JXM6REER.js";
 import "./chunk-PSO7R5AD.js";
 import {
   loadConfig,
   readCredentials
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/mcpServer/serve.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

package/dist/serve.d.ts

@@ -0,0 +1,37 @@
+import type { Provider } from './provider';
+export interface ServeOptions {
+    port?: number;
+    host?: string;
+    token?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    fetch?: typeof fetch;
+    heartbeatMs?: number;
+    err?: (s: string) => void;
+}
+export interface ServeHandle {
+    port: number;
+    token: string;
+    url: string;
+    close(): Promise<void>;
+}
+export type PermissionMode = 'ask' | 'bypassPermissions';
+/**
+ * One-line terminal banner for `bccli serve`. A token the user supplied (`--token` or
+ * `BCCLI_SERVE_TOKEN`) is left out so it cannot leak into logs; a token BCCLI generated
+ * itself must be printed or nobody could connect.
+ */
+export declare function serveBanner(handle: {
+    url: string;
+    token: string;
+}, opts?: {
+    token?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+/**
+ * Starts the loopback session server (HTTP unary + WS mux at /v1/mux). Refuses
+ * non-loopback bind addresses; every request passes the DSH-style trust fence
+ * (403) and, except /health, the bearer-token check (401).
+ */
+export declare function startServe(opts?: ServeOptions): Promise<ServeHandle>;

package/dist/serveHeartbeat.d.ts

@@ -0,0 +1,14 @@
+export interface Heartbeat {
+    /** Sends the first ping and schedules the check loop. Idempotent until stop(). */
+    start(): void;
+    /** Marks the last ping as answered (ws 'pong' event). */
+    pong(): void;
+    /** Clears the timer; no further pings or terminations. */
+    stop(): void;
+}
+/**
+ * ws heartbeat with deadline: every interval a ping goes out; a ping left
+ * unanswered by the next tick terminates the socket (connection, not stream).
+ * Modeled on the DSH gateway's `websocketHeartbeatIntervalMs` behavior.
+ */
+export declare function createHeartbeat(intervalMs: number, ping: () => void, terminate: () => void): Heartbeat;

package/dist/serveProtocol.d.ts

@@ -0,0 +1,47 @@
+/** Wire frames of the /v1/mux WebSocket (subset of the DSH stream protocol). */
+export type ClientFrame = {
+    type: 'open';
+    streamId: string;
+    target: string;
+} | {
+    type: 'cancel';
+    streamId: string;
+};
+export type ServerFrame = {
+    type: 'item';
+    streamId: string;
+    value: unknown;
+} | {
+    type: 'end';
+    streamId: string;
+} | {
+    type: 'error';
+    streamId: string;
+    message: string;
+};
+/** Uplink frame size limit; oversized frames error their stream without closing the socket. */
+export declare const MAX_FRAME_BYTES = 262144;
+/**
+ * Parses one uplink mux frame. Malformed JSON, unknown types, an empty streamId,
+ * or an `open` without a target produce `{ error }` instead of throwing.
+ */
+export declare function parseClientFrame(raw: string): ClientFrame | {
+    error: string;
+};
+/** Addresses `bccli serve` is allowed to bind (loopback only; 0.0.0.0 is refused). */
+export declare const LOOPBACK_BIND: Set<string>;
+/**
+ * DSH-style trust fence: loopback Host with a port matching the listener, a
+ * same-machine Origin when attached, and no cross-site sec-fetch-site. Returns
+ * null when trusted, else the 403 reason. Never establishes identity — the
+ * bearer token does.
+ */
+export declare function trustFence(headers: {
+    host?: string;
+    origin?: string;
+    'sec-fetch-site'?: string;
+}, port: number): string | null;
+/** Timing-safe `Authorization: Bearer <token>` check. */
+export declare function bearerOk(header: string | undefined, token: string): boolean;
+/** Fresh 32-byte hex serve token. */
+export declare function randomToken(): string;

package/dist/session-YQXCCKXI.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  Session,
+  pruneSessions
+} from "./chunk-SVD4LHJC.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
+import "./chunk-3WHI4LN3.js";
+export {
+  Session,
+  pruneSessions
+};

package/dist/session.d.ts

@@ -0,0 +1,33 @@
+import { type ChatMessage, type Usage } from './provider';
+export declare class Session {
+    readonly file: string;
+    constructor(file: string);
+    get id(): string;
+    static create(home: string, cwd: string, now?: Date): Session;
+    static list(home: string, cwd: string): {
+        session: Session;
+        mtime: Date;
+        preview: string;
+    }[];
+    static latest(home: string, cwd: string): Session | undefined;
+    private write;
+    append(message: ChatMessage): void;
+    appendUsage(usage: Usage & {
+        model?: string;
+    }): void;
+    reset(): void;
+    private records;
+    /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+    load(): ChatMessage[];
+    /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+    lastModel(): string | undefined;
+    /** Accumulated token usage since the last non-compaction reset. */
+    totalUsage(): Usage;
+    /**
+     * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+     * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+     * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+     */
+    loadHistory(): ChatMessage[];
+}
+export declare function pruneSessions(home: string, now?: number, maxAgeDays?: number): number;

package/dist/setup-S4AJT6XE.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  createRuntime,
+  lunaPtcAutoEnabled
+} from "./chunk-R72OV7RF.js";
+import "./chunk-OK2USAXX.js";
+import "./chunk-ZEPTUKNW.js";
+import "./chunk-JXM6REER.js";
+import "./chunk-PSO7R5AD.js";
+import "./chunk-WFZKJY3R.js";
+import "./chunk-H7XJDKJY.js";
+import "./chunk-IYR5PYA3.js";
+import "./chunk-HQW4BROS.js";
+import "./chunk-3I5BW3ZT.js";
+import "./chunk-SVD4LHJC.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
+import "./chunk-6M55UPES.js";
+import "./chunk-RX4UQX43.js";
+import "./chunk-3WHI4LN3.js";
+export {
+  createRuntime,
+  lunaPtcAutoEnabled
+};

package/dist/setup.d.ts

@@ -0,0 +1,74 @@
+import { Agent } from './agent';
+import { CheckpointStore } from './checkpoints';
+import type { McpServerSpec } from './mcp/config';
+import { McpManager } from './mcp/manager';
+import type { CliArgs } from './args';
+import { type Config } from './config';
+import { type AgentDef, type CommandDef, type SkillDef } from './extensions';
+import { type ModelGroup } from './models';
+import { type ChatMessage, type Provider } from './provider';
+import type { ReasoningLevel } from './reasoning';
+import { addProviderKey } from './providerCli';
+import { Session } from './session';
+import { type Interaction } from './tools/plan';
+import { TodoStore } from './tools/todo';
+import { type PluginPayload } from './plugins';
+import type { HookEvent } from './hooks';
+export interface Runtime {
+    cwd: string;
+    home: string;
+    config: Config;
+    modelRef: string;
+    reasoning: ReasoningLevel;
+    agent: Agent;
+    session: Session;
+    setModel(ref: string): void;
+    setReasoning(level: ReasoningLevel): void;
+    env: NodeJS.ProcessEnv;
+    skills: SkillDef[];
+    commands: CommandDef[];
+    agentDefs: AgentDef[];
+    todos: TodoStore;
+    interaction: Interaction;
+    mcp: McpManager;
+    startMcp(specs: McpServerSpec[]): Promise<void>;
+    reloadConfig(): void;
+    providerLabel(): string;
+    listModels: (only?: string) => Promise<ModelGroup[]>;
+    addProviderKey(id: string, key: string): ReturnType<typeof addProviderKey>;
+    /** Continue an earlier session: load its history and append new messages to its file. */
+    resume(session: Session): void;
+    /** Starts a fresh session file; the previous one stays on disk for /resume. */
+    newSession(): void;
+    /** Re-reads AGENTS.md/BCCLI.md into the system prompt (after /memory). */
+    rebuildSystemPrompt(): void;
+    /** Fires a plugin observer event (SessionStart/Stop are emitted here; tool events come from the agent). */
+    emitPlugins(event: HookEvent, payload?: PluginPayload): Promise<void>;
+    checkpoints: CheckpointStore;
+    /**
+     * Steps back n conversation turns: truncates the history (and the session log) to before
+     * them and restores the file snapshots they took. Returns undefined when nothing is left.
+     */
+    rewindTurns(n: number): Promise<RewindResult | undefined>;
+    startedAt: Date;
+}
+export interface RewindResult {
+    turns: number;
+    restored: string[];
+    deleted: string[];
+    skipped: string[];
+    failed: string[];
+}
+/** PTC is automatic for Luna. This env var is only an emergency/internal kill switch. */
+export declare function lunaPtcAutoEnabled(env: NodeJS.ProcessEnv): boolean;
+export declare function createRuntime(opts: {
+    cwd: string;
+    args: CliArgs;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    history?: ChatMessage[];
+    fetch?: typeof fetch;
+    userHome?: string;
+    /** Override langkah agent (mis. githubBot.stepLimit) — menang atas config.maxSteps. */
+    maxSteps?: number | null;
+}): Runtime;

package/dist/slash/copy.d.ts

@@ -0,0 +1 @@
+export declare function osc52(text: string, inTmux: boolean): string;

package/dist/slash/diff.d.ts

@@ -0,0 +1 @@
+export declare function gitDiff(cwd: string, maxLines?: number, bin?: string): Promise<string>;

package/dist/slash/doctor.d.ts

@@ -0,0 +1,18 @@
+export interface DoctorDeps {
+    which: (cmd: string) => boolean | Promise<boolean>;
+    nodeVersion: string;
+    listModels: () => Promise<unknown[]>;
+}
+export declare function doctorText(input: {
+    providers: {
+        id: string;
+        name: string;
+        ready: boolean;
+    }[];
+    mcp: {
+        name: string;
+        status: string;
+        error?: string;
+    }[];
+    activeProvider: string;
+}, deps: DoctorDeps): Promise<string>;

package/dist/slash/export.d.ts

@@ -0,0 +1,2 @@
+import { type ChatMessage } from '../provider';
+export declare function exportMarkdown(messages: ChatMessage[], title: string): string;

package/dist/slash/info.d.ts

@@ -0,0 +1,46 @@
+export interface StatusInput {
+    version: string;
+    modelRef: string;
+    providerLabel: string;
+    mode: string;
+    cwd: string;
+    mcp: {
+        name: string;
+        status: string;
+        error?: string;
+        tools: number;
+    }[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens?: number;
+        cacheWriteTokens?: number;
+    };
+    lastInputTokens: number;
+    contextWindow?: number;
+}
+export declare function statusText(s: StatusInput): string;
+export declare function agentsText(defs: {
+    name: string;
+    description: string;
+    tools?: string[];
+    model?: string;
+}[]): string;
+export declare function skillsText(skills: {
+    name: string;
+    description: string;
+    dir: string;
+}[], commands: {
+    name: string;
+    description?: string;
+}[]): string;
+export declare function sessionText(s: {
+    file: string;
+    started: Date;
+    messages: number;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    modelRef: string;
+}): string;

package/dist/slash/memory.d.ts

@@ -0,0 +1,10 @@
+export declare function instructionFiles(cwd: string, home: string): {
+    path: string;
+    lines: number;
+}[];
+export declare function appendMemory(file: string, text: string): void;
+/** `/memory [global] <teks>` → target file and text; text is empty when nothing follows. */
+export declare function parseMemoryArgs(args: string): {
+    global: boolean;
+    text: string;
+};

package/dist/{statsCli-CF3R7ATL.js → statsCli-XR6BEZQQ.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   estimateTokens
-} from "./chunk-QZKLZELZ.js";
+} from "./chunk-OK2USAXX.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/statsCli.ts
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";

package/dist/statsCli.d.ts

@@ -0,0 +1,62 @@
+export interface StatsRow {
+    project: string;
+    sessions: number;
+    messages: number;
+    /** Estimated tokens (messages without recorded usage only). */
+    inputTokens: number;
+    outputTokens: number;
+    /** Tokens from persisted `t:usage` records. */
+    usageInputTokens: number;
+    usageOutputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+    toolCalls: Record<string, number>;
+    /** Total tokens per session (recorded basis when present, estimate otherwise). */
+    sessionTotals: number[];
+    /** Per-model token totals from `t:usage` records that carry a model ref. */
+    modelUsage: Record<string, ModelTotals>;
+}
+export interface ModelTotals {
+    turns: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+}
+export interface AggregateOptions {
+    days: number;
+    now?: number;
+}
+/**
+ * Walk home/sessions/<project>/*.jsonl, keep files with mtime within `days`,
+ * and aggregate per project. Token basis switches per session: sessions with
+ * recorded usage records use them (incl. cache counters); older sessions fall
+ * back to ~4 chars/token estimates from message content.
+ */
+export declare function aggregateSessions(home: string, opts: AggregateOptions): StatsRow[];
+/** Compact token formatting like the opencode stats boxes: 291.6K / 41.0M / 627.4M. */
+export declare function fmtCompact(n: number): string;
+export interface StatsCliArgs {
+    subArgs: string[];
+    home: string;
+    cwd?: string;
+    now?: number;
+    /** Already-parsed `--days` from parseCliArgs (subArgs never contains it). */
+    days?: number;
+    /** Already-parsed `--tools` top-N cap. */
+    tools?: number;
+    /** Already-parsed `--models` ("all" or a number as string). */
+    models?: string;
+    /** Already-parsed `--project` filter (empty string = current project). */
+    project?: string;
+}
+export interface StatsDeps {
+    out(line: string): void;
+    err?(line: string): void;
+}
+/**
+ * `bccli stats [--days N] [--tools N] [--models [N|all]] [--project slug]` —
+ * token usage and tool-call stats from local session files, rendered as
+ * opencode-style overview/tokens/model/tool boxes.
+ */
+export declare function runStatsCommand(args: StatsCliArgs, deps: StatsDeps): number;

package/dist/textToolCalls.d.ts

@@ -0,0 +1,6 @@
+import type { ToolCall } from './provider';
+import type { ToolDefinition } from './tools/index';
+export declare function recoverTextToolCalls(text: string, tools: ToolDefinition[]): {
+    text: string;
+    toolCalls: ToolCall[];
+} | null;

package/dist/thinking.d.ts

@@ -0,0 +1,17 @@
+export declare class ThinkSplitter {
+    private inside;
+    private held;
+    push(delta: string): {
+        text: string;
+        thinking: string;
+    };
+    /** Whatever was held back as a possible tag start is plain text after all. */
+    flush(): {
+        text: string;
+        thinking: string;
+    };
+}
+export declare function splitThinking(text: string): {
+    text: string;
+    thinking: string;
+};

package/dist/tokenBudget.d.ts

@@ -0,0 +1,22 @@
+import type { ChatMessage } from './provider';
+/** ~4 chars per token, the same conservative estimate the usage fallback uses. */
+export declare const estimateTokens: (text: string) => number;
+export declare function estimateMessages(messages: ChatMessage[]): number;
+/**
+ * Drops whole oldest turns (everything up to the next user message) until the history fits the
+ * budget. Cutting only at turn boundaries keeps assistant tool_calls paired with their tool
+ * replies, so the trimmed history is always valid for a provider request.
+ */
+export declare function trimToFit(messages: ChatMessage[], maxTokens: number): ChatMessage[];
+/**
+ * Splits history into [old, keep]: the newest whole turns that fit `keepTokens` (at least the
+ * last user turn) stay verbatim; everything older goes to `old` for summarization. Cutting at
+ * user boundaries keeps tool_calls paired with their replies.
+ */
+export declare function splitKeepRecent(messages: ChatMessage[], keepTokens: number): [ChatMessage[], ChatMessage[]];
+export declare const isToolStub: (content: string) => boolean;
+/**
+ * Replaces old tool results with a one-line stub once they add up past PRUNE_MIN_TOKENS, so the
+ * prompt prefix (and its cache) changes rarely. The newest KEEP_TOKENS worth stay intact.
+ */
+export declare function pruneOldToolOutputs(messages: ChatMessage[]): boolean;

package/dist/tools/bash.d.ts

@@ -0,0 +1,52 @@
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { type ShellDeps, type ShellSpec } from './shell';
+type Spawn = typeof spawn;
+/** Kill a command and everything it started. Never throws (e.g. taskkill missing on Windows). */
+export declare function killProcessTree(pid: number, platform?: NodeJS.Platform, spawnFn?: Spawn): void;
+export declare function killAllCommands(): void;
+/** Human-readable list for the /tasks slash command. */
+export declare function renderBackgroundTasks(): string;
+/** Test/exit helper: stop every background task and forget them. */
+export declare function resetBackgroundTasks(): void;
+export interface CommandResult {
+    output: string;
+    exitCode: number | null;
+    timedOut: boolean;
+    aborted: boolean;
+}
+export declare function needsNetwork(command: string): boolean;
+/** Proxy env pointing at a dead local port: tools that honour proxy vars fail fast offline. */
+export declare function offlineEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function runCommand(command: string | string[], opts: {
+    cwd: string;
+    timeoutMs: number;
+    signal: AbortSignal;
+    env?: NodeJS.ProcessEnv;
+    shell?: ShellSpec;
+}): Promise<CommandResult>;
+export interface BashToolOptions {
+    /** "offline" blocks known network commands and points proxy env at a dead local port. */
+    networkPolicy?: 'allow' | 'offline';
+    /** Run every command inside the OS sandbox (sandbox-exec on macOS, bwrap on Linux). */
+    sandbox?: boolean;
+    /** Test hook: pretend to be another platform. */
+    platform?: NodeJS.Platform;
+    /** Test hook: fake environment / file lookup used to pick the Windows shell. */
+    shellDeps?: Partial<ShellDeps>;
+}
+export declare function createBashTool(options?: BashToolOptions): import("./types").Tool<z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    task_id: z.ZodOptional<z.ZodNumber>;
+    kill: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export declare const bashTool: import("./types").Tool<z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    task_id: z.ZodOptional<z.ZodNumber>;
+    kill: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export {};

package/dist/tools/diagnostics.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { type LspServer } from '../lsp';
+export declare function createDiagnosticsTool(servers: LspServer[]): import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>>;

package/dist/tools/edit.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const editTool: import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    old_string: z.ZodOptional<z.ZodString>;
+    new_string: z.ZodOptional<z.ZodString>;
+    replace_all: z.ZodOptional<z.ZodBoolean>;
+    edits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        old_string: z.ZodString;
+        new_string: z.ZodString;
+        replace_all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;