@gguf/pigbot 0.0.5 → 0.0.7

package/dist/agents/models-config.providers.js

@@ -4,7 +4,7 @@ import { resolveAwsSdkEnvVarName, resolveEnvApiKey } from "./model-auth.js";
 import { discoverBedrockModels } from "./bedrock-discovery.js";
 import { buildSyntheticModelDefinition, SYNTHETIC_BASE_URL, SYNTHETIC_MODEL_CATALOG, } from "./synthetic-models.js";
 import { discoverVeniceModels, VENICE_BASE_URL } from "./venice-models.js";
-const MINIMAX_API_BASE_URL = "https://api.minimax.io/anthropic";
+const MINIMAX_API_BASE_URL = "https://api.minimax.chat/v1";
 const MINIMAX_DEFAULT_MODEL_ID = "MiniMax-M2.1";
 const MINIMAX_DEFAULT_VISION_MODEL_ID = "MiniMax-VL-01";
 const MINIMAX_DEFAULT_CONTEXT_WINDOW = 200000;
@@ -16,8 +16,18 @@ const MINIMAX_API_COST = {
     cacheRead: 2,
     cacheWrite: 10,
 };
+const XIAOMI_BASE_URL = "https://api.xiaomimimo.com/anthropic";
+export const XIAOMI_DEFAULT_MODEL_ID = "mimo-v2-flash";
+const XIAOMI_DEFAULT_CONTEXT_WINDOW = 262144;
+const XIAOMI_DEFAULT_MAX_TOKENS = 8192;
+const XIAOMI_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
 const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
-const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2-0905-preview";
+const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2.5";
 const MOONSHOT_DEFAULT_CONTEXT_WINDOW = 256000;
 const MOONSHOT_DEFAULT_MAX_TOKENS = 8192;
 const MOONSHOT_DEFAULT_COST = {
@@ -198,7 +208,7 @@ export function normalizeProviders(params) {
 function buildMinimaxProvider() {
     return {
         baseUrl: MINIMAX_API_BASE_URL,
-        api: "anthropic-messages",
+        api: "openai-completions",
         models: [
             {
                 id: MINIMAX_DEFAULT_MODEL_ID,
@@ -228,7 +238,7 @@ function buildMoonshotProvider() {
         models: [
             {
                 id: MOONSHOT_DEFAULT_MODEL_ID,
-                name: "Kimi K2 0905 Preview",
+                name: "Kimi K2.5",
                 reasoning: false,
                 input: ["text"],
                 cost: MOONSHOT_DEFAULT_COST,
@@ -290,6 +300,23 @@ function buildSyntheticProvider() {
         models: SYNTHETIC_MODEL_CATALOG.map(buildSyntheticModelDefinition),
     };
 }
+export function buildXiaomiProvider() {
+    return {
+        baseUrl: XIAOMI_BASE_URL,
+        api: "anthropic-messages",
+        models: [
+            {
+                id: XIAOMI_DEFAULT_MODEL_ID,
+                name: "Xiaomi MiMo V2 Flash",
+                reasoning: false,
+                input: ["text"],
+                cost: XIAOMI_DEFAULT_COST,
+                contextWindow: XIAOMI_DEFAULT_CONTEXT_WINDOW,
+                maxTokens: XIAOMI_DEFAULT_MAX_TOKENS,
+            },
+        ],
+    };
+}
 async function buildVeniceProvider() {
     const models = await discoverVeniceModels();
     return {
@@ -343,6 +370,11 @@ export async function resolveImplicitProviders(params) {
             apiKey: QWEN_PORTAL_OAUTH_PLACEHOLDER,
         };
     }
+    const xiaomiKey = resolveEnvApiKeyVarName("xiaomi") ??
+        resolveApiKeyFromProfiles({ provider: "xiaomi", store: authStore });
+    if (xiaomiKey) {
+        providers.xiaomi = { ...buildXiaomiProvider(), apiKey: xiaomiKey };
+    }
     // Ollama provider - only add if explicitly configured
     const ollamaKey = resolveEnvApiKeyVarName("ollama") ??
         resolveApiKeyFromProfiles({ provider: "ollama", store: authStore });
@@ -384,15 +416,15 @@ export async function resolveImplicitCopilotProvider(params) {
     }
     // pi-coding-agent's ModelRegistry marks a model "available" only if its
     // `AuthStorage` has auth configured for that provider (via auth.json/env/etc).
-    // Our Copilot auth lives in Moltbot's auth-profiles store instead, so we also
+    // Our Copilot auth lives in OpenClaw's auth-profiles store instead, so we also
     // write a runtime-only auth.json entry for pi-coding-agent to pick up.
     //
-    // This is safe because it's (1) within Moltbot's agent dir, (2) contains the
+    // This is safe because it's (1) within OpenClaw's agent dir, (2) contains the
     // GitHub token (not the exchanged Copilot token), and (3) matches existing
     // patterns for OAuth-like providers in pi-coding-agent.
     // Note: we deliberately do not write pi-coding-agent's `auth.json` here.
-    // Moltbot uses its own auth store and exchanges tokens at runtime.
-    // `models list` uses Moltbot's auth heuristics for availability.
+    // OpenClaw uses its own auth store and exchanges tokens at runtime.
+    // `models list` uses OpenClaw's auth heuristics for availability.
     // We intentionally do NOT define custom models for Copilot in models.json.
     // pi-coding-agent treats providers with models as replacements requiring apiKey.
     // We only override baseUrl; the model list comes from pi-ai built-ins.

package/dist/agents/{moltbot-tools.js → openclaw-tools.js}

@@ -15,7 +15,7 @@ import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
 import { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
 import { createWebFetchTool, createWebSearchTool } from "./tools/web-tools.js";
 import { createTtsTool } from "./tools/tts-tool.js";
-export function createMoltbotTools(options) {
+export function createOpenClawTools(options) {
     const imageTool = options?.agentDir?.trim()
         ? createImageTool({
             config: options?.config,

package/dist/agents/pi-embedded-helpers/errors.js

@@ -348,6 +348,7 @@ const ERROR_PATTERNS = {
 };
 const IMAGE_DIMENSION_ERROR_RE = /image dimensions exceed max allowed size for many-image requests:\s*(\d+)\s*pixels/i;
 const IMAGE_DIMENSION_PATH_RE = /messages\.(\d+)\.content\.(\d+)\.image/i;
+const IMAGE_SIZE_ERROR_RE = /image exceeds\s*(\d+(?:\.\d+)?)\s*mb/i;
 function matchesErrorPatterns(raw, patterns) {
     if (!raw)
         return false;
@@ -401,6 +402,23 @@ export function parseImageDimensionError(raw) {
 export function isImageDimensionErrorMessage(raw) {
     return Boolean(parseImageDimensionError(raw));
 }
+export function parseImageSizeError(raw) {
+    if (!raw)
+        return null;
+    const lower = raw.toLowerCase();
+    if (!lower.includes("image exceeds") || !lower.includes("mb"))
+        return null;
+    const match = raw.match(IMAGE_SIZE_ERROR_RE);
+    return {
+        maxMb: match?.[1] ? Number.parseFloat(match[1]) : undefined,
+        raw,
+    };
+}
+export function isImageSizeError(errorMessage) {
+    if (!errorMessage)
+        return false;
+    return Boolean(parseImageSizeError(errorMessage));
+}
 export function isCloudCodeAssistFormatError(raw) {
     return !isImageDimensionErrorMessage(raw) && matchesErrorPatterns(raw, ERROR_PATTERNS.format);
 }
@@ -412,6 +430,8 @@ export function isAuthAssistantError(msg) {
 export function classifyFailoverReason(raw) {
     if (isImageDimensionErrorMessage(raw))
         return null;
+    if (isImageSizeError(raw))
+        return null;
     if (isRateLimitErrorMessage(raw))
         return "rate_limit";
     if (isOverloadedErrorMessage(raw))

package/dist/agents/pi-embedded-helpers/openai.js

@@ -41,7 +41,7 @@ function hasFollowingNonThinkingBlock(content, index) {
  * OpenAI Responses API can reject transcripts that contain a standalone `reasoning` item id
  * without the required following item.
  *
- * Moltbot persists provider-specific reasoning metadata in `thinkingSignature`; if that metadata
+ * OpenClaw persists provider-specific reasoning metadata in `thinkingSignature`; if that metadata
  * is incomplete, drop the block to keep history usable.
  */
 export function downgradeOpenAIReasoningBlocks(messages) {

package/dist/agents/pi-embedded-helpers.js

@@ -1,5 +1,5 @@
 export { buildBootstrapContextFiles, DEFAULT_BOOTSTRAP_MAX_CHARS, ensureSessionHeader, resolveBootstrapMaxChars, stripThoughtSignatures, } from "./pi-embedded-helpers/bootstrap.js";
-export { classifyFailoverReason, formatRawAssistantErrorForUi, formatAssistantErrorText, getApiErrorPayloadFingerprint, isAuthAssistantError, isAuthErrorMessage, isBillingAssistantError, parseApiErrorInfo, sanitizeUserFacingText, isBillingErrorMessage, isCloudCodeAssistFormatError, isCompactionFailureError, isContextOverflowError, isLikelyContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, isImageDimensionErrorMessage, isOverloadedErrorMessage, isRawApiErrorPayload, isRateLimitAssistantError, isRateLimitErrorMessage, isTimeoutErrorMessage, parseImageDimensionError, } from "./pi-embedded-helpers/errors.js";
+export { classifyFailoverReason, formatRawAssistantErrorForUi, formatAssistantErrorText, getApiErrorPayloadFingerprint, isAuthAssistantError, isAuthErrorMessage, isBillingAssistantError, parseApiErrorInfo, sanitizeUserFacingText, isBillingErrorMessage, isCloudCodeAssistFormatError, isCompactionFailureError, isContextOverflowError, isLikelyContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, isImageDimensionErrorMessage, isImageSizeError, isOverloadedErrorMessage, isRawApiErrorPayload, isRateLimitAssistantError, isRateLimitErrorMessage, isTimeoutErrorMessage, parseImageDimensionError, parseImageSizeError, } from "./pi-embedded-helpers/errors.js";
 export { isGoogleModelApi, sanitizeGoogleTurnOrdering } from "./pi-embedded-helpers/google.js";
 export { downgradeOpenAIReasoningBlocks } from "./pi-embedded-helpers/openai.js";
 export { isEmptyAssistantMessageContent, sanitizeSessionMessagesImages, } from "./pi-embedded-helpers/images.js";

package/dist/agents/pi-embedded-runner/cache-ttl.js

@@ -1,4 +1,4 @@
-export const CACHE_TTL_CUSTOM_TYPE = "moltbot.cache-ttl";
+export const CACHE_TTL_CUSTOM_TYPE = "openclaw.cache-ttl";
 export function isCacheTtlEligibleProvider(provider, modelId) {
     const normalizedProvider = provider.toLowerCase();
     const normalizedModelId = modelId.toLowerCase();

package/dist/agents/pi-embedded-runner/compact.js

@@ -13,16 +13,16 @@ import { normalizeMessageChannel } from "../../utils/message-channel.js";
 import { isSubagentSessionKey } from "../../routing/session-key.js";
 import { isReasoningTagProvider } from "../../utils/provider-utils.js";
 import { resolveUserPath } from "../../utils.js";
-import { resolveMoltbotAgentDir } from "../agent-paths.js";
+import { resolveOpenClawAgentDir } from "../agent-paths.js";
 import { resolveSessionAgentIds } from "../agent-scope.js";
 import { makeBootstrapWarn, resolveBootstrapContextForRun } from "../bootstrap-files.js";
-import { resolveMoltbotDocsPath } from "../docs-path.js";
+import { resolveOpenClawDocsPath } from "../docs-path.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
 import { getApiKeyForModel, resolveModelAuthMode } from "../model-auth.js";
-import { ensureMoltbotModelsJson } from "../models-config.js";
+import { ensureOpenClawModelsJson } from "../models-config.js";
 import { ensureSessionHeader, validateAnthropicTurns, validateGeminiTurns, } from "../pi-embedded-helpers.js";
 import { ensurePiCompactionReserveTokens, resolveCompactionReserveTokensFloor, } from "../pi-settings.js";
-import { createMoltbotCodingTools } from "../pi-tools.js";
+import { createOpenClawCodingTools } from "../pi-tools.js";
 import { resolveSandboxContext } from "../sandbox.js";
 import { guardSessionManager } from "../session-tool-result-guard-wrapper.js";
 import { resolveTranscriptPolicy } from "../transcript-policy.js";
@@ -50,8 +50,8 @@ export async function compactEmbeddedPiSessionDirect(params) {
     const prevCwd = process.cwd();
     const provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
     const modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
-    const agentDir = params.agentDir ?? resolveMoltbotAgentDir();
-    await ensureMoltbotModelsJson(params.config, agentDir);
+    const agentDir = params.agentDir ?? resolveOpenClawAgentDir();
+    await ensureOpenClawModelsJson(params.config, agentDir);
     const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
     if (!model) {
         return {
@@ -139,7 +139,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
             warn: makeBootstrapWarn({ sessionLabel, warn: (message) => log.warn(message) }),
         });
         const runAbortController = new AbortController();
-        const toolsRaw = createMoltbotCodingTools({
+        const toolsRaw = createOpenClawCodingTools({
             exec: {
                 ...resolveExecToolDefaults(params.config),
                 elevated: params.bashElevated,
@@ -240,7 +240,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
         });
         const isDefaultAgent = sessionAgentId === defaultAgentId;
         const promptMode = isSubagentSessionKey(params.sessionKey) ? "minimal" : "full";
-        const docsPath = await resolveMoltbotDocsPath({
+        const docsPath = await resolveOpenClawDocsPath({
             workspaceDir: effectiveWorkspace,
             argv1: process.argv[1],
             cwd: process.cwd(),

package/dist/agents/pi-embedded-runner/model.js

@@ -1,5 +1,5 @@
 import { discoverAuthStorage, discoverModels } from "@mariozechner/pi-coding-agent";
-import { resolveMoltbotAgentDir } from "../agent-paths.js";
+import { resolveOpenClawAgentDir } from "../agent-paths.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../defaults.js";
 import { normalizeModelCompat } from "../model-compat.js";
 import { normalizeProviderId } from "../model-selection.js";
@@ -33,7 +33,7 @@ export function buildModelAliasLines(cfg) {
         .map((entry) => `- ${entry.alias}: ${entry.model}`);
 }
 export function resolveModel(provider, modelId, agentDir, cfg) {
-    const resolvedAgentDir = agentDir ?? resolveMoltbotAgentDir();
+    const resolvedAgentDir = agentDir ?? resolveOpenClawAgentDir();
     const authStorage = discoverAuthStorage(resolvedAgentDir);
     const modelRegistry = discoverModels(authStorage, resolvedAgentDir);
     const model = modelRegistry.find(provider, modelId);

package/dist/agents/pi-embedded-runner/run/attempt.js

@@ -15,15 +15,15 @@ import { isSubagentSessionKey } from "../../../routing/session-key.js";
 import { resolveUserPath } from "../../../utils.js";
 import { createCacheTrace } from "../../cache-trace.js";
 import { createAnthropicPayloadLogger } from "../../anthropic-payload-log.js";
-import { resolveMoltbotAgentDir } from "../../agent-paths.js";
+import { resolveOpenClawAgentDir } from "../../agent-paths.js";
 import { resolveSessionAgentIds } from "../../agent-scope.js";
 import { makeBootstrapWarn, resolveBootstrapContextForRun } from "../../bootstrap-files.js";
-import { resolveMoltbotDocsPath } from "../../docs-path.js";
+import { resolveOpenClawDocsPath } from "../../docs-path.js";
 import { resolveModelAuthMode } from "../../model-auth.js";
 import { isCloudCodeAssistFormatError, resolveBootstrapMaxChars, validateAnthropicTurns, validateGeminiTurns, } from "../../pi-embedded-helpers.js";
 import { subscribeEmbeddedPiSession } from "../../pi-embedded-subscribe.js";
 import { ensurePiCompactionReserveTokens, resolveCompactionReserveTokensFloor, } from "../../pi-settings.js";
-import { createMoltbotCodingTools } from "../../pi-tools.js";
+import { createOpenClawCodingTools } from "../../pi-tools.js";
 import { resolveSandboxContext } from "../../sandbox.js";
 import { guardSessionManager } from "../../session-tool-result-guard-wrapper.js";
 import { resolveTranscriptPolicy } from "../../transcript-policy.js";
@@ -141,12 +141,12 @@ export async function runEmbeddedAttempt(params) {
         const workspaceNotes = hookAdjustedBootstrapFiles.some((file) => file.name === DEFAULT_BOOTSTRAP_FILENAME && !file.missing)
             ? ["Reminder: commit your changes in this workspace after edits."]
             : undefined;
-        const agentDir = params.agentDir ?? resolveMoltbotAgentDir();
+        const agentDir = params.agentDir ?? resolveOpenClawAgentDir();
         // Check if the model supports native image input
         const modelHasVision = params.model.input?.includes("image") ?? false;
         const toolsRaw = params.disableTools
             ? []
-            : createMoltbotCodingTools({
+            : createOpenClawCodingTools({
                 exec: {
                     ...params.execOverrides,
                     elevated: params.bashElevated,
@@ -267,7 +267,7 @@ export async function runEmbeddedAttempt(params) {
         });
         const isDefaultAgent = sessionAgentId === defaultAgentId;
         const promptMode = isSubagentSessionKey(params.sessionKey) ? "minimal" : "full";
-        const docsPath = await resolveMoltbotDocsPath({
+        const docsPath = await resolveOpenClawDocsPath({
             workspaceDir: effectiveWorkspace,
             argv1: process.argv[1],
             cwd: process.cwd(),

package/dist/agents/pi-embedded-runner/run.js

@@ -2,15 +2,15 @@ import fs from "node:fs/promises";
 import { enqueueCommandInLane } from "../../process/command-queue.js";
 import { resolveUserPath } from "../../utils.js";
 import { isMarkdownCapableMessageChannel } from "../../utils/message-channel.js";
-import { resolveMoltbotAgentDir } from "../agent-paths.js";
+import { resolveOpenClawAgentDir } from "../agent-paths.js";
 import { isProfileInCooldown, markAuthProfileFailure, markAuthProfileGood, markAuthProfileUsed, } from "../auth-profiles.js";
 import { CONTEXT_WINDOW_HARD_MIN_TOKENS, CONTEXT_WINDOW_WARN_BELOW_TOKENS, evaluateContextWindowGuard, resolveContextWindowInfo, } from "../context-window-guard.js";
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
 import { FailoverError, resolveFailoverStatus } from "../failover-error.js";
 import { ensureAuthProfileStore, getApiKeyForModel, resolveAuthProfileOrder, } from "../model-auth.js";
 import { normalizeProviderId } from "../model-selection.js";
-import { ensureMoltbotModelsJson } from "../models-config.js";
-import { classifyFailoverReason, formatAssistantErrorText, isAuthAssistantError, isCompactionFailureError, isContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, parseImageDimensionError, isRateLimitAssistantError, isTimeoutErrorMessage, pickFallbackThinkingLevel, } from "../pi-embedded-helpers.js";
+import { ensureOpenClawModelsJson } from "../models-config.js";
+import { classifyFailoverReason, formatAssistantErrorText, isAuthAssistantError, isCompactionFailureError, isContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, parseImageSizeError, parseImageDimensionError, isRateLimitAssistantError, isTimeoutErrorMessage, pickFallbackThinkingLevel, } from "../pi-embedded-helpers.js";
 import { normalizeUsage } from "../usage.js";
 import { compactEmbeddedPiSessionDirect } from "./compact.js";
 import { resolveGlobalLane, resolveSessionLane } from "./lanes.js";
@@ -46,9 +46,9 @@ export async function runEmbeddedPiAgent(params) {
         const prevCwd = process.cwd();
         const provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
         const modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
-        const agentDir = params.agentDir ?? resolveMoltbotAgentDir();
+        const agentDir = params.agentDir ?? resolveOpenClawAgentDir();
         const fallbackConfigured = (params.config?.agents?.defaults?.model?.fallbacks?.length ?? 0) > 0;
-        await ensureMoltbotModelsJson(params.config, agentDir);
+        await ensureOpenClawModelsJson(params.config, agentDir);
         const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
         if (!model) {
             throw new Error(error ?? `Unknown model: ${provider}/${modelId}`);
@@ -351,6 +351,32 @@ export async function runEmbeddedPiAgent(params) {
                             },
                         };
                     }
+                    // Handle image size errors with a user-friendly message (no retry needed)
+                    const imageSizeError = parseImageSizeError(errorText);
+                    if (imageSizeError) {
+                        const maxMb = imageSizeError.maxMb;
+                        const maxMbLabel = typeof maxMb === "number" && Number.isFinite(maxMb) ? `${maxMb}` : null;
+                        const maxBytesHint = maxMbLabel ? ` (max ${maxMbLabel}MB)` : "";
+                        return {
+                            payloads: [
+                                {
+                                    text: `Image too large for the model${maxBytesHint}. ` +
+                                        "Please compress or resize the image and try again.",
+                                    isError: true,
+                                },
+                            ],
+                            meta: {
+                                durationMs: Date.now() - started,
+                                agentMeta: {
+                                    sessionId: sessionIdUsed,
+                                    provider,
+                                    model: model.id,
+                                },
+                                systemPromptReport: attempt.systemPromptReport,
+                                error: { kind: "image_size", message: errorText },
+                            },
+                        };
+                    }
                     const promptFailoverReason = classifyFailoverReason(errorText);
                     if (promptFailoverReason && promptFailoverReason !== "timeout" && lastProfileId) {
                         await markAuthProfileFailure({

package/dist/agents/pi-embedded-runner/session-manager-cache.js

@@ -5,7 +5,7 @@ const SESSION_MANAGER_CACHE = new Map();
 const DEFAULT_SESSION_MANAGER_TTL_MS = 45_000; // 45 seconds
 function getSessionManagerTtl() {
     return resolveCacheTtlMs({
-        envValue: process.env.CLAWDBOT_SESSION_MANAGER_CACHE_TTL_MS,
+        envValue: process.env.OPENCLAW_SESSION_MANAGER_CACHE_TTL_MS,
         defaultTtlMs: DEFAULT_SESSION_MANAGER_TTL_MS,
     });
 }

package/dist/agents/pi-embedded-runner/utils.js

@@ -1,5 +1,5 @@
 export function mapThinkingLevel(level) {
-    // pi-agent-core supports "xhigh"; Moltbot enables it for specific models.
+    // pi-agent-core supports "xhigh"; OpenClaw enables it for specific models.
     if (!level)
         return "off";
     return level;

package/dist/agents/pi-embedded-subscribe.raw-stream.js

@@ -2,8 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveStateDir } from "../config/paths.js";
 import { isTruthyEnvValue } from "../infra/env.js";
-const RAW_STREAM_ENABLED = isTruthyEnvValue(process.env.CLAWDBOT_RAW_STREAM);
-const RAW_STREAM_PATH = process.env.CLAWDBOT_RAW_STREAM_PATH?.trim() ||
+const RAW_STREAM_ENABLED = isTruthyEnvValue(process.env.OPENCLAW_RAW_STREAM);
+const RAW_STREAM_PATH = process.env.OPENCLAW_RAW_STREAM_PATH?.trim() ||
     path.join(resolveStateDir(), "logs", "raw-stream.jsonl");
 let rawStreamReady = false;
 export function appendRawStream(payload) {

package/dist/agents/pi-tools.js

@@ -4,10 +4,10 @@ import { resolveGatewayMessageChannel } from "../utils/message-channel.js";
 import { createApplyPatchTool } from "./apply-patch.js";
 import { createExecTool, createProcessTool, } from "./bash-tools.js";
 import { listChannelAgentTools } from "./channel-tools.js";
-import { createMoltbotTools } from "./moltbot-tools.js";
+import { createOpenClawTools } from "./openclaw-tools.js";
 import { wrapToolWithAbortSignal } from "./pi-tools.abort.js";
 import { filterToolsByPolicy, isToolAllowedByPolicies, resolveEffectiveToolPolicy, resolveGroupToolPolicy, resolveSubagentToolPolicy, } from "./pi-tools.policy.js";
-import { assertRequiredParams, CLAUDE_PARAM_GROUPS, createMoltbotReadTool, createSandboxedEditTool, createSandboxedReadTool, createSandboxedWriteTool, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization, } from "./pi-tools.read.js";
+import { assertRequiredParams, CLAUDE_PARAM_GROUPS, createOpenClawReadTool, createSandboxedEditTool, createSandboxedReadTool, createSandboxedWriteTool, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization, } from "./pi-tools.read.js";
 import { cleanToolSchemaForGemini, normalizeToolParameters } from "./pi-tools.schema.js";
 import { buildPluginToolGroups, collectExplicitAllowlist, expandPolicyWithPluginGroups, normalizeToolName, resolveToolProfilePolicy, stripPluginOnlyAllowlist, } from "./tool-policy.js";
 import { getPluginToolMeta } from "../plugins/tools.js";
@@ -59,7 +59,7 @@ export const __testing = {
     wrapToolParamNormalization,
     assertRequiredParams,
 };
-export function createMoltbotCodingTools(options) {
+export function createOpenClawCodingTools(options) {
     const execToolName = "exec";
     const sandbox = options?.sandbox?.enabled ? options.sandbox : undefined;
     const { agentId, globalPolicy, globalProviderPolicy, agentPolicy, agentProviderPolicy, profile, providerProfile, profileAlsoAllow, providerProfileAlsoAllow, } = resolveEffectiveToolPolicy({
@@ -124,7 +124,7 @@ export function createMoltbotCodingTools(options) {
                 return [createSandboxedReadTool(sandboxRoot)];
             }
             const freshReadTool = createReadTool(workspaceRoot);
-            return [createMoltbotReadTool(freshReadTool)];
+            return [createOpenClawReadTool(freshReadTool)];
         }
         if (tool.name === "bash" || tool.name === execToolName)
             return [];
@@ -194,7 +194,7 @@ export function createMoltbotCodingTools(options) {
         processTool,
         // Channel docking: include channel-defined agent tools (login, etc.).
         ...listChannelAgentTools({ cfg: options?.config }),
-        ...createMoltbotTools({
+        ...createOpenClawTools({
             sandboxBrowserBridgeUrl: sandbox?.browser?.bridgeUrl,
             allowHostBrowserControl: sandbox ? sandbox.browserAllowHostControl : true,
             agentSessionKey: options?.sessionKey,

package/dist/agents/pi-tools.read.js

@@ -199,7 +199,7 @@ function wrapSandboxPathGuard(tool, root) {
 }
 export function createSandboxedReadTool(root) {
     const base = createReadTool(root);
-    return wrapSandboxPathGuard(createMoltbotReadTool(base), root);
+    return wrapSandboxPathGuard(createOpenClawReadTool(base), root);
 }
 export function createSandboxedWriteTool(root) {
     const base = createWriteTool(root);
@@ -209,7 +209,7 @@ export function createSandboxedEditTool(root) {
     const base = createEditTool(root);
     return wrapSandboxPathGuard(wrapToolParamNormalization(base, CLAUDE_PARAM_GROUPS.edit), root);
 }
-export function createMoltbotReadTool(base) {
+export function createOpenClawReadTool(base) {
     const patched = patchToolSchemaForClaudeCompatibility(base);
     return {
         ...patched,

package/dist/agents/sandbox/browser.js

@@ -1,6 +1,6 @@
 import { startBrowserBridgeServer, stopBrowserBridgeServer } from "../../browser/bridge-server.js";
 import { resolveProfile } from "../../browser/config.js";
-import { DEFAULT_BROWSER_EVALUATE_ENABLED, DEFAULT_CLAWD_BROWSER_COLOR, } from "../../browser/constants.js";
+import { DEFAULT_BROWSER_EVALUATE_ENABLED, DEFAULT_OPENCLAW_BROWSER_COLOR, DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME, } from "../../browser/constants.js";
 import { BROWSER_BRIDGES } from "./browser-bridges.js";
 import { DEFAULT_SANDBOX_BROWSER_IMAGE, SANDBOX_AGENT_WORKSPACE_MOUNT } from "./constants.js";
 import { buildSandboxCreateArgs, dockerContainerState, execDocker, readDockerPort, } from "./docker.js";
@@ -41,14 +41,17 @@ function buildSandboxBrowserResolvedConfig(params) {
         cdpIsLoopback: true,
         remoteCdpTimeoutMs: 1500,
         remoteCdpHandshakeTimeoutMs: 3000,
-        color: DEFAULT_CLAWD_BROWSER_COLOR,
+        color: DEFAULT_OPENCLAW_BROWSER_COLOR,
         executablePath: undefined,
         headless: params.headless,
         noSandbox: false,
         attachOnly: true,
-        defaultProfile: "clawd",
+        defaultProfile: DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME,
         profiles: {
-            clawd: { cdpPort: params.cdpPort, color: DEFAULT_CLAWD_BROWSER_COLOR },
+            [DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME]: {
+                cdpPort: params.cdpPort,
+                color: DEFAULT_OPENCLAW_BROWSER_COLOR,
+            },
         },
     };
 }
@@ -75,7 +78,7 @@ export async function ensureSandboxBrowser(params) {
             name: containerName,
             cfg: params.cfg.docker,
             scopeKey: params.scopeKey,
-            labels: { "moltbot.sandboxBrowser": "1" },
+            labels: { "openclaw.sandboxBrowser": "1" },
         });
         const mainMountSuffix = params.cfg.workspaceAccess === "ro" && params.workspaceDir === params.agentWorkspaceDir
             ? ":ro"
@@ -89,11 +92,11 @@ export async function ensureSandboxBrowser(params) {
         if (params.cfg.browser.enableNoVnc && !params.cfg.browser.headless) {
             args.push("-p", `127.0.0.1::${params.cfg.browser.noVncPort}`);
         }
-        args.push("-e", `CLAWDBOT_BROWSER_HEADLESS=${params.cfg.browser.headless ? "1" : "0"}`);
-        args.push("-e", `CLAWDBOT_BROWSER_ENABLE_NOVNC=${params.cfg.browser.enableNoVnc ? "1" : "0"}`);
-        args.push("-e", `CLAWDBOT_BROWSER_CDP_PORT=${params.cfg.browser.cdpPort}`);
-        args.push("-e", `CLAWDBOT_BROWSER_VNC_PORT=${params.cfg.browser.vncPort}`);
-        args.push("-e", `CLAWDBOT_BROWSER_NOVNC_PORT=${params.cfg.browser.noVncPort}`);
+        args.push("-e", `OPENCLAW_BROWSER_HEADLESS=${params.cfg.browser.headless ? "1" : "0"}`);
+        args.push("-e", `OPENCLAW_BROWSER_ENABLE_NOVNC=${params.cfg.browser.enableNoVnc ? "1" : "0"}`);
+        args.push("-e", `OPENCLAW_BROWSER_CDP_PORT=${params.cfg.browser.cdpPort}`);
+        args.push("-e", `OPENCLAW_BROWSER_VNC_PORT=${params.cfg.browser.vncPort}`);
+        args.push("-e", `OPENCLAW_BROWSER_NOVNC_PORT=${params.cfg.browser.noVncPort}`);
         args.push(params.cfg.browser.image);
         await execDocker(args);
         await execDocker(["start", containerName]);
@@ -109,7 +112,9 @@ export async function ensureSandboxBrowser(params) {
         ? await readDockerPort(containerName, params.cfg.browser.noVncPort)
         : null;
     const existing = BROWSER_BRIDGES.get(params.scopeKey);
-    const existingProfile = existing ? resolveProfile(existing.bridge.state.resolved, "clawd") : null;
+    const existingProfile = existing
+        ? resolveProfile(existing.bridge.state.resolved, DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME)
+        : null;
     const shouldReuse = existing && existing.containerName === containerName && existingProfile?.cdpPort === mappedCdp;
     if (existing && !shouldReuse) {
         await stopBrowserBridgeServer(existing.bridge.server).catch(() => undefined);

package/dist/agents/sandbox/constants.js

@@ -2,9 +2,9 @@ import os from "node:os";
 import path from "node:path";
 import { CHANNEL_IDS } from "../../channels/registry.js";
 import { STATE_DIR } from "../../config/config.js";
-export const DEFAULT_SANDBOX_WORKSPACE_ROOT = path.join(os.homedir(), ".clawdbot", "sandboxes");
-export const DEFAULT_SANDBOX_IMAGE = "moltbot-sandbox:bookworm-slim";
-export const DEFAULT_SANDBOX_CONTAINER_PREFIX = "moltbot-sbx-";
+export const DEFAULT_SANDBOX_WORKSPACE_ROOT = path.join(os.homedir(), ".openclaw", "sandboxes");
+export const DEFAULT_SANDBOX_IMAGE = "openclaw-sandbox:bookworm-slim";
+export const DEFAULT_SANDBOX_CONTAINER_PREFIX = "openclaw-sbx-";
 export const DEFAULT_SANDBOX_WORKDIR = "/workspace";
 export const DEFAULT_SANDBOX_IDLE_HOURS = 24;
 export const DEFAULT_SANDBOX_MAX_AGE_DAYS = 7;
@@ -31,15 +31,15 @@ export const DEFAULT_TOOL_DENY = [
     "gateway",
     ...CHANNEL_IDS,
 ];
-export const DEFAULT_SANDBOX_BROWSER_IMAGE = "moltbot-sandbox-browser:bookworm-slim";
-export const DEFAULT_SANDBOX_COMMON_IMAGE = "moltbot-sandbox-common:bookworm-slim";
-export const DEFAULT_SANDBOX_BROWSER_PREFIX = "moltbot-sbx-browser-";
+export const DEFAULT_SANDBOX_BROWSER_IMAGE = "openclaw-sandbox-browser:bookworm-slim";
+export const DEFAULT_SANDBOX_COMMON_IMAGE = "openclaw-sandbox-common:bookworm-slim";
+export const DEFAULT_SANDBOX_BROWSER_PREFIX = "openclaw-sbx-browser-";
 export const DEFAULT_SANDBOX_BROWSER_CDP_PORT = 9222;
 export const DEFAULT_SANDBOX_BROWSER_VNC_PORT = 5900;
 export const DEFAULT_SANDBOX_BROWSER_NOVNC_PORT = 6080;
 export const DEFAULT_SANDBOX_BROWSER_AUTOSTART_TIMEOUT_MS = 12_000;
 export const SANDBOX_AGENT_WORKSPACE_MOUNT = "/agent";
-const resolvedSandboxStateDir = STATE_DIR ?? path.join(os.homedir(), ".clawdbot");
+const resolvedSandboxStateDir = STATE_DIR ?? path.join(os.homedir(), ".openclaw");
 export const SANDBOX_STATE_DIR = path.join(resolvedSandboxStateDir, "sandbox");
 export const SANDBOX_REGISTRY_PATH = path.join(SANDBOX_STATE_DIR, "containers.json");
 export const SANDBOX_BROWSER_REGISTRY_PATH = path.join(SANDBOX_STATE_DIR, "browsers.json");

package/dist/agents/sandbox/docker.js

@@ -102,11 +102,11 @@ function formatUlimitValue(name, value) {
 export function buildSandboxCreateArgs(params) {
     const createdAtMs = params.createdAtMs ?? Date.now();
     const args = ["create", "--name", params.name];
-    args.push("--label", "moltbot.sandbox=1");
-    args.push("--label", `moltbot.sessionKey=${params.scopeKey}`);
-    args.push("--label", `moltbot.createdAtMs=${createdAtMs}`);
+    args.push("--label", "openclaw.sandbox=1");
+    args.push("--label", `openclaw.sessionKey=${params.scopeKey}`);
+    args.push("--label", `openclaw.createdAtMs=${createdAtMs}`);
     if (params.configHash) {
-        args.push("--label", `moltbot.configHash=${params.configHash}`);
+        args.push("--label", `openclaw.configHash=${params.configHash}`);
     }
     for (const [key, value] of Object.entries(params.labels ?? {})) {
         if (key && value)
@@ -187,23 +187,26 @@ async function createSandboxContainer(params) {
     }
 }
 async function readContainerConfigHash(containerName) {
-    const result = await execDocker(["inspect", "-f", '{{ index .Config.Labels "moltbot.configHash" }}', containerName], { allowFailure: true });
-    if (result.code !== 0)
-        return null;
-    const raw = result.stdout.trim();
-    if (!raw || raw === "<no value>")
-        return null;
-    return raw;
+    const readLabel = async (label) => {
+        const result = await execDocker(["inspect", "-f", `{{ index .Config.Labels "${label}" }}`, containerName], { allowFailure: true });
+        if (result.code !== 0)
+            return null;
+        const raw = result.stdout.trim();
+        if (!raw || raw === "<no value>")
+            return null;
+        return raw;
+    };
+    return await readLabel("openclaw.configHash");
 }
 function formatSandboxRecreateHint(params) {
     if (params.scope === "session") {
-        return formatCliCommand(`moltbot sandbox recreate --session ${params.sessionKey}`);
+        return formatCliCommand(`openclaw sandbox recreate --session ${params.sessionKey}`);
     }
     if (params.scope === "agent") {
         const agentId = resolveSandboxAgentId(params.sessionKey) ?? "main";
-        return formatCliCommand(`moltbot sandbox recreate --agent ${agentId}`);
+        return formatCliCommand(`openclaw sandbox recreate --agent ${agentId}`);
     }
-    return formatCliCommand("moltbot sandbox recreate --all");
+    return formatCliCommand("openclaw sandbox recreate --all");
 }
 export async function ensureSandboxContainer(params) {
     const scopeKey = resolveSandboxScopeKey(params.cfg.scope, params.sessionKey);

package/dist/agents/sandbox/runtime-status.js

@@ -85,6 +85,6 @@ export function formatSandboxToolPolicyBlockedMessage(params) {
     if (runtime.mode === "non-main") {
         lines.push(`- Use main session key (direct): ${runtime.mainSessionKey}`);
     }
-    lines.push(`- See: ${formatCliCommand(`moltbot sandbox explain --session ${runtime.sessionKey}`)}`);
+    lines.push(`- See: ${formatCliCommand(`openclaw sandbox explain --session ${runtime.sessionKey}`)}`);
     return lines.join("\n");
 }

package/dist/agents/session-transcript-repair.js

@@ -35,7 +35,7 @@ function makeMissingToolResult(params) {
         content: [
             {
                 type: "text",
-                text: "[moltbot] missing tool result in session history; inserted synthetic error result for transcript repair.",
+                text: "[openclaw] missing tool result in session history; inserted synthetic error result for transcript repair.",
             },
         ],
         isError: true,

package/dist/agents/session-write-lock.js

@@ -22,8 +22,8 @@ function isAlive(pid) {
 function releaseAllLocksSync() {
     for (const [sessionFile, held] of HELD_LOCKS) {
         try {
-            if (typeof held.handle.fd === "number") {
-                fsSync.closeSync(held.handle.fd);
+            if (typeof held.handle.close === "function") {
+                void held.handle.close().catch(() => { });
             }
         }
         catch {