@promptbook/google 0.112.0-71 → 0.112.0-73

package/umd/src/conversion/pipelineJsonToString/createPipelineIntroduction.d.ts

@@ -0,0 +1,8 @@
+import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
+import type { string_markdown } from '../../types/string_markdown';
+/**
+ * Creates the initial markdown heading and description of a pipeline.
+ *
+ * @private internal utility of `pipelineJsonToString`
+ */
+export declare function createPipelineIntroduction(pipelineJson: PipelineJson): string_markdown;

package/umd/src/conversion/pipelineJsonToString/createTaskSerialization.d.ts

@@ -0,0 +1,23 @@
+import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
+/**
+ * Code fence language used when stringifying a pipeline task.
+ *
+ * @private internal type of `createTaskSerialization`
+ */
+type PipelineTaskContentLanguage = 'markdown' | 'text' | 'javascript' | 'typescript' | 'python' | '';
+/**
+ * All derived serialization details needed to render one task section.
+ *
+ * @private internal type of `createTaskSerialization`
+ */
+type TaskSerialization = {
+    readonly commands: Array<string>;
+    readonly contentLanguage: PipelineTaskContentLanguage;
+};
+/**
+ * Collects all task-specific serialization details.
+ *
+ * @private internal utility of `pipelineJsonToString`
+ */
+export declare function createTaskSerialization(task: TaskJson): TaskSerialization;
+export {};

package/umd/src/conversion/pipelineJsonToString/stringifyCommands.d.ts

@@ -0,0 +1,7 @@
+import type { string_markdown } from '../../types/string_markdown';
+/**
+ * Renders commands as markdown bullet items.
+ *
+ * @private internal utility of `pipelineJsonToString`
+ */
+export declare function stringifyCommands(commands: ReadonlyArray<string>): string_markdown;

package/umd/src/conversion/pipelineJsonToString/stringifyTask.d.ts

@@ -0,0 +1,8 @@
+import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
+import type { string_markdown } from '../../types/string_markdown';
+/**
+ * Stringifies one task section of the pipeline.
+ *
+ * @private internal utility of `pipelineJsonToString`
+ */
+export declare function stringifyTask(task: TaskJson): string_markdown;

package/umd/src/conversion/pipelineJsonToString.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/src/execution/createPipelineExecutor/executeSingleAttempt.d.ts

@@ -0,0 +1,31 @@
+import type { string_parameter_name } from '../../types/string_name';
+import type { LlmExecutionTools } from '../LlmExecutionTools';
+import type { $OngoingTaskResult } from './$OngoingTaskResult';
+import type { ExecuteAttemptsOptions } from './40-executeAttempts';
+/**
+ * Executes one loop iteration, from joker resolution or task execution through validation.
+ *
+ * @private function of `executeAttempts`
+ */
+export declare function executeSingleAttempt(options: {
+    /**
+     * Metadata describing the current loop iteration.
+     */
+    readonly attempt: {
+        readonly attemptIndex: number;
+        readonly isJokerAttempt: boolean;
+        readonly jokerParameterName?: string_parameter_name;
+    };
+    /**
+     * Immutable executor options shared across all attempts.
+     */
+    readonly options: ExecuteAttemptsOptions;
+    /**
+     * Narrowed LLM execution tools for prompt tasks.
+     */
+    readonly llmTools: LlmExecutionTools;
+    /**
+     * Mutable per-task state accumulated across attempts.
+     */
+    readonly $ongoingTaskResult: $OngoingTaskResult;
+}): Promise<void>;

package/umd/src/execution/createPipelineExecutor/handleAttemptFailure.d.ts

@@ -0,0 +1,40 @@
+import type { PartialDeep, Promisable } from 'type-fest';
+import { ExpectError } from '../../errors/ExpectError';
+import type { PipelineExecutorResult } from '../PipelineExecutorResult';
+import type { $OngoingTaskResult } from './$OngoingTaskResult';
+/**
+ * Stores one failed attempt, reports the expectation error, and throws the aggregated retry error after the final
+ * regular attempt.
+ *
+ * @private function of `executeAttempts`
+ */
+export declare function handleAttemptFailure(options: {
+    /**
+     * Expectation error raised by the current attempt.
+     */
+    readonly error: ExpectError;
+    /**
+     * Zero-based attempt index for the current execution loop.
+     */
+    readonly attemptIndex: number;
+    /**
+     * Maximum number of attempts for the current task type.
+     */
+    readonly maxAttempts: number;
+    /**
+     * Maximum number of model execution attempts for prompt tasks.
+     */
+    readonly maxExecutionAttempts: number;
+    /**
+     * Callback invoked with partial progress updates.
+     */
+    onProgress(newOngoingResult: PartialDeep<PipelineExecutorResult>): Promisable<void>;
+    /**
+     * String identifier for the pipeline, used for error reporting.
+     */
+    readonly pipelineIdentification: string;
+    /**
+     * Mutable per-task execution state.
+     */
+    readonly $ongoingTaskResult: $OngoingTaskResult;
+}): void;

package/umd/src/execution/createPipelineExecutor/reportPromptExecution.d.ts

@@ -0,0 +1,34 @@
+import type { Promisable, ReadonlyDeep, WritableDeep } from 'type-fest';
+import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
+import type { LlmCall } from '../../types/LlmCall';
+import type { ExecutionReportJson } from '../execution-report/ExecutionReportJson';
+import type { $OngoingTaskResult } from './$OngoingTaskResult';
+/**
+ * Appends the prompt execution report for prompt-task attempts.
+ *
+ * @private function of `executeAttempts`
+ */
+export declare function reportPromptExecution(options: {
+    /**
+     * Metadata describing the current loop iteration.
+     */
+    readonly attempt: {
+        readonly isJokerAttempt: boolean;
+    };
+    /**
+     * Task currently being executed.
+     */
+    readonly task: ReadonlyDeep<TaskJson>;
+    /**
+     * Mutable execution report object to append prompt execution data to.
+     */
+    readonly $executionReport: WritableDeep<ExecutionReportJson>;
+    /**
+     * Optional callback invoked with each LLM call.
+     */
+    logLlmCall?(llmCall: LlmCall): Promisable<void>;
+    /**
+     * Mutable per-task execution state.
+     */
+    readonly $ongoingTaskResult: $OngoingTaskResult;
+}): void;

package/umd/src/execution/resolveTaskTldr.d.ts

@@ -0,0 +1,32 @@
+import type { number_percent } from '../types/number_percent';
+import type { chococake } from '../utils/organization/really_any';
+import type { task_status } from './ExecutionTask';
+/**
+ * Shared type for task TLDR information.
+ *
+ * @private internal type of `ExecutionTask`
+ */
+type TaskTldrInfo = {
+    readonly percent: number_percent;
+    readonly message: string;
+};
+/**
+ * Snapshot of the mutable task state needed to resolve the fallback TLDR.
+ *
+ * @private internal type of `ExecutionTask`
+ */
+type ResolveTaskTldrOptions = {
+    readonly customTldr: TaskTldrInfo | null;
+    readonly currentValue: chococake;
+    readonly status: task_status;
+    readonly createdAt: Date;
+    readonly errors: ReadonlyArray<Error>;
+    readonly warnings: ReadonlyArray<Error>;
+};
+/**
+ * Resolves the short task summary shown in the UI.
+ *
+ * @private internal helper function of `ExecutionTask`
+ */
+export declare function resolveTaskTldr(options: ResolveTaskTldrOptions): TaskTldrInfo;
+export {};

package/umd/src/execution/resolveTaskTldr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/src/llm-providers/agent/AgentLlmExecutionTools.d.ts

@@ -27,50 +27,49 @@ import type { CreateAgentLlmExecutionToolsOptions } from './CreateAgentLlmExecut
 export declare class AgentLlmExecutionTools implements LlmExecutionTools {
     protected readonly options: CreateAgentLlmExecutionToolsOptions;
     /**
-     * Cached AgentKit agents to avoid rebuilding identical instances.
+     * Cached model requirements to avoid re-parsing the agent source.
      */
-    private static agentKitAgentCache;
+    private _cachedModelRequirements;
     /**
-     * Cache of OpenAI assistants to avoid creating duplicates
+     * Cached parsed agent information.
      */
-    private static assistantCache;
+    private _cachedAgentInfo;
     /**
-     * Cache of OpenAI vector stores to avoid creating duplicates
+     * Optional server-precomputed model requirements reused until the source changes.
      */
-    private static vectorStoreCache;
+    private precomputedModelRequirements;
     /**
-     * Cached model requirements to avoid re-parsing the agent source
+     * Dedicated prompt preparation facade used before backend dispatch.
      */
-    private _cachedModelRequirements;
+    private readonly promptPreparer;
     /**
-     * Cached parsed agent information
+     * Dedicated OpenAI AgentKit runner used when the wrapped tools support AgentKit preparation.
      */
-    private _cachedAgentInfo;
+    private readonly agentKitRunner;
     /**
-     * Optional server-precomputed model requirements reused until the source changes.
+     * Dedicated OpenAI Assistant runner used when the wrapped tools use Assistants.
      */
-    private precomputedModelRequirements;
+    private readonly openAiAssistantRunner;
     /**
-     * Creates new AgentLlmExecutionTools
+     * Creates new AgentLlmExecutionTools.
      *
-     * @param llmTools The underlying LLM execution tools to wrap
-     * @param agentSource The agent source string that defines the agent's behavior
+     * @param options - The underlying LLM tools and agent source configuration.
      */
     constructor(options: CreateAgentLlmExecutionToolsOptions);
     /**
-     * Updates the agent source and clears the cache
+     * Updates the agent source and clears the cache.
      *
-     * @param agentSource The new agent source string
+     * @param agentSource - The new agent source string.
      */
     protected updateAgentSource(agentSource: string_book): void;
     /**
-     * Get cached or parse agent information
+     * Returns cached or parsed agent information.
      */
     private getAgentInfo;
     /**
-     * Get cached or create agent model requirements
+     * Returns cached or compiled agent model requirements.
      *
-     * Note: [🐤] This is names `getModelRequirements` *(not `getAgentModelRequirements`)* because in future these two will be united
+     * Note: [🐤] This is named `getModelRequirements` *(not `getAgentModelRequirements`)* because in future these two will be united.
      */
     getModelRequirements(): Promise<AgentModelRequirements>;
     get title(): string_title & string_markdown_text;
@@ -78,62 +77,22 @@ export declare class AgentLlmExecutionTools implements LlmExecutionTools {
     get profile(): ChatParticipant | undefined;
     checkConfiguration(): Promisable<void>;
     /**
-     * Returns a virtual model name representing the agent behavior
+     * Returns a virtual model name representing the agent behavior.
      */
     get modelName(): string_model_name;
     listModels(): Promisable<ReadonlyArray<AvailableModel>>;
     /**
-     * Calls the chat model with agent-specific system prompt and requirements
+     * Calls the chat model with agent-specific system prompt and requirements.
      */
     callChatModel(prompt: Prompt): Promise<ChatPromptResult>;
     /**
-     * Calls the chat model with agent-specific system prompt and requirements with streaming
+     * Calls the chat model with agent-specific system prompt and requirements with streaming.
      */
     callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
-    /**
-     * Ensures the agent wrapper only processes chat prompts.
-     */
-    private requireChatPrompt;
-    /**
-     * Resolves agent requirements, attachments, and runtime overrides into one forwarded chat prompt.
-     */
-    private prepareChatPrompt;
-    /**
-     * Removes bookkeeping-only properties from compiled agent requirements before forwarding them.
-     */
-    private getSanitizedAgentModelRequirements;
     /**
      * Dispatches one prepared agent prompt to the correct underlying LLM backend.
      */
     private callPreparedChatModelStream;
-    /**
-     * Runs one prepared prompt through the OpenAI AgentKit backend.
-     */
-    private callOpenAiAgentKitChatModelStream;
-    /**
-     * Resolves the AgentKit cache state for the current prompt, including external and in-memory caches.
-     */
-    private resolveAgentKitCacheState;
-    /**
-     * Returns a prepared AgentKit agent, creating one only when the cache could not satisfy the request.
-     */
-    private getOrPrepareAgentKitAgent;
-    /**
-     * Stores freshly prepared AgentKit resources back into the in-memory caches when caching is allowed.
-     */
-    private storeAgentKitCache;
-    /**
-     * Runs one prepared prompt through the deprecated OpenAI Assistant backend.
-     */
-    private callOpenAiAssistantChatModelStream;
-    /**
-     * Returns an assistant instance matching the current agent requirements, reusing caches when possible.
-     */
-    private getOrPrepareOpenAiAssistant;
-    /**
-     * Stores one assistant id in the shared assistant cache for this agent title.
-     */
-    private storeAssistantCache;
     /**
      * Runs one prepared prompt through generic LLM tools that do not need special assistant preparation.
      */

package/umd/src/llm-providers/agent/AgentLlmExecutionToolsAgentKitRunner.d.ts

@@ -0,0 +1,51 @@
+import type { CallChatModelStreamOptions } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult, CommonPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_model_name } from '../../types/string_model_name';
+import type { string_title } from '../../types/string_title';
+import { OpenAiAgentKitExecutionTools } from '../openai/OpenAiAgentKitExecutionTools';
+import type { AgentLlmExecutionToolsPromptPreparer } from './AgentLlmExecutionToolsPromptPreparer';
+/**
+ * Handles OpenAI AgentKit-backed executions for `AgentLlmExecutionTools`.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare class AgentLlmExecutionToolsAgentKitRunner {
+    private readonly context;
+    /**
+     * Cached AgentKit agents to avoid rebuilding identical instances.
+     */
+    private static agentKitAgentCache;
+    /**
+     * Cache of OpenAI vector stores to avoid creating duplicates.
+     */
+    private static vectorStoreCache;
+    constructor(context: {
+        readonly getTitle: () => string_title;
+        readonly getModelName: () => string_model_name;
+        readonly isVerbose?: boolean;
+        readonly assistantPreparationMode?: 'internal' | 'external';
+    });
+    /**
+     * Runs one prepared prompt through the OpenAI AgentKit backend.
+     */
+    callChatModelStream(options: {
+        readonly llmTools: OpenAiAgentKitExecutionTools;
+        readonly originalPrompt: Prompt;
+        readonly preparedChatPrompt: Awaited<ReturnType<AgentLlmExecutionToolsPromptPreparer['prepareChatPrompt']>>;
+        readonly onProgress: (chunk: ChatPromptResult) => void;
+        readonly streamOptions?: CallChatModelStreamOptions;
+    }): Promise<CommonPromptResult>;
+    /**
+     * Resolves the AgentKit cache state for the current prompt, including external and in-memory caches.
+     */
+    private resolveAgentKitCacheState;
+    /**
+     * Returns a prepared AgentKit agent, creating one only when the cache could not satisfy the request.
+     */
+    private getOrPrepareAgentKitAgent;
+    /**
+     * Stores freshly prepared AgentKit resources back into the in-memory caches when caching is allowed.
+     */
+    private storeAgentKitCache;
+}

package/umd/src/llm-providers/agent/AgentLlmExecutionToolsOpenAiAssistantRunner.d.ts

@@ -0,0 +1,43 @@
+import type { CallChatModelStreamOptions } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult, CommonPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_model_name } from '../../types/string_model_name';
+import type { string_title } from '../../types/string_title';
+import { OpenAiAssistantExecutionTools } from '../openai/OpenAiAssistantExecutionTools';
+import type { AgentLlmExecutionToolsPromptPreparer } from './AgentLlmExecutionToolsPromptPreparer';
+/**
+ * Handles deprecated OpenAI Assistant-backed executions for `AgentLlmExecutionTools`.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare class AgentLlmExecutionToolsOpenAiAssistantRunner {
+    private readonly context;
+    /**
+     * Cache of OpenAI assistants to avoid creating duplicates.
+     */
+    private static assistantCache;
+    constructor(context: {
+        readonly getTitle: () => string_title;
+        readonly getModelName: () => string_model_name;
+        readonly isVerbose?: boolean;
+        readonly assistantPreparationMode?: 'internal' | 'external';
+    });
+    /**
+     * Runs one prepared prompt through the deprecated OpenAI Assistant backend.
+     */
+    callChatModelStream(options: {
+        readonly llmTools: OpenAiAssistantExecutionTools;
+        readonly originalPrompt: Prompt;
+        readonly preparedChatPrompt: Awaited<ReturnType<AgentLlmExecutionToolsPromptPreparer['prepareChatPrompt']>>;
+        readonly onProgress: (chunk: ChatPromptResult) => void;
+        readonly streamOptions?: CallChatModelStreamOptions;
+    }): Promise<CommonPromptResult>;
+    /**
+     * Returns an assistant instance matching the current agent requirements, reusing caches when possible.
+     */
+    private getOrPrepareOpenAiAssistant;
+    /**
+     * Stores one assistant id in the shared assistant cache for this agent title.
+     */
+    private storeAssistantCache;
+}

package/umd/src/llm-providers/agent/AgentLlmExecutionToolsPromptPreparer.d.ts

@@ -0,0 +1,41 @@
+import type { AgentModelRequirements } from '../../book-2.0/agent-source/AgentModelRequirements';
+import type { ChatPrompt, Prompt } from '../../types/Prompt';
+import type { string_title } from '../../types/string_title';
+/**
+ * Agent model requirements stripped of prompt-only bookkeeping before forwarding to runtime tools.
+ */
+type SanitizedAgentModelRequirements = Omit<AgentModelRequirements, '_metadata' | 'promptSuffix'>;
+/**
+ * Resolves runtime prompts into the fully enriched prompt shape forwarded by `AgentLlmExecutionTools`.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare class AgentLlmExecutionToolsPromptPreparer {
+    private readonly context;
+    constructor(context: {
+        readonly getModelRequirements: () => Promise<AgentModelRequirements>;
+        readonly getTitle: () => string_title;
+        readonly isVerbose?: boolean;
+        readonly hasPrecomputedModelRequirements: () => boolean;
+    });
+    /**
+     * Resolves agent requirements, attachments, and runtime overrides into one forwarded chat prompt.
+     */
+    prepareChatPrompt(prompt: Prompt): Promise<{
+        readonly forwardedPrompt: ChatPrompt;
+        readonly sanitizedRequirements: SanitizedAgentModelRequirements;
+        readonly mergedTools: Array<NonNullable<ChatPrompt['tools']>[number]>;
+        readonly knowledgeSourcesForAgent?: Array<string>;
+        readonly hasAttachmentSources: boolean;
+        readonly hasRuntimePromptTools: boolean;
+    }>;
+    /**
+     * Removes bookkeeping-only properties from compiled agent requirements before forwarding them.
+     */
+    private getSanitizedAgentModelRequirements;
+    /**
+     * Ensures the agent wrapper only processes chat prompts.
+     */
+    private requireChatPrompt;
+}
+export {};

package/umd/src/llm-providers/agent/emitAgentLlmExecutionToolsAssistantPreparationProgress.d.ts

@@ -0,0 +1,26 @@
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_model_name } from '../../types/string_model_name';
+/**
+ * Emits a progress update to signal assistant preparation before long setup work.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare function emitAgentLlmExecutionToolsAssistantPreparationProgress(options: {
+    /**
+     * Callback to send progress updates to the caller.
+     */
+    readonly onProgress: (chunk: ChatPromptResult) => void;
+    /**
+     * Original prompt being executed.
+     */
+    readonly prompt: Prompt;
+    /**
+     * Model name used for the update payload.
+     */
+    readonly modelName: string_model_name;
+    /**
+     * Optional detail describing the current preparation phase.
+     */
+    readonly phase?: string;
+}): void;

package/umd/src/llm-providers/openai/OpenAiAgentKitExecutionTools.d.ts

@@ -1,60 +1,13 @@
 import { Agent as AgentFromKit } from '@openai/agents';
-import OpenAI from 'openai';
 import type { CallChatModelStreamOptions, LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { ChatPromptResult } from '../../execution/PromptResult';
 import type { ModelRequirements } from '../../types/ModelRequirements';
 import type { Prompt } from '../../types/Prompt';
 import type { string_markdown, string_markdown_text } from '../../types/string_markdown';
 import type { string_title } from '../../types/string_title';
-import type { TODO_any } from '../../utils/organization/TODO_any';
 import type { OpenAiAgentKitExecutionToolsOptions } from './OpenAiAgentKitExecutionToolsOptions';
+import { OpenAiAgentKitExecutionToolsOutputTypeMapper } from './OpenAiAgentKitExecutionToolsOutputTypeMapper';
 import { OpenAiVectorStoreHandler } from './OpenAiVectorStoreHandler';
-/**
- * Represents the AgentKit output configuration used to match OpenAI `response_format` expectations.
- *
- * @private utility of Open AI
- */
-export type AgentOutputType = 'text' | JsonSchemaDefinition;
-/**
- * Type describing Json schema definition entry.
- */
-type JsonSchemaDefinitionEntry = {
-    type?: string;
-    description?: string;
-    properties?: Record<string, JsonSchemaDefinitionEntry>;
-    required?: Array<string>;
-    items?: JsonSchemaDefinitionEntry;
-    [key: string]: TODO_any;
-};
-/**
- * Definition of Json schema.
- */
-type JsonSchemaDefinition = {
-    type: 'json_schema';
-    name: string;
-    strict: boolean;
-    schema: {
-        type: 'object';
-        properties: Record<string, JsonSchemaDefinitionEntry>;
-        required: Array<string>;
-        additionalProperties: boolean;
-        description?: string;
-    };
-};
-/**
- * Type describing open Ai chat response format.
- */
-type OpenAiChatResponseFormat = OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming['response_format'];
-/**
- * Maps OpenAI `response_format` payloads to AgentKit output types so the runner can forward
- * structured-output preferences to OpenAI while still reusing the same AgentKit agent instance.
- *
- * @param responseFormat - The OpenAI `response_format` payload from the user request.
- * @returns An Agent output type compatible with the requested schema or `undefined` when no impact is required.
- *
- * @private utility of Open AI
- */
-export declare function mapResponseFormatToAgentOutputType(responseFormat?: OpenAiChatResponseFormat): AgentOutputType | undefined;
 /**
  * Alias for OpenAI AgentKit agent to avoid naming confusion with Promptbook agents.
  */
@@ -66,6 +19,10 @@ type OpenAiAgentKitPreparedAgent = {
     readonly agent: OpenAiAgentKitAgent;
     readonly vectorStoreId?: string;
 };
+/**
+ * AgentKit output type returned by the dedicated response-format mapper.
+ */
+type OpenAiAgentKitAgentOutputType = ReturnType<typeof OpenAiAgentKitExecutionToolsOutputTypeMapper.mapResponseFormatToAgentOutputType>;
 /**
  * Execution tools for OpenAI AgentKit (Agents SDK).
  *
@@ -73,9 +30,9 @@ type OpenAiAgentKitPreparedAgent = {
  */
 export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler implements LlmExecutionTools {
     private preparedAgentKitAgent;
-    private readonly agentKitToolResultsByCallId;
-    private readonly agentKitToolSnapshotsByCallId;
     private readonly agentKitModelName;
+    private readonly inputBuilder;
+    private readonly toolBuilder;
     /**
      * Creates OpenAI AgentKit execution tools.
      */
@@ -113,18 +70,6 @@ export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandl
         readonly vectorStoreId?: string;
         readonly storeAsPrepared?: boolean;
     }): Promise<OpenAiAgentKitPreparedAgent>;
-    /**
-     * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
-     */
-    private ensureAgentKitDefaults;
-    /**
-     * Builds the tool list for AgentKit, including hosted file search when applicable.
-     */
-    private buildAgentKitTools;
-    /**
-     * Resolves the configured script tools for tool execution.
-     */
-    private resolveScriptTools;
     /**
      * Runs a prepared AgentKit agent and streams results back to the caller.
      */
@@ -135,50 +80,28 @@ export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandl
         readonly onProgress: (chunk: ChatPromptResult & {
             isFinished?: boolean;
         }) => void;
-        readonly responseFormatOutputType?: AgentOutputType;
+        readonly responseFormatOutputType?: OpenAiAgentKitAgentOutputType;
         /**
          * Optional abort signal propagated from chat surfaces so stream generation can be cancelled.
          */
         readonly signal?: AbortSignal;
     }): Promise<ChatPromptResult>;
     /**
-     * Builds AgentKit input items from the prompt and optional thread.
-     */
-    private buildAgentKitInputItems;
-    /**
-     * Builds the user message content for AgentKit runs, including file inputs when provided.
-     */
-    private buildAgentKitUserContent;
-    /**
-     * Converts uploaded `File` objects into AgentKit `input_image` entries.
-     */
-    private createAgentKitInputImageItemsFromFiles;
-    /**
-     * Converts image chat attachments into AgentKit `input_image` entries.
-     *
-     * Note: This keeps images in the same completion request as multimodal input.
-     */
-    private createAgentKitInputImageItemsFromAttachments;
-    /**
-     * Builds AgentKit user content that can include text, uploaded files, and image attachments.
-     */
-    private buildAgentKitUserContentWithAttachments;
-    /**
-     * Normalizes AgentKit tool outputs into a string for Promptbook tool call results.
-     */
-    private formatAgentKitToolOutput;
-    /**
-     * Resolves the assistant-visible AgentKit tool response while preserving structured tool result data.
+     * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
      */
-    private resolveAgentKitToolResponse;
+    private ensureAgentKitDefaults;
     /**
-     * Resolves the stored Promptbook tool result for one AgentKit tool call.
+     * Builds the tool list for AgentKit while keeping the public facade small.
      */
-    private resolveAgentKitToolOutputResult;
+    private buildAgentKitTools;
     /**
      * Returns AgentKit-specific options.
      */
     private get agentKitOptions();
+    /**
+     * Formats raw prompt content with the AgentKit model injected.
+     */
+    private templatePromptContent;
     /**
      * Discriminant for type guards.
      */