@promptbook/node 0.112.0-99 → 0.112.0

package/umd/scripts/run-agent-chat/executeAgentChatTurn.d.ts

@@ -0,0 +1,28 @@
+import type { AgentCliHistoryMessage, AgentCliRunOptions } from './AgentCliRunOptions';
+/**
+ * Result of one local agent CLI turn.
+ */
+export type AgentChatTurnResult = {
+    readonly answer: string;
+    readonly workspacePath: string;
+    readonly messageFilePath: string;
+    readonly agentPath: string;
+};
+/**
+ * Options for executing one local agent CLI turn.
+ */
+export type ExecuteAgentChatTurnOptions = AgentCliRunOptions & {
+    readonly messages: ReadonlyArray<AgentCliHistoryMessage>;
+    readonly workspacePath?: string;
+};
+/**
+ * Executes one user turn by asking the selected harness to append `MESSAGE @Agent` to a temporary thread book.
+ */
+export declare function executeAgentChatTurn(options: ExecuteAgentChatTurnOptions): Promise<AgentChatTurnResult>;
+/**
+ * Creates an isolated workspace path under the project-local Promptbook temporary directory.
+ */
+export declare function createAgentChatWorkspacePath(options: {
+    readonly currentWorkingDirectory: string;
+    readonly agentPath: string;
+}): string;

package/umd/scripts/run-agent-messages/messages/buildAgentMessagePrompt.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Builds the prompt sent to the selected coding runner for one queued user-thread book.
+ */
+export declare function buildAgentMessagePrompt(messageRelativePath: string, agentSystemMessage: string): string;

package/umd/scripts/run-agent-messages/messages/buildAgentMessageScriptPath.d.ts

@@ -0,0 +1,5 @@
+import type { AgentMessageFile } from './AgentMessageFile';
+/**
+ * Builds a temporary script path for one agent message runner invocation.
+ */
+export declare function buildAgentMessageScriptPath(projectPath: string, messageFile: AgentMessageFile): string;

package/umd/scripts/run-agent-messages/messages/createAgentRunnerSystemMessage.d.ts

@@ -0,0 +1,10 @@
+import type { AgentModelRequirements } from '../../../src/book-2.0/agent-source/AgentModelRequirements';
+import type { string_book } from '../../../src/book-2.0/agent-source/string_book';
+/**
+ * Compiles agent source into the behavior text passed to CLI harness runners.
+ */
+export declare function createAgentRunnerSystemMessage(agentSource: string_book): Promise<string>;
+/**
+ * Formats prepared model requirements for a text-only CLI harness prompt.
+ */
+export declare function formatAgentModelRequirementsForRunner(modelRequirements: AgentModelRequirements): string;

package/umd/scripts/run-codex-prompts/common/ProgressiveBackoff.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Default progressive delays used for rate-limit retries:
+ * 1 minute, 2 minutes, 5 minutes, 10 minutes, and 30 minutes.
+ */
+export declare const DEFAULT_PROGRESSIVE_BACKOFF_DELAYS_MS: readonly number[];
+/**
+ * Options for one progressive backoff counter.
+ */
+export type ProgressiveBackoffOptions = {
+    delaysMs?: readonly number[];
+    maxDelayMs?: number;
+    jitterRatio?: number;
+    random?: () => number;
+};
+/**
+ * Stateful progressive backoff counter with optional jitter and capped maximum delay.
+ */
+export declare class ProgressiveBackoff {
+    private readonly delaysMs;
+    private readonly maxDelayMs;
+    private readonly jitterRatio;
+    private readonly random;
+    private failuresSinceSuccess;
+    /**
+     * Creates one progressive backoff counter.
+     */
+    constructor(options?: ProgressiveBackoffOptions);
+    /**
+     * Number of consecutive failures since the last successful reset.
+     */
+    get retryCount(): number;
+    /**
+     * Returns the next delay and advances the backoff counter by one failed attempt.
+     */
+    nextDelayMs(): number;
+    /**
+     * Resets backoff state after one successful call.
+     */
+    reset(): void;
+    /**
+     * Resolves the non-jittered delay for the given retry index.
+     */
+    private resolveBaseDelayMs;
+}

package/umd/scripts/run-codex-prompts/common/appendCoderContext.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Appends optional coding context to a runner prompt.
+ */
+export declare function appendCoderContext(prompt: string, context: string | undefined): string;

package/umd/scripts/run-codex-prompts/common/formatUnknownErrorDetails.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Formats one unknown error-like value into readable text for logs and feedback.
+ */
+export declare function formatUnknownErrorDetails(error: unknown): string;

package/umd/scripts/run-codex-prompts/common/runGoScript/$runGoScript.d.ts

@@ -0,0 +1,5 @@
+import type { RunGoScriptOptions } from './RunGoScriptOptions';
+/**
+ * Creates a temporary script file, runs it, and cleans it up unless preservation is requested or the run fails.
+ */
+export declare function $runGoScript(options: RunGoScriptOptions): Promise<void>;

package/umd/scripts/run-codex-prompts/common/runGoScript/$runGoScriptUntilMarkerIdle.d.ts

@@ -0,0 +1,6 @@
+import type { RunGoScriptUntilMarkerIdleOptions } from './RunGoScriptUntilMarkerIdleOptions';
+/**
+ * Creates a temporary script file, runs it, waits for a completion marker and idle time, and cleans it up unless preservation is requested or the run fails.
+ * Returns the captured output for post-processing.
+ */
+export declare function $runGoScriptUntilMarkerIdle(options: RunGoScriptUntilMarkerIdleOptions): Promise<string>;

package/umd/scripts/run-codex-prompts/common/runGoScript/$runGoScriptWithOutput.d.ts

@@ -0,0 +1,5 @@
+import type { RunGoScriptOptions } from './RunGoScriptOptions';
+/**
+ * Creates a temporary script file, runs it, captures output, and cleans it up unless preservation is requested or the run fails.
+ */
+export declare function $runGoScriptWithOutput(options: RunGoScriptOptions): Promise<string>;

package/umd/scripts/run-codex-prompts/common/runGoScript/buildScriptLogPath.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Builds the temporary live runtime log path for one prompt script and its sibling test script.
+ */
+export declare function buildScriptLogPath(scriptPath: string): string;

package/umd/scripts/run-codex-prompts/common/runGoScript/buildTemporaryPromptScriptPath.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Options used to build one Promptbook-owned temporary shell script path.
+ */
+type BuildTemporaryPromptScriptPathOptions = {
+    readonly projectPath: string;
+    readonly scriptDirectoryName: string;
+    readonly sourceFileName: string;
+    readonly suffix?: string;
+};
+/**
+ * Builds a normalized temporary shell script path for prompt runners.
+ */
+export declare function buildTemporaryPromptScriptPath(options: BuildTemporaryPromptScriptPathOptions): string;
+export {};

package/umd/scripts/run-codex-prompts/common/runGoScript/printLiveScriptChunk.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Prints one live shell output chunk to the terminal when console mirroring is enabled.
+ */
+export declare function printLiveScriptChunk(chunk: string, source: 'stdout' | 'stderr', shouldPrintLiveOutput: boolean): void;

package/umd/scripts/run-codex-prompts/common/runGoScript/runBashScriptWithOutput.d.ts

@@ -0,0 +1,5 @@
+import type { RunGoScriptOptions } from './RunGoScriptOptions';
+/**
+ * Runs one temporary bash script, optionally mirroring its raw input/output into a live runtime log file.
+ */
+export declare function runBashScriptWithOutput(options: RunGoScriptOptions): Promise<string>;

package/umd/scripts/run-codex-prompts/common/runGoScript/runScriptUntilMarkerIdle.d.ts

@@ -0,0 +1,6 @@
+import type { RunScriptUntilMarkerIdleOptions } from './RunScriptUntilMarkerIdleOptions';
+/**
+ * Runs a script until a completion marker is observed and output is idle for a set timeout.
+ * Returns the captured output.
+ */
+export declare function runScriptUntilMarkerIdle(options: RunScriptUntilMarkerIdleOptions): Promise<string>;

package/umd/scripts/run-codex-prompts/common/runGoScript/scriptExecutionLog.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Environment variable read by the shell wrapper to tee live output into the temporary runtime log file.
+ */
+export declare const PTBK_CODER_LOG_FILE_ENV_NAME = "PTBK_CODER_LOG_FILE";
+/**
+ * Shapes one bash invocation that optionally mirrors live script output into a temporary log file.
+ */
+export declare function buildLoggedBashExecution(scriptPath: string, logPath?: string): {
+    args: string[];
+    env?: Record<string, string>;
+};
+/**
+ * Appends one execution-start section with the raw script input before the shell begins producing output.
+ */
+export declare function appendScriptExecutionLogStart({ scriptPath, scriptContent, logPath, }: {
+    scriptPath: string;
+    scriptContent: string;
+    logPath?: string;
+}): Promise<void>;
+/**
+ * Appends one execution-finish section after the shell settles.
+ */
+export declare function appendScriptExecutionLogFinish({ scriptPath, logPath, status, details, }: {
+    scriptPath: string;
+    logPath?: string;
+    status: string;
+    details?: unknown;
+}): Promise<void>;

package/umd/scripts/run-codex-prompts/common/runGoScript/shouldDeleteTemporaryArtifact.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decides whether one temporary prompt artifact should be deleted after a round finishes.
+ */
+export declare function shouldDeleteTemporaryArtifact({ preserveArtifactsOnSuccess, hasFailed, }: {
+    preserveArtifactsOnSuccess?: boolean;
+    hasFailed: boolean;
+}): boolean;

package/umd/scripts/run-codex-prompts/common/runGoScript/toPosixPath.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Converts a file path to POSIX format.
+ */
+export declare function toPosixPath(filePath: string): string;

package/umd/scripts/run-codex-prompts/common/runGoScript/withPromptRuntimeLog.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs one prompt-processing round with a dedicated temporary runtime log file that is cleaned up only after successful non-preserved runs.
+ */
+export declare function withPromptRuntimeLog<T>(scriptPath: string, handler: (logPath: string) => Promise<T>, options?: {
+    preserveArtifactsOnSuccess?: boolean;
+}): Promise<T>;

package/umd/scripts/run-codex-prompts/common/runGoScript/withTempScript.d.ts

@@ -0,0 +1,5 @@
+import type { RunGoScriptOptions } from './RunGoScriptOptions';
+/**
+ * Creates a temporary script file, runs a handler, and cleans it up unless preservation is requested or the run fails.
+ */
+export declare function withTempScript<T>(options: RunGoScriptOptions, handler: (scriptPath: string) => Promise<T>): Promise<T>;

package/umd/scripts/run-codex-prompts/main/resolvePromptRunner.d.ts

@@ -0,0 +1,24 @@
+import type { RunOptions } from '../cli/RunOptions';
+import type { PromptRunner } from '../runners/types/PromptRunner';
+/**
+ * Runner metadata used in prompt status lines.
+ */
+type RunnerMetadata = {
+    runnerName: string;
+    modelName?: string;
+};
+/**
+ * Resolved runner setup used by `runCodexPrompts`.
+ */
+type PromptRunnerResolution = {
+    runner: PromptRunner;
+    actualRunnerModel?: string;
+    runnerMetadata: RunnerMetadata;
+};
+/**
+ * Resolves the configured prompt runner together with status-line metadata.
+ *
+ * @private function of runCodexPrompts
+ */
+export declare function resolvePromptRunner(options: RunOptions): PromptRunnerResolution;
+export {};

package/umd/scripts/run-codex-prompts/runners/claude-code/ClaudeCodeRunner.d.ts

@@ -0,0 +1,19 @@
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { PromptRunner } from '../types/PromptRunner';
+import type { ClaudeCodeRunnerOptions } from './ClaudeCodeRunnerOptions';
+/**
+ * Runs prompts via the Claude Code CLI.
+ */
+export declare class ClaudeCodeRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "claude-code";
+    /**
+     * Creates a new Claude Code runner.
+     */
+    constructor(options?: ClaudeCodeRunnerOptions);
+    /**
+     * Runs the prompt using Claude Code and parses usage output.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/umd/scripts/run-codex-prompts/runners/claude-code/buildClaudeScript.d.ts

@@ -0,0 +1,5 @@
+import type { ClaudeScriptOptions } from './ClaudeScriptOptions';
+/**
+ * Builds the shell script that runs Claude Code with the prompt and coding context.
+ */
+export declare function buildClaudeScript(options: ClaudeScriptOptions): string;

package/umd/scripts/run-codex-prompts/runners/claude-code/parseClaudeCodeJsonOutput.d.ts

@@ -0,0 +1,5 @@
+import type { Usage } from '../../../../src/execution/Usage';
+/**
+ * Parses Claude Code JSON output and extracts usage information.
+ */
+export declare function parseClaudeCodeJsonOutput(output: string): Usage;

package/umd/scripts/run-codex-prompts/runners/cline/ClineRunner.d.ts

@@ -0,0 +1,19 @@
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { PromptRunner } from '../types/PromptRunner';
+import type { ClineRunnerOptions } from './ClineRunnerOptions';
+/**
+ * Runs prompts via the Cline CLI.
+ */
+export declare class ClineRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "cline";
+    /**
+     * Creates a new Cline runner.
+     */
+    constructor(options: ClineRunnerOptions);
+    /**
+     * Runs the prompt using the Cline CLI.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/umd/scripts/run-codex-prompts/runners/cline/buildClineScript.d.ts

@@ -0,0 +1,5 @@
+import type { ClineScriptOptions } from './ClineScriptOptions';
+/**
+ * Builds the shell script that runs Cline with the prompt and coding context.
+ */
+export declare function buildClineScript(options: ClineScriptOptions): string;

package/umd/scripts/run-codex-prompts/runners/gemini/GeminiRunner.d.ts

@@ -0,0 +1,23 @@
+import type { PromptRunner } from '../types/PromptRunner';
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { GeminiRunnerOptions } from './GeminiRunnerOptions';
+/**
+ * Default Gemini model used by the coding runner.
+ */
+export declare const DEFAULT_GEMINI_MODEL = "gemini-3.1-pro-preview";
+/**
+ * Runs prompts via the Gemini CLI.
+ */
+export declare class GeminiRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "gemini";
+    /**
+     * Creates a new Gemini runner.
+     */
+    constructor(options: GeminiRunnerOptions);
+    /**
+     * Runs the prompt using Gemini and parses usage output.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/umd/scripts/run-codex-prompts/runners/gemini/buildGeminiScript.d.ts

@@ -0,0 +1,5 @@
+import type { GeminiScriptOptions } from './GeminiScriptOptions';
+/**
+ * Builds the shell script that runs Gemini with the prompt and coding context.
+ */
+export declare function buildGeminiScript(options: GeminiScriptOptions): string;

package/umd/scripts/run-codex-prompts/runners/gemini/gemini-pricing.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The pricing for Gemini models per 1 million tokens in USD.
+ *
+ * Note: This is an estimation.
+ *
+ * @see https://ai.google.dev/pricing
+ */
+export declare const GEMINI_PRICING: {
+    'gemini-1.5-flash': {
+        input: number;
+        output: number;
+    };
+};
+/**
+ * The model to use for price estimation.
+ */
+export declare const GEMINI_MODEL_FOR_ESTIMATION = "gemini-1.5-flash";
+/**
+ * Gemini pricing entry per 1 million tokens.
+ */
+export type GeminiPricing = {
+    input: number;
+    output: number;
+};
+/**
+ * Resolves Gemini pricing for the requested model.
+ *
+ * It first tries exact match, then prefix match, then falls back to a stable
+ * default pricing model.
+ */
+export declare function resolveGeminiPricing(modelName?: string): GeminiPricing;
+/**
+ * A an estimation of how many characters are in one token.
+ */
+export declare const CHARS_PER_TOKEN = 4;

package/umd/scripts/run-codex-prompts/runners/gemini/parseGeminiUsageFromOutput.d.ts

@@ -0,0 +1,9 @@
+import type { Usage } from '../../../../src/execution/Usage';
+/**
+ * Parses Gemini CLI output and extracts usage information.
+ *
+ * @param output The output from the Gemini CLI.
+ * @param prompt The prompt that was sent to the Gemini CLI.
+ * @param modelName The Gemini model used for this run.
+ */
+export declare function parseGeminiUsageFromOutput(output: string, prompt: string, modelName?: string): Usage;

package/umd/scripts/run-codex-prompts/runners/github-copilot/GitHubCopilotRunner.d.ts

@@ -0,0 +1,19 @@
+import type { PromptRunner } from '../types/PromptRunner';
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { GitHubCopilotRunnerOptions } from './GitHubCopilotRunnerOptions';
+/**
+ * Runs prompts via the GitHub Copilot CLI.
+ */
+export declare class GitHubCopilotRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "github-copilot";
+    /**
+     * Creates a new GitHub Copilot runner.
+     */
+    constructor(options: GitHubCopilotRunnerOptions);
+    /**
+     * Runs the prompt using GitHub Copilot CLI.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/umd/scripts/run-codex-prompts/runners/github-copilot/buildGitHubCopilotScript.d.ts

@@ -0,0 +1,5 @@
+import type { GitHubCopilotScriptOptions } from './GitHubCopilotScriptOptions';
+/**
+ * Builds the shell script that runs GitHub Copilot CLI with the prompt and coding context.
+ */
+export declare function buildGitHubCopilotScript(options: GitHubCopilotScriptOptions): string;

package/umd/scripts/run-codex-prompts/runners/openai-codex/CodexFailureHandling.d.ts

@@ -0,0 +1,21 @@
+import { NotAllowed } from '../../../../src/errors/NotAllowed';
+/**
+ * Failure category used by OpenAI Codex retry/fail-fast handling.
+ */
+export type CodexFailureKind = 'credits-required' | 'rate-limit' | 'other';
+/**
+ * Classifies one Codex failure message into retry/fail-fast categories.
+ */
+export declare function classifyCodexFailure(details: string): CodexFailureKind;
+/**
+ * Builds a fail-fast error for cases where credit spending is disallowed.
+ */
+export declare function buildCreditsDisallowedError(details: string): NotAllowed;
+/**
+ * Extracts a text description from unknown thrown values.
+ */
+export declare function extractCodexFailureDetails(error: unknown): string;
+/**
+ * Trims very long CLI error output to keep logs and thrown messages readable.
+ */
+export declare function limitErrorDetails(details: string, maxChars?: number): string;

package/umd/scripts/run-codex-prompts/runners/openai-codex/OpenAiCodexRunner.d.ts

@@ -0,0 +1,20 @@
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { PromptRunner } from '../types/PromptRunner';
+import type { OpenAiCodexRunnerOptions } from './OpenAiCodexRunnerOptions';
+/**
+ * Runs prompts via the OpenAI Codex CLI.
+ */
+export declare class OpenAiCodexRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "codex";
+    private readonly rateLimitBackoff;
+    /**
+     * Creates a new Codex runner.
+     */
+    constructor(options: OpenAiCodexRunnerOptions);
+    /**
+     * Runs the Codex prompt in a temporary script and waits for completion output.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/umd/scripts/run-codex-prompts/runners/openai-codex/buildCodexScript.d.ts

@@ -0,0 +1,5 @@
+import type { CodexScriptOptions } from './CodexScriptOptions';
+/**
+ * Builds the shell script that runs Codex with the prompt and coding context.
+ */
+export declare function buildCodexScript(options: CodexScriptOptions): string;

package/umd/scripts/run-codex-prompts/runners/openai-codex/buildCodexUsageFromOutput.d.ts

@@ -0,0 +1,10 @@
+import type { Usage } from '../../../../src/execution/Usage';
+/**
+ * Heuristic share of the total tokens that are expected to come from completion tokens
+ * when Codex only reports a single total value.
+ */
+export declare const DEFAULT_CODEX_COMPLETION_SHARE = 0.1;
+/**
+ * Builds usage stats from Codex CLI output.
+ */
+export declare function buildCodexUsageFromOutput(output: string, modelName: string): Usage;

package/umd/scripts/run-codex-prompts/runners/opencode/OpencodeRunner.d.ts

@@ -0,0 +1,19 @@
+import type { PromptRunOptions } from '../types/PromptRunOptions';
+import type { PromptRunResult } from '../types/PromptRunResult';
+import type { PromptRunner } from '../types/PromptRunner';
+import type { OpencodeRunnerOptions } from './OpencodeRunnerOptions';
+/**
+ * Runs prompts via the Opencode CLI.
+ */
+export declare class OpencodeRunner implements PromptRunner {
+    private readonly options;
+    readonly name = "opencode";
+    /**
+     * Creates a new Opencode runner.
+     */
+    constructor(options: OpencodeRunnerOptions);
+    /**
+     * Runs the prompt using Opencode and parses usage output.
+     */
+    runPrompt(options: PromptRunOptions): Promise<PromptRunResult>;
+}

package/umd/scripts/run-codex-prompts/runners/opencode/buildOpencodeScript.d.ts

@@ -0,0 +1,5 @@
+import type { OpencodeScriptOptions } from './OpencodeScriptOptions';
+/**
+ * Builds the shell script that runs Opencode with the prompt and coding context.
+ */
+export declare function buildOpencodeScript(options: OpencodeScriptOptions): string;

package/umd/scripts/run-codex-prompts/runners/opencode/parseOpencodeJsonOutput.d.ts

@@ -0,0 +1,5 @@
+import type { Usage } from '../../../../src/execution/Usage';
+/**
+ * Parses Opencode JSON output and extracts usage information.
+ */
+export declare function parseOpencodeJsonOutput(output: string): Usage;

package/umd/src/_packages/components.index.d.ts

@@ -12,6 +12,7 @@ import type { BookEditorUploadProgressCallback } from '../book-components/BookEd
 import type { BookEditorUploadOptions } from '../book-components/BookEditor/BookEditor';
 import type { BookEditorProps } from '../book-components/BookEditor/BookEditor';
 import { BookEditor } from '../book-components/BookEditor/BookEditor';
+import { BookEditorForClient } from '../book-components/BookEditor/BookEditorForClient';
 import { AgentChat } from '../book-components/Chat/AgentChat/AgentChat';
 import type { AgentChatProps } from '../book-components/Chat/AgentChat/AgentChatProps';
 import { Chat } from '../book-components/Chat/Chat/Chat';
@@ -65,6 +66,7 @@ import type { ChatProgressCard } from '../book-components/Chat/types/ChatMessage
 import type { ChatMessageReplyingTo } from '../book-components/Chat/types/ChatMessage';
 import type { ChatMessage } from '../book-components/Chat/types/ChatMessage';
 import type { ChatParticipant } from '../book-components/Chat/types/ChatParticipant';
+import type { CitationLabelResolver } from '../book-components/Chat/types/CitationLabelResolver';
 import type { MessageButton } from '../book-components/Chat/utils/parseMessageButtons';
 import { parseMessageButtons } from '../book-components/Chat/utils/parseMessageButtons';
 import { ArrowIcon } from '../book-components/icons/ArrowIcon';
@@ -95,6 +97,7 @@ export type { BookEditorUploadProgressCallback };
 export type { BookEditorUploadOptions };
 export type { BookEditorProps };
 export { BookEditor };
+export { BookEditorForClient };
 export { AgentChat };
 export type { AgentChatProps };
 export { Chat };
@@ -148,6 +151,7 @@ export type { ChatProgressCard };
 export type { ChatMessageReplyingTo };
 export type { ChatMessage };
 export type { ChatParticipant };
+export type { CitationLabelResolver };
 export type { MessageButton };
 export { parseMessageButtons };
 export { ArrowIcon };

package/umd/src/_packages/core.index.d.ts

@@ -221,7 +221,6 @@ import { normalizeChatAttachments } from '../utils/chat/chatAttachments/normaliz
 import { resolveChatAttachmentContents } from '../utils/chat/chatAttachments/resolveChatAttachmentContents';
 import { aboutPromptbookInformation } from '../utils/misc/aboutPromptbookInformation';
 import { $generateBookBoilerplate } from '../utils/random/$generateBookBoilerplate';
-import { CORE_AGENTS_SERVER } from '../../servers';
 import { CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES } from '../../servers';
 import { PUBLIC_AGENTS_SERVERS } from '../../servers';
 export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION };
@@ -447,6 +446,5 @@ export { normalizeChatAttachments };
 export { resolveChatAttachmentContents };
 export { aboutPromptbookInformation };
 export { $generateBookBoilerplate };
-export { CORE_AGENTS_SERVER };
 export { CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES };
 export { PUBLIC_AGENTS_SERVERS };

package/umd/src/_packages/node.index.d.ts

@@ -1,4 +1,24 @@
 import { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION } from '../version';
+import { AGENT_BOOK_FILE_PATH } from '../book-3.0/agentFolderPaths';
+import { AGENT_MESSAGES_DIRECTORY_PATH } from '../book-3.0/agentFolderPaths';
+import { AGENT_QUEUED_MESSAGES_DIRECTORY_PATH } from '../book-3.0/agentFolderPaths';
+import { AGENT_FINISHED_MESSAGES_DIRECTORY_PATH } from '../book-3.0/agentFolderPaths';
+import { AGENT_FAILED_MESSAGES_DIRECTORY_PATH } from '../book-3.0/agentFolderPaths';
+import type { BookNodeAgentSource } from '../book-3.0/BookNodeAgentSource';
+import type { BookNodeAgentSourceOptions } from '../book-3.0/BookNodeAgentSource';
+import type { CliAgentHarness } from '../book-3.0/CliAgent';
+import type { CliAgentThinkingLevel } from '../book-3.0/CliAgent';
+import type { CliAgentRunOptions } from '../book-3.0/CliAgent';
+import type { CliAgentOptions } from '../book-3.0/CliAgent';
+import { CliAgent } from '../book-3.0/CliAgent';
+import { CLI_AGENT_HARNESS_NAMES } from '../book-3.0/cliAgentEnv';
+import { CLI_AGENT_THINKING_LEVEL_VALUES } from '../book-3.0/cliAgentEnv';
+import { PTBK_HARNESS_ENV } from '../book-3.0/cliAgentEnv';
+import { PTBK_MODEL_ENV } from '../book-3.0/cliAgentEnv';
+import { PTBK_THINKING_LEVEL_ENV } from '../book-3.0/cliAgentEnv';
+import type { LiteAgentOptions } from '../book-3.0/LiteAgent';
+import type { LiteAgentRunOptions } from '../book-3.0/LiteAgent';
+import { LiteAgent } from '../book-3.0/LiteAgent';
 import { createPipelineCollectionFromDirectory } from '../collection/pipeline-collection/constructors/createPipelineCollectionFromDirectory';
 import { getAllCommitmentsToolFunctionsForNode } from '../commitments/_common/getAllCommitmentsToolFunctionsForNode';
 import { $provideExecutablesForNode } from '../executables/$provideExecutablesForNode';
@@ -12,6 +32,26 @@ import { FileCacheStorage } from '../storage/file-cache-storage/FileCacheStorage
 import { $execCommand } from '../utils/execCommand/$execCommand';
 import { $execCommands } from '../utils/execCommand/$execCommands';
 export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION };
+export { AGENT_BOOK_FILE_PATH };
+export { AGENT_MESSAGES_DIRECTORY_PATH };
+export { AGENT_QUEUED_MESSAGES_DIRECTORY_PATH };
+export { AGENT_FINISHED_MESSAGES_DIRECTORY_PATH };
+export { AGENT_FAILED_MESSAGES_DIRECTORY_PATH };
+export type { BookNodeAgentSource };
+export type { BookNodeAgentSourceOptions };
+export type { CliAgentHarness };
+export type { CliAgentThinkingLevel };
+export type { CliAgentRunOptions };
+export type { CliAgentOptions };
+export { CliAgent };
+export { CLI_AGENT_HARNESS_NAMES };
+export { CLI_AGENT_THINKING_LEVEL_VALUES };
+export { PTBK_HARNESS_ENV };
+export { PTBK_MODEL_ENV };
+export { PTBK_THINKING_LEVEL_ENV };
+export type { LiteAgentOptions };
+export type { LiteAgentRunOptions };
+export { LiteAgent };
 export { createPipelineCollectionFromDirectory };
 export { getAllCommitmentsToolFunctionsForNode };
 export { $provideExecutablesForNode };