@keyueclaw/web-sdk 0.1.84 → 0.1.85

package/dist/src/agents/pi-embedded-runner/run/attempt.d.ts

@@ -0,0 +1,67 @@
+import type { StreamFn } from "@mariozechner/pi-agent-core";
+import type { OpenClawConfig } from "../../../config/config.js";
+import type { PluginHookAgentContext, PluginHookBeforeAgentStartResult, PluginHookBeforePromptBuildResult } from "../../../plugins/types.js";
+import type { CompactEmbeddedPiSessionParams } from "../compact.js";
+import type { EmbeddedRunAttemptParams, EmbeddedRunAttemptResult } from "./types.js";
+type PromptBuildHookRunner = {
+    hasHooks: (hookName: "before_prompt_build" | "before_agent_start") => boolean;
+    runBeforePromptBuild: (event: {
+        prompt: string;
+        messages: unknown[];
+    }, ctx: PluginHookAgentContext) => Promise<PluginHookBeforePromptBuildResult | undefined>;
+    runBeforeAgentStart: (event: {
+        prompt: string;
+        messages: unknown[];
+    }, ctx: PluginHookAgentContext) => Promise<PluginHookBeforeAgentStartResult | undefined>;
+};
+export declare function isOllamaCompatProvider(model: {
+    provider?: string;
+    baseUrl?: string;
+    api?: string;
+}): boolean;
+export declare function resolveOllamaCompatNumCtxEnabled(params: {
+    config?: OpenClawConfig;
+    providerId?: string;
+}): boolean;
+export declare function shouldInjectOllamaCompatNumCtx(params: {
+    model: {
+        api?: string;
+        provider?: string;
+        baseUrl?: string;
+    };
+    config?: OpenClawConfig;
+    providerId?: string;
+}): boolean;
+export declare function wrapOllamaCompatNumCtx(baseFn: StreamFn | undefined, numCtx: number): StreamFn;
+export declare function wrapStreamFnTrimToolCallNames(baseFn: StreamFn, allowedToolNames?: Set<string>): StreamFn;
+export declare function wrapStreamFnRepairMalformedToolCallArguments(baseFn: StreamFn): StreamFn;
+export declare function decodeHtmlEntitiesInObject(obj: unknown): unknown;
+export declare function resolvePromptBuildHookResult(params: {
+    prompt: string;
+    messages: unknown[];
+    hookCtx: PluginHookAgentContext;
+    hookRunner?: PromptBuildHookRunner | null;
+    legacyBeforeAgentStartResult?: PluginHookBeforeAgentStartResult;
+}): Promise<PluginHookBeforePromptBuildResult>;
+export declare function composeSystemPromptWithHookContext(params: {
+    baseSystemPrompt?: string;
+    prependSystemContext?: string;
+    appendSystemContext?: string;
+}): string | undefined;
+export declare function resolvePromptModeForSession(sessionKey?: string): "minimal" | "full";
+export declare function resolveAttemptFsWorkspaceOnly(params: {
+    config?: OpenClawConfig;
+    sessionAgentId: string;
+}): boolean;
+export declare function prependSystemPromptAddition(params: {
+    systemPrompt: string;
+    systemPromptAddition?: string;
+}): string;
+/** Build runtime context passed into context-engine afterTurn hooks. */
+export declare function buildAfterTurnRuntimeContext(params: {
+    attempt: Pick<EmbeddedRunAttemptParams, "sessionKey" | "messageChannel" | "messageProvider" | "agentAccountId" | "config" | "skillsSnapshot" | "senderIsOwner" | "provider" | "modelId" | "thinkLevel" | "reasoningLevel" | "bashElevated" | "extraSystemPrompt" | "ownerNumbers" | "authProfileId">;
+    workspaceDir: string;
+    agentDir: string;
+}): Partial<CompactEmbeddedPiSessionParams>;
+export declare function runEmbeddedAttempt(params: EmbeddedRunAttemptParams): Promise<EmbeddedRunAttemptResult>;
+export {};

package/dist/src/agents/pi-embedded-runner/run/compaction-retry-aggregate-timeout.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Wait for compaction retry completion with an aggregate timeout to avoid
+ * holding a session lane indefinitely when retry resolution is lost.
+ */
+export declare function waitForCompactionRetryWithAggregateTimeout(params: {
+    waitForCompactionRetry: () => Promise<void>;
+    abortable: <T>(promise: Promise<T>) => Promise<T>;
+    aggregateTimeoutMs: number;
+    onTimeout?: () => void;
+    isCompactionStillInFlight?: () => boolean;
+}): Promise<{
+    timedOut: boolean;
+}>;

package/dist/src/agents/pi-embedded-runner/run/compaction-timeout.d.ts

@@ -0,0 +1,29 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+export type CompactionTimeoutSignal = {
+    isTimeout: boolean;
+    isCompactionPendingOrRetrying: boolean;
+    isCompactionInFlight: boolean;
+};
+export declare function shouldFlagCompactionTimeout(signal: CompactionTimeoutSignal): boolean;
+export declare function resolveRunTimeoutDuringCompaction(params: {
+    isCompactionPendingOrRetrying: boolean;
+    isCompactionInFlight: boolean;
+    graceAlreadyUsed: boolean;
+}): "extend" | "abort";
+export declare function resolveRunTimeoutWithCompactionGraceMs(params: {
+    runTimeoutMs: number;
+    compactionTimeoutMs: number;
+}): number;
+export type SnapshotSelectionParams = {
+    timedOutDuringCompaction: boolean;
+    preCompactionSnapshot: AgentMessage[] | null;
+    preCompactionSessionId: string;
+    currentSnapshot: AgentMessage[];
+    currentSessionId: string;
+};
+export type SnapshotSelection = {
+    messagesSnapshot: AgentMessage[];
+    sessionIdUsed: string;
+    source: "pre-compaction" | "current";
+};
+export declare function selectCompactionTimeoutSnapshot(params: SnapshotSelectionParams): SnapshotSelection;

package/dist/src/agents/pi-embedded-runner/run/failover-observation.d.ts

@@ -0,0 +1,20 @@
+import type { AuthProfileFailureReason } from "../../auth-profiles.js";
+import type { FailoverReason } from "../../pi-embedded-helpers.js";
+export type FailoverDecisionLoggerInput = {
+    stage: "prompt" | "assistant";
+    decision: "rotate_profile" | "fallback_model" | "surface_error";
+    runId?: string;
+    rawError?: string;
+    failoverReason: FailoverReason | null;
+    profileFailureReason?: AuthProfileFailureReason | null;
+    provider: string;
+    model: string;
+    profileId?: string;
+    fallbackConfigured: boolean;
+    timedOut?: boolean;
+    aborted?: boolean;
+    status?: number;
+};
+export type FailoverDecisionLoggerBase = Omit<FailoverDecisionLoggerInput, "decision" | "status">;
+export declare function normalizeFailoverDecisionObservationBase(base: FailoverDecisionLoggerBase): FailoverDecisionLoggerBase;
+export declare function createFailoverDecisionLogger(base: FailoverDecisionLoggerBase): (decision: FailoverDecisionLoggerInput["decision"], extra?: Pick<FailoverDecisionLoggerInput, "status">) => void;

package/dist/src/agents/pi-embedded-runner/run/history-image-prune.d.ts

@@ -0,0 +1,7 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+export declare const PRUNED_HISTORY_IMAGE_MARKER = "[image data removed - already processed by model]";
+/**
+ * Idempotent cleanup for legacy sessions that persisted image blocks in history.
+ * Called each run; mutates only user turns that already have an assistant reply.
+ */
+export declare function pruneProcessedHistoryImages(messages: AgentMessage[]): boolean;

package/dist/src/agents/pi-embedded-runner/run/images.d.ts

@@ -0,0 +1,83 @@
+import type { ImageContent } from "@mariozechner/pi-ai";
+import type { SandboxFsBridge } from "../../sandbox/fs-bridge.js";
+/**
+ * Result of detecting an image reference in text.
+ */
+export interface DetectedImageRef {
+    /** The raw matched string from the prompt */
+    raw: string;
+    /** The type of reference */
+    type: "path";
+    /** The resolved/normalized path */
+    resolved: string;
+}
+/**
+ * Detects image references in a user prompt.
+ *
+ * Patterns detected:
+ * - Absolute paths: /path/to/image.png
+ * - Relative paths: ./image.png, ../images/photo.jpg
+ * - Home paths: ~/Pictures/screenshot.png
+ * - file:// URLs: file:///path/to/image.png
+ * - Message attachments: [Image: source: /path/to/image.jpg]
+ *
+ * @param prompt The user prompt text to scan
+ * @returns Array of detected image references
+ */
+export declare function detectImageReferences(prompt: string): DetectedImageRef[];
+/**
+ * Loads an image from a file path and returns it as ImageContent.
+ *
+ * @param ref The detected image reference
+ * @param workspaceDir The current workspace directory for resolving relative paths
+ * @param options Optional settings for sandbox and size limits
+ * @returns The loaded image content, or null if loading failed
+ */
+export declare function loadImageFromRef(ref: DetectedImageRef, workspaceDir: string, options?: {
+    maxBytes?: number;
+    workspaceOnly?: boolean;
+    sandbox?: {
+        root: string;
+        bridge: SandboxFsBridge;
+    };
+}): Promise<ImageContent | null>;
+/**
+ * Checks if a model supports image input based on its input capabilities.
+ *
+ * @param model The model object with input capability array
+ * @returns True if the model supports image input
+ */
+export declare function modelSupportsImages(model: {
+    input?: string[];
+}): boolean;
+/**
+ * Detects and loads images referenced in a prompt for models with vision capability.
+ *
+ * This function scans the prompt for image references (file paths and URLs),
+ * loads them, and returns them as ImageContent array ready to be passed to
+ * the model's prompt method.
+ *
+ * @param params Configuration for image detection and loading
+ * @returns Object with loaded images for current prompt only
+ */
+export declare function detectAndLoadPromptImages(params: {
+    prompt: string;
+    workspaceDir: string;
+    model: {
+        input?: string[];
+    };
+    existingImages?: ImageContent[];
+    maxBytes?: number;
+    maxDimensionPx?: number;
+    workspaceOnly?: boolean;
+    sandbox?: {
+        root: string;
+        bridge: SandboxFsBridge;
+    };
+}): Promise<{
+    /** Images for the current prompt (existingImages + detected in current prompt) */
+    images: ImageContent[];
+    detectedRefs: DetectedImageRef[];
+    loadedCount: number;
+    skippedCount: number;
+}>;

package/dist/src/agents/pi-embedded-runner/run/params.d.ts

@@ -0,0 +1,138 @@
+import type { ImageContent } from "@mariozechner/pi-ai";
+import type { ReasoningLevel, ThinkLevel, VerboseLevel } from "../../../auto-reply/thinking.js";
+import type { ReplyPayload } from "../../../auto-reply/types.js";
+import type { OpenClawConfig } from "../../../config/config.js";
+import type { enqueueCommand } from "../../../process/command-queue.js";
+import type { InputProvenance } from "../../../sessions/input-provenance.js";
+import type { ExecElevatedDefaults, ExecToolDefaults } from "../../bash-tools.js";
+import type { AgentStreamParams } from "../../command/types.js";
+import type { BlockReplyPayload } from "../../pi-embedded-payloads.js";
+import type { BlockReplyChunking, ToolResultFormat } from "../../pi-embedded-subscribe.js";
+import type { SkillSnapshot } from "../../skills.js";
+export type ClientToolDefinition = {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+};
+export type RunEmbeddedPiAgentParams = {
+    sessionId: string;
+    sessionKey?: string;
+    agentId?: string;
+    messageChannel?: string;
+    messageProvider?: string;
+    agentAccountId?: string;
+    /** What initiated this agent run: "user", "heartbeat", "cron", or "memory". */
+    trigger?: string;
+    /** Relative workspace path that memory-triggered writes are allowed to append to. */
+    memoryFlushWritePath?: string;
+    /** Delivery target (e.g. telegram:group:123:topic:456) for topic/thread routing. */
+    messageTo?: string;
+    /** Thread/topic identifier for routing replies to the originating thread. */
+    messageThreadId?: string | number;
+    /** Group id for channel-level tool policy resolution. */
+    groupId?: string | null;
+    /** Group channel label (e.g. #general) for channel-level tool policy resolution. */
+    groupChannel?: string | null;
+    /** Group space label (e.g. guild/team id) for channel-level tool policy resolution. */
+    groupSpace?: string | null;
+    /** Parent session key for subagent policy inheritance. */
+    spawnedBy?: string | null;
+    senderId?: string | null;
+    senderName?: string | null;
+    senderUsername?: string | null;
+    senderE164?: string | null;
+    /** Whether the sender is an owner (required for owner-only tools). */
+    senderIsOwner?: boolean;
+    /** Current channel ID for auto-threading (Slack). */
+    currentChannelId?: string;
+    /** Current thread timestamp for auto-threading (Slack). */
+    currentThreadTs?: string;
+    /** Current inbound message id for action fallbacks (e.g. Telegram react). */
+    currentMessageId?: string | number;
+    /** Reply-to mode for Slack auto-threading. */
+    replyToMode?: "off" | "first" | "all";
+    /** Mutable ref to track if a reply was sent (for "first" mode). */
+    hasRepliedRef?: {
+        value: boolean;
+    };
+    /** Require explicit message tool targets (no implicit last-route sends). */
+    requireExplicitMessageTarget?: boolean;
+    /** If true, omit the message tool from the tool list. */
+    disableMessageTool?: boolean;
+    /** Allow runtime plugins for this run to late-bind the gateway subagent. */
+    allowGatewaySubagentBinding?: boolean;
+    sessionFile: string;
+    workspaceDir: string;
+    agentDir?: string;
+    config?: OpenClawConfig;
+    skillsSnapshot?: SkillSnapshot;
+    prompt: string;
+    images?: ImageContent[];
+    /** Optional client-provided tools (OpenResponses hosted tools). */
+    clientTools?: ClientToolDefinition[];
+    /** Disable built-in tools for this run (LLM-only mode). */
+    disableTools?: boolean;
+    provider?: string;
+    model?: string;
+    authProfileId?: string;
+    authProfileIdSource?: "auto" | "user";
+    thinkLevel?: ThinkLevel;
+    fastMode?: boolean;
+    verboseLevel?: VerboseLevel;
+    reasoningLevel?: ReasoningLevel;
+    toolResultFormat?: ToolResultFormat;
+    /** If true, suppress tool error warning payloads for this run (including mutating tools). */
+    suppressToolErrorWarnings?: boolean;
+    /** Bootstrap context mode for workspace file injection. */
+    bootstrapContextMode?: "full" | "lightweight";
+    /** Run kind hint for context mode behavior. */
+    bootstrapContextRunKind?: "default" | "heartbeat" | "cron";
+    /** Seen bootstrap truncation warning signatures for this session (once mode dedupe). */
+    bootstrapPromptWarningSignaturesSeen?: string[];
+    /** Last shown bootstrap truncation warning signature for this session. */
+    bootstrapPromptWarningSignature?: string;
+    execOverrides?: Pick<ExecToolDefaults, "host" | "security" | "ask" | "node">;
+    bashElevated?: ExecElevatedDefaults;
+    timeoutMs: number;
+    runId: string;
+    abortSignal?: AbortSignal;
+    shouldEmitToolResult?: () => boolean;
+    shouldEmitToolOutput?: () => boolean;
+    onPartialReply?: (payload: {
+        text?: string;
+        mediaUrls?: string[];
+    }) => void | Promise<void>;
+    onAssistantMessageStart?: () => void | Promise<void>;
+    onBlockReply?: (payload: BlockReplyPayload) => void | Promise<void>;
+    onBlockReplyFlush?: () => void | Promise<void>;
+    blockReplyBreak?: "text_end" | "message_end";
+    blockReplyChunking?: BlockReplyChunking;
+    onReasoningStream?: (payload: {
+        text?: string;
+        mediaUrls?: string[];
+    }) => void | Promise<void>;
+    onReasoningEnd?: () => void | Promise<void>;
+    onToolResult?: (payload: ReplyPayload) => void | Promise<void>;
+    onAgentEvent?: (evt: {
+        stream: string;
+        data: Record<string, unknown>;
+    }) => void;
+    lane?: string;
+    enqueue?: typeof enqueueCommand;
+    extraSystemPrompt?: string;
+    inputProvenance?: InputProvenance;
+    streamParams?: AgentStreamParams;
+    ownerNumbers?: string[];
+    enforceFinalTag?: boolean;
+    /**
+     * Allow a single run attempt even when all auth profiles are in cooldown,
+     * but only for inferred transient cooldowns like `rate_limit` or `overloaded`.
+     *
+     * This is used by model fallback when trying sibling models on providers
+     * where transient service pressure is often model-scoped.
+     */
+    allowTransientCooldownProbe?: boolean;
+};

package/dist/src/agents/pi-embedded-runner/run/payloads.d.ts

@@ -0,0 +1,43 @@
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { ReasoningLevel, VerboseLevel } from "../../../auto-reply/thinking.js";
+import type { OpenClawConfig } from "../../../config/config.js";
+import type { ToolResultFormat } from "../../pi-embedded-subscribe.js";
+type ToolMetaEntry = {
+    toolName: string;
+    meta?: string;
+};
+type LastToolError = {
+    toolName: string;
+    meta?: string;
+    error?: string;
+    mutatingAction?: boolean;
+    actionFingerprint?: string;
+};
+export declare function buildEmbeddedRunPayloads(params: {
+    assistantTexts: string[];
+    toolMetas: ToolMetaEntry[];
+    lastAssistant: AssistantMessage | undefined;
+    lastToolError?: LastToolError;
+    config?: OpenClawConfig;
+    sessionKey: string;
+    provider?: string;
+    model?: string;
+    verboseLevel?: VerboseLevel;
+    reasoningLevel?: ReasoningLevel;
+    toolResultFormat?: ToolResultFormat;
+    suppressToolErrorWarnings?: boolean;
+    inlineToolResultsAllowed: boolean;
+    didSendViaMessagingTool?: boolean;
+    didSendDeterministicApprovalPrompt?: boolean;
+}): Array<{
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    replyToId?: string;
+    isError?: boolean;
+    isReasoning?: boolean;
+    audioAsVoice?: boolean;
+    replyToTag?: boolean;
+    replyToCurrent?: boolean;
+}>;
+export {};

package/dist/src/agents/pi-embedded-runner/run/types.d.ts

@@ -0,0 +1,70 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { Api, AssistantMessage, Model } from "@mariozechner/pi-ai";
+import type { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import type { ThinkLevel } from "../../../auto-reply/thinking.js";
+import type { SessionSystemPromptReport } from "../../../config/sessions/types.js";
+import type { ContextEngine } from "../../../context-engine/types.js";
+import type { PluginHookBeforeAgentStartResult } from "../../../plugins/types.js";
+import type { MessagingToolSend } from "../../pi-embedded-messaging.js";
+import type { NormalizedUsage } from "../../usage.js";
+import type { RunEmbeddedPiAgentParams } from "./params.js";
+type EmbeddedRunAttemptBase = Omit<RunEmbeddedPiAgentParams, "provider" | "model" | "authProfileId" | "authProfileIdSource" | "thinkLevel" | "lane" | "enqueue">;
+export type EmbeddedRunAttemptParams = EmbeddedRunAttemptBase & {
+    /** Pluggable context engine for ingest/assemble/compact lifecycle. */
+    contextEngine?: ContextEngine;
+    /** Resolved model context window in tokens for assemble/compact budgeting. */
+    contextTokenBudget?: number;
+    /** Auth profile resolved for this attempt's provider/model call. */
+    authProfileId?: string;
+    /** Source for the resolved auth profile (user-locked or automatic). */
+    authProfileIdSource?: "auto" | "user";
+    provider: string;
+    modelId: string;
+    model: Model<Api>;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+    thinkLevel: ThinkLevel;
+    legacyBeforeAgentStartResult?: PluginHookBeforeAgentStartResult;
+};
+export type EmbeddedRunAttemptResult = {
+    aborted: boolean;
+    timedOut: boolean;
+    /** True if the timeout occurred while compaction was in progress or pending. */
+    timedOutDuringCompaction: boolean;
+    promptError: unknown;
+    sessionIdUsed: string;
+    bootstrapPromptWarningSignaturesSeen?: string[];
+    bootstrapPromptWarningSignature?: string;
+    systemPromptReport?: SessionSystemPromptReport;
+    messagesSnapshot: AgentMessage[];
+    assistantTexts: string[];
+    toolMetas: Array<{
+        toolName: string;
+        meta?: string;
+    }>;
+    lastAssistant: AssistantMessage | undefined;
+    lastToolError?: {
+        toolName: string;
+        meta?: string;
+        error?: string;
+        mutatingAction?: boolean;
+        actionFingerprint?: string;
+    };
+    didSendViaMessagingTool: boolean;
+    didSendDeterministicApprovalPrompt?: boolean;
+    messagingToolSentTexts: string[];
+    messagingToolSentMediaUrls: string[];
+    messagingToolSentTargets: MessagingToolSend[];
+    successfulCronAdds?: number;
+    cloudCodeAssistFormatError: boolean;
+    attemptUsage?: NormalizedUsage;
+    compactionCount?: number;
+    /** Client tool call detected (OpenResponses hosted tools). */
+    clientToolCall?: {
+        name: string;
+        params: Record<string, unknown>;
+    };
+    /** True when sessions_yield tool was called during this attempt. */
+    yieldDetected?: boolean;
+};
+export {};

package/dist/src/agents/pi-embedded-runner/run.d.ts

@@ -0,0 +1,3 @@
+import type { RunEmbeddedPiAgentParams } from "./run/params.js";
+import type { EmbeddedPiRunResult } from "./types.js";
+export declare function runEmbeddedPiAgent(params: RunEmbeddedPiAgentParams): Promise<EmbeddedPiRunResult>;

package/dist/src/agents/pi-embedded-runner/runs.d.ts

@@ -0,0 +1,45 @@
+type EmbeddedPiQueueHandle = {
+    queueMessage: (text: string) => Promise<void>;
+    isStreaming: () => boolean;
+    isCompacting: () => boolean;
+    abort: () => void;
+};
+export type ActiveEmbeddedRunSnapshot = {
+    transcriptLeafId: string | null;
+    messages?: unknown[];
+    inFlightPrompt?: string;
+};
+export declare function queueEmbeddedPiMessage(sessionId: string, text: string): boolean;
+/**
+ * Abort embedded PI runs.
+ *
+ * - With a sessionId, aborts that single run.
+ * - With no sessionId, supports targeted abort modes (for example, compacting runs only).
+ */
+export declare function abortEmbeddedPiRun(sessionId: string): boolean;
+export declare function abortEmbeddedPiRun(sessionId: undefined, opts: {
+    mode: "all" | "compacting";
+}): boolean;
+export declare function isEmbeddedPiRunActive(sessionId: string): boolean;
+export declare function isEmbeddedPiRunStreaming(sessionId: string): boolean;
+export declare function getActiveEmbeddedRunCount(): number;
+export declare function getActiveEmbeddedRunSnapshot(sessionId: string): ActiveEmbeddedRunSnapshot | undefined;
+/**
+ * Wait for active embedded runs to drain.
+ *
+ * Used during restarts so in-flight compaction runs can release session write
+ * locks before the next lifecycle starts.
+ */
+export declare function waitForActiveEmbeddedRuns(timeoutMs?: number, opts?: {
+    pollMs?: number;
+}): Promise<{
+    drained: boolean;
+}>;
+export declare function waitForEmbeddedPiRunEnd(sessionId: string, timeoutMs?: number): Promise<boolean>;
+export declare function setActiveEmbeddedRun(sessionId: string, handle: EmbeddedPiQueueHandle, sessionKey?: string): void;
+export declare function updateActiveEmbeddedRunSnapshot(sessionId: string, snapshot: ActiveEmbeddedRunSnapshot): void;
+export declare function clearActiveEmbeddedRun(sessionId: string, handle: EmbeddedPiQueueHandle, sessionKey?: string): void;
+export declare const __testing: {
+    resetActiveEmbeddedRuns(): void;
+};
+export type { EmbeddedPiQueueHandle };

package/dist/src/agents/pi-embedded-runner/sandbox-info.d.ts

@@ -0,0 +1,4 @@
+import type { ExecElevatedDefaults } from "../bash-tools.js";
+import type { resolveSandboxContext } from "../sandbox.js";
+import type { EmbeddedSandboxInfo } from "./types.js";
+export declare function buildEmbeddedSandboxInfo(sandbox?: Awaited<ReturnType<typeof resolveSandboxContext>>, execElevated?: ExecElevatedDefaults): EmbeddedSandboxInfo | undefined;

package/dist/src/agents/pi-embedded-runner/session-manager-cache.d.ts

@@ -0,0 +1,2 @@
+export declare function trackSessionManagerAccess(sessionFile: string): void;
+export declare function prewarmSessionFile(sessionFile: string): Promise<void>;

package/dist/src/agents/pi-embedded-runner/session-manager-init.d.ts

@@ -0,0 +1,17 @@
+/**
+ * pi-coding-agent SessionManager persistence quirk:
+ * - If the file exists but has no assistant message, SessionManager marks itself `flushed=true`
+ *   and will never persist the initial user message.
+ * - If the file doesn't exist yet, SessionManager builds a new session in memory and flushes
+ *   header+user+assistant once the first assistant arrives (good).
+ *
+ * This normalizes the file/session state so the first user prompt is persisted before the first
+ * assistant entry, even for pre-created session files.
+ */
+export declare function prepareSessionManagerForRun(params: {
+    sessionManager: unknown;
+    sessionFile: string;
+    hadSessionFile: boolean;
+    sessionId: string;
+    cwd: string;
+}): Promise<void>;

package/dist/src/agents/pi-embedded-runner/skills-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import { type SkillEntry, type SkillSnapshot } from "../skills.js";
+export declare function resolveEmbeddedRunSkillEntries(params: {
+    workspaceDir: string;
+    config?: OpenClawConfig;
+    skillsSnapshot?: SkillSnapshot;
+}): {
+    shouldLoadSkillEntries: boolean;
+    skillEntries: SkillEntry[];
+};

package/dist/src/agents/pi-embedded-runner/stream-payload-utils.d.ts

@@ -0,0 +1,2 @@
+import type { StreamFn } from "@mariozechner/pi-agent-core";
+export declare function streamWithPayloadPatch(underlying: StreamFn, model: Parameters<StreamFn>[0], context: Parameters<StreamFn>[1], options: Parameters<StreamFn>[2], patchPayload: (payload: Record<string, unknown>) => void): import("@mariozechner/pi-ai").AssistantMessageEventStream | Promise<import("@mariozechner/pi-ai").AssistantMessageEventStream>;

package/dist/src/agents/pi-embedded-runner/system-prompt.d.ts

@@ -0,0 +1,55 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { MemoryCitationsMode } from "../../config/types.memory.js";
+import type { ResolvedTimeFormat } from "../date-time.js";
+import type { EmbeddedContextFile } from "../pi-embedded-helpers.js";
+import { type PromptMode } from "../system-prompt.js";
+import type { EmbeddedSandboxInfo } from "./types.js";
+import type { ReasoningLevel, ThinkLevel } from "./utils.js";
+export declare function buildEmbeddedSystemPrompt(params: {
+    workspaceDir: string;
+    defaultThinkLevel?: ThinkLevel;
+    reasoningLevel?: ReasoningLevel;
+    extraSystemPrompt?: string;
+    ownerNumbers?: string[];
+    ownerDisplay?: "raw" | "hash";
+    ownerDisplaySecret?: string;
+    reasoningTagHint: boolean;
+    heartbeatPrompt?: string;
+    skillsPrompt?: string;
+    docsPath?: string;
+    ttsHint?: string;
+    reactionGuidance?: {
+        level: "minimal" | "extensive";
+        channel: string;
+    };
+    workspaceNotes?: string[];
+    /** Controls which hardcoded sections to include. Defaults to "full". */
+    promptMode?: PromptMode;
+    /** Whether ACP-specific routing guidance should be included. Defaults to true. */
+    acpEnabled?: boolean;
+    runtimeInfo: {
+        agentId?: string;
+        host: string;
+        os: string;
+        arch: string;
+        node: string;
+        model: string;
+        provider?: string;
+        capabilities?: string[];
+        channel?: string;
+        /** Supported message actions for the current channel (e.g., react, edit, unsend) */
+        channelActions?: string[];
+    };
+    messageToolHints?: string[];
+    sandboxInfo?: EmbeddedSandboxInfo;
+    tools: AgentTool[];
+    modelAliasLines: string[];
+    userTimezone: string;
+    userTime?: string;
+    userTimeFormat?: ResolvedTimeFormat;
+    contextFiles?: EmbeddedContextFile[];
+    memoryCitationsMode?: MemoryCitationsMode;
+}): string;
+export declare function createSystemPromptOverride(systemPrompt: string): (defaultPrompt?: string) => string;
+export declare function applySystemPromptOverrideToSession(session: AgentSession, override: string | ((defaultPrompt?: string) => string)): void;

package/dist/src/agents/pi-embedded-runner/thinking.d.ts

@@ -0,0 +1,17 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+type AssistantMessage = Extract<AgentMessage, {
+    role: "assistant";
+}>;
+export declare function isAssistantMessageWithContent(message: AgentMessage): message is AssistantMessage;
+/**
+ * Strip all `type: "thinking"` content blocks from assistant messages.
+ *
+ * If an assistant message becomes empty after stripping, it is replaced with
+ * a synthetic `{ type: "text", text: "" }` block to preserve turn structure
+ * (some providers require strict user/assistant alternation).
+ *
+ * Returns the original array reference when nothing was changed (callers can
+ * use reference equality to skip downstream work).
+ */
+export declare function dropThinkingBlocks(messages: AgentMessage[]): AgentMessage[];
+export {};

package/dist/src/agents/pi-embedded-runner/tool-name-allowlist.d.ts

@@ -0,0 +1,6 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { ClientToolDefinition } from "./run/params.js";
+export declare function collectAllowedToolNames(params: {
+    tools: AgentTool[];
+    clientTools?: ClientToolDefinition[];
+}): Set<string>;